Outline: Xinu Implementation

comparison to X-kernel
socket API
threads/processes
ports
messages
buffer management
queues
sleep

Comparison to X-kernel

	Xinu	x-kernel
purpose:	education	research
OS:	primary goal	marginal
layers:	few	many
upcalls:	UPD, ICMP	pervasive
	(very limited)
receive:	queues, downcalls	upcalls
	context switches
threads:	long-lived	packet lifetime
messages:	contiguous	gather-write
proj life:	decade+	half decade

Socket APIs

the Unix API pretends everything is a file (e.g. file descriptors)
the x-kernel API pretends everything is a protocol (e.g. upcalls)
the Xinu API pretends everything is a device (e.g. the TCP device)

Xinu Socket API

TCP master device used to open connections
TCP slave devices used to communicate
read, write on slave device used to send and receive
control used for the equivalent of listen and accept
application threads are separate from the kernel threads:
- sent data goes into a queue
- received data is taken from a queue
- wake up appropriate TCP thread

Xinu Socket API examples

active open (client):

int dd = open(TCP, "128.171.10.1:333",
              ANYLPORT);
write(dd, buf, sizeof(buf));
read(dd, buf, sizeof(buf));
close(dd);

passive open (server):

int dd = open(TCP, ANYFPORT, MYPORT);
control(dd, TCPCLISTENQ, size);
while(1) {
  dd2 = control(dd, TCPCACCEPT);
  write(dd2, buf, sizeof(buf));
  read(dd2, buf, sizeof(buf));
  close(dd2);
}

Xinu threads

lightweight -- no address space changes
Xinu scheduler does round-robin on all highest-priority processes
can create, sleep, kill
mutual exclusion primitives (wait/signal)
counting semaphores

Xinu ports

a thread can suspend on a port data = preceive(port)
another thread can signal this port psend(port, data)
sender puts message in queue, blocks if queue is full
receiver blocks until some thread puts data into queue
rendez-vous mechanism
data is a single word (often a pointer)
n = pcount(port) can be used for non-blocking send
ports are thread-independent

Xinu messages

a thread can suspend: message = receive()
another thread can signal this thread: send(message, pid)
sender never blocks, will get SYSERR if nobody has done receive since the last time send was called
data is a single word (often a pointer)
recvclr() clears the waiting messages
message = recvtim(int) will return a message if send was called within the specified time, and TIMEOUT otherwise

Xinu Buffer Management

fixed-size buffers
two sizes:
- small buffers (MTU)
- large buffers (64K, max IP size)
TCP data transmission:
1. copy from application space to TCP buffers
2. copy from TCP buffers to outgoing segment ("buffer")
3. copy from outgoing segment to device
finite buffers: when out of space, must
- discard incoming packets
- fail system calls

Xinu queues

regular queues
- int enqueue(int item, int queue)
- int dequeue(int queue)
priority queues:
- int enq(int q, void *elt, int key)
- void * deq(int q)

Xinu sleep

scheduler keeps a delta list of sleeping processes
clock interrupt places them on "ready-to-execute" list when ready to wake them up
scheduler then schedules them as regular ready threads