Initial source

1 files changed, 795 insertions, 0 deletions

diff --git a/ipc/fipc.c b/ipc/fipc.c
new file mode 100644
index 0000000..ebab640
--- /dev/null
+++ b/ipc/fipc.c
@@ -0,0 +1,795 @@
+/*
+ * Copyright (c) 1996-1994 The University of Utah and
+ * the Computer Systems Laboratory (CSL).  All rights reserved.
+ *
+ * Permission to use, copy, modify and distribute this software is hereby
+ * granted provided that (1) source code retains these copyright, permission,
+ * and disclaimer notices, and (2) redistributions including binaries
+ * reproduce the notices in supporting documentation, and (3) all advertising
+ * materials mentioning features or use of this software display the following
+ * acknowledgement: ``This product includes software developed by the
+ * Computer Systems Laboratory at the University of Utah.''
+ *
+ * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
+ * IS" CONDITION.  THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
+ * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ *
+ * CSL requests users of this software to return to csl-dist@cs.utah.edu any
+ * improvements that they make and grant CSL redistribution rights.
+ *
+ *  Utah $Hdr: fipc.c 1.1 96/2/29$
+ *  Author: Linus Kamb
+ */
+
+#ifdef FIPC
+
+#include <mach/kern_return.h>
+
+#include <device/device_types.h> 
+#include <device/device.h>
+#include <device/dev_hdr.h>
+#include <device/device_port.h>
+#include <device/io_req.h>
+#include <device/if_ether.h>
+#include <net_io.h>
+#include <spl.h>
+#include <kern/lock.h>
+
+#include "fipc.h" 
+
+void fipc_packet();
+void allocate_fipc_buffers(boolean_t);
+int fipc_lookup(unsigned short port);
+int fipc_lookup_table_enter(unsigned short port);
+int fipc_lookup_table_remove(unsigned short port);
+int f_lookup_hash(unsigned short port);
+int fipc_done(io_req_t ior);
+
+
+/********************************************************************/
+/* fipc variables
+/********************************************************************/
+
+fipc_port_t fports[N_MAX_OPEN_FIPC_PORTS];
+fipc_lookup_table_ent fipc_lookup_table[N_MAX_OPEN_FIPC_PORTS];
+
+int n_free_recv_bufs = 0;
+int n_free_send_bufs = 0;
+int n_fipc_recv_ports_used = 0;
+
+int fipc_sends = 0;
+int fipc_recvs =0;
+
+fipc_stat_t fipc_stats;
+
+char *fipc_recv_free_list = NULL;
+char *fipc_recv_free_list_tail = NULL;
+char *fipc_send_free_list = NULL;
+char *fipc_send_free_list_tail = NULL;
+
+/* fipc locks */
+decl_simple_lock_data(, fipc_lock);
+decl_simple_lock_data(, fipc_buf_q_lock);
+
+
+/*
+ * Routine: fipc_init(): initializes the fipc data structures.
+ */
+
+void fipc_init(void)
+{
+	int i;
+
+	allocate_fipc_buffers(TRUE);	/* recv buffers */
+	allocate_fipc_buffers(FALSE);	/* send buffers */
+
+	fipc_stats.dropped_msgs = 0;
+
+	bzero (&fports, sizeof(fports));
+	for (i=0; i<N_MAX_OPEN_FIPC_PORTS; i++)
+	{
+		simple_lock_init(&(fports[i].lock));
+		fipc_lookup_table[i].fpt_num = INVALID;
+		fipc_lookup_table[i].fipc_port = INVALID;
+	}
+}
+
+
+/*
+ * Routine: allocate_fipc_buffers(): allocate more buffers
+ * Currently we are only allocating 1500 byte (ETHERMTU) buffers.
+ * We use the first word in the buffer as the pointer to the next.
+ */
+
+void allocate_fipc_buffers(boolean_t r_buf)
+{
+	char *new_pg;
+	char **free_list, **free_list_tail;
+	int *free_count, min_count, max_count;
+	int total_buffer_size;
+
+	if (r_buf)
+	{	
+		free_count = &n_free_recv_bufs;
+		min_count = N_MIN_RECV_BUFS;
+		max_count = N_MAX_RECV_BUFS;
+		free_list = &fipc_recv_free_list;
+		free_list_tail = &fipc_recv_free_list_tail;
+		total_buffer_size = (N_MAX_RECV_BUFS * FIPC_BUFFER_SIZE);
+		total_buffer_size = round_page(total_buffer_size);
+	}
+	else
+	{
+		free_count = &n_free_send_bufs;
+		min_count = N_MIN_SEND_BUFS;
+		max_count = N_MAX_SEND_BUFS;
+		free_list = &fipc_send_free_list;
+		free_list_tail = &fipc_send_free_list_tail;
+		total_buffer_size = (N_MAX_SEND_BUFS * FIPC_BUFFER_SIZE);
+		total_buffer_size = round_page(total_buffer_size);
+	}
+
+	if (!(*free_count))  /* empty buffer pool */
+	{
+#ifdef FI_DEBUG
+		printf ("Allocating new fipc ");
+		if (r_buf)
+			printf ("recv buffer pool.\n");
+		else
+			printf ("send buffer pool.\n");
+#endif
+		*free_list = (char*)kalloc (total_buffer_size);
+		if (!*free_list)	/* bummer */
+			panic("allocate_fipc_buffers: no memory");
+		*free_list_tail = *free_list;
+		for (*free_count=1; *free_count<max_count; (*free_count)++)
+		{
+			*(char**)*free_list_tail = *free_list_tail + FIPC_BUFFER_SIZE;
+			*free_list_tail += FIPC_BUFFER_SIZE;
+		}
+		*(char**)*free_list_tail = NULL;
+	}	
+	else  /* Request to grow the buffer pool. */
+	{
+#ifdef FI_DEBUG
+		printf ("Growing fipc ");
+		if (r_buf)
+			printf ("recv buffer pool.\n");
+		else
+			printf ("send buffer pool.\n");
+#endif
+
+#define GROW_SIZE 8192
+		new_pg = (char*)kalloc (round_page(GROW_SIZE));
+		if (new_pg)
+		{
+			int new_cnt, n_new = GROW_SIZE / FIPC_BUFFER_SIZE;
+
+			if (*free_list_tail != NULL)
+				*(char**)*free_list_tail = new_pg;
+			for ( new_cnt =0; new_cnt<n_new; new_cnt++)
+			{
+				*(char**)*free_list_tail = *free_list_tail + FIPC_BUFFER_SIZE;
+				*free_list_tail += FIPC_BUFFER_SIZE;
+			}
+			*(char**)*free_list_tail = NULL;
+			*free_count +=new_cnt;
+		}
+#ifdef FI_DEBUG
+		else
+			printf ("### kalloc failed in allocate_fipc_buffers()\n");
+#endif
+
+	}
+}
+
+
+/*
+ * Routine: get_fipc_buffer (): returns a free buffer
+ * Takes a size (currently not used), a boolean flag to tell if it is a
+ * receive buffer, and a boolean flag if the request is coming at interrupt
+ * level.
+ */
+
+inline 
+char* get_fipc_buffer(int size, boolean_t r_buf, boolean_t at_int_lvl)
+{
+	/* we currently don't care about size, since there is only one 
+	 * buffer pool. */
+
+	char* head;
+	char **free_list;
+	int *free_count, min_count;
+
+	if (r_buf)
+	{	
+		free_count = &n_free_recv_bufs;
+		free_list = &fipc_recv_free_list;
+		min_count = N_MIN_RECV_BUFS;
+	}
+	else
+	{
+		free_count = &n_free_send_bufs;
+		free_list = &fipc_send_free_list;
+		min_count = N_MIN_SEND_BUFS;
+	}
+
+	/*
+	 * Since we currently allocate a full complement of receive buffers,
+	 * there is no need to allocate more receive buffers.  But that is likely
+	 * to change, I'm sure.
+	 */
+
+	if (*free_count < min_count)
+	{
+		if (!at_int_lvl) 
+			allocate_fipc_buffers(r_buf);
+	}
+
+	if (*free_count)
+	{
+		head = *free_list;
+		*free_list = *(char**)*free_list;
+		(*free_count)--;
+		return head;
+	}
+	else
+		return NULL;
+}
+
+
+/*
+ * Routine: return_fipc_buffer (): puts a used buffer back in the pool.
+ */
+
+inline
+void return_fipc_buffer(char* buf, int size,  
+			boolean_t r_buf, boolean_t at_int_lvl)
+{
+	/* return the buffer to the free pool */
+	char **free_list, **free_list_tail;
+	int *free_count, min_count;
+
+	if (r_buf)
+	{	
+		free_count = &n_free_recv_bufs;
+		free_list = &fipc_recv_free_list;
+		free_list_tail = &fipc_recv_free_list_tail;
+		min_count = N_MIN_RECV_BUFS;
+	}
+	else
+	{
+		free_count = &n_free_send_bufs;
+		free_list = &fipc_send_free_list;
+		free_list_tail = &fipc_send_free_list_tail;
+		min_count = N_MIN_SEND_BUFS;
+	}
+
+#ifdef FI_SECURE
+	bzero(buf, FIPC_BUFFER_SIZE);
+#endif
+
+	if (*free_list_tail != NULL)
+		*(char**)*free_list_tail = buf;
+	*free_list_tail = buf;
+	(*free_count)++;
+	*(char**)buf = NULL;
+
+	if (!at_int_lvl)
+		if (*free_count < min_count)
+			allocate_fipc_buffers(r_buf);
+
+	return;
+}
+
+inline
+int f_lookup_hash(unsigned short port)
+{
+	/* Ok, so it's not really a hash function */
+	int bail=0;
+	int chk=0;
+
+	if (n_fipc_recv_ports_used == N_MAX_OPEN_FIPC_PORTS ||
+		port > MAX_FIPC_PORT_NUM)
+			return INVALID;
+
+	while (fipc_lookup_table[chk].fipc_port != port &&
+			fipc_lookup_table[chk].fpt_num != INVALID &&
+			bail < N_MAX_OPEN_FIPC_PORTS)
+	{
+		chk = (chk+1) % N_MAX_OPEN_FIPC_PORTS;
+		bail++;
+	}
+
+	/* This is redundent, but better safe then sorry */
+	if (bail<N_MAX_OPEN_FIPC_PORTS)
+		return chk;
+	else
+		return INVALID;
+}
+
+inline
+int fipc_lookup_table_enter(unsigned short port)
+{
+	int cfpn = n_fipc_recv_ports_used;
+	int lu_tbl_num = f_lookup_hash(port);
+
+	if (lu_tbl_num == INVALID)
+		return INVALID;
+
+	fipc_lookup_table[lu_tbl_num].fipc_port = port;
+	fipc_lookup_table[lu_tbl_num].fpt_num = cfpn;
+	n_fipc_recv_ports_used += 1;
+	return cfpn;
+}
+
+inline
+int fipc_lookup(unsigned short port)
+{
+	int chk = f_lookup_hash(port);
+
+	if (chk == INVALID)
+		return INVALID;
+
+	if (fipc_lookup_table[chk].fpt_num == INVALID)
+		return fipc_lookup_table_enter(port);
+	else
+		return fipc_lookup_table[chk].fpt_num;
+}
+
+inline
+int fipc_lookup_table_remove(unsigned short port)
+{
+	int chk = f_lookup_hash(port);
+
+	if (chk == INVALID)
+		return 0;
+
+	if (fipc_lookup_table[chk].fipc_port == port)
+	{
+		fports[fipc_lookup_table[chk].fpt_num].valid_msg = 0;
+		fports[fipc_lookup_table[chk].fpt_num].bound = FALSE;
+		fipc_lookup_table[chk].fpt_num = INVALID;
+		fipc_lookup_table[chk].fipc_port = INVALID;
+		n_fipc_recv_ports_used -=1;
+		return 1;
+	}
+	return 0;
+}
+
+/*
+ * Routine: fipc_packet(): handles incoming fipc packets.
+ * does some simple packet handling and wakes up receiving thread, if any.
+ * called by device controller (currently, nerecv only.)
+ * called at interrupt level and splimp.
+ * Messages are dropped if the recv queue is full.
+ */
+
+ void fipc_packet( char* msg_buf, struct ether_header sender)
+ {
+	int to_port = ((fipc_header_t*)msg_buf)->dest_port;
+	int from_port = ((fipc_header_t*)msg_buf)->send_port;
+	int f_tbl_num;
+	fipc_port_t *cfp;
+	fipc_buffer_q_ent *crqe;
+	int *tail;
+
+#ifdef FI_DEBUG
+	printf  ("fipc_packet :(0x%x) %s", msg_buf,
+				msg_buf+sizeof(fipc_header_t));
+#endif
+
+	f_tbl_num = fipc_lookup(to_port);
+	if (f_tbl_num == INVALID)
+	{
+#ifdef FI_DEBUG
+		printf ("Lookup failed.\n");
+#endif
+		fipc_stats.dropped_msgs += 1;
+		return_fipc_buffer (msg_buf, FIPC_BUFFER_SIZE, TRUE, TRUE);
+		return;
+	}
+
+	cfp = &fports[f_tbl_num];
+	tail = &cfp->rq_tail;
+	crqe = &cfp->recv_q[*tail];
+		
+	if (cfp->valid_msg == FIPC_RECV_Q_SIZE) 
+	{
+		/* Queue full.
+		 * Drop packet, return buffer, and return. */
+#ifdef FI_DEBUG
+		printf ("Port %d queue is full: valid_msg count: %d\n", 
+				to_port, cfp->valid_msg);
+#endif
+		fipc_stats.dropped_msgs += 1;
+		return_fipc_buffer (msg_buf, FIPC_BUFFER_SIZE, TRUE, TRUE);
+		return;
+	}
+
+	/* "enqueue" at "tail" */
+	crqe->buffer = msg_buf;
+	crqe->size = ((fipc_header_t*)msg_buf)->msg_size;
+    /* This could certainly be done faster... */
+    bcopy(&(sender.ether_shost), &(crqe->sender.hwaddr), ETHER_HWADDR_SIZE);
+    /* This is actually useless, since there _is_ no sender port.. duh.  */
+    crqe->sender.port = from_port;
+
+	*tail = ((*tail)+1) % FIPC_RECV_Q_SIZE;
+
+	if (cfp->bound)
+		thread_wakeup(&(cfp->valid_msg));
+	cfp->valid_msg++;
+#ifdef FI_DEBUG
+	printf ("valid_msg: %d\n", cfp->valid_msg);
+#endif
+
+	return;
+ }
+
+
+/*
+ * loopback(): for fipc_sends to the local host.
+ */
+
+inline
+kern_return_t loopback(char *packet)
+{
+	fipc_packet(packet+sizeof(struct ether_header), 
+		*(struct ether_header*)packet);
+	return KERN_SUCCESS;
+}
+
+
+/********************************************************************/
+/* Routine: fipc_send
+/********************************************************************/
+
+kern_return_t syscall_fipc_send(fipc_endpoint_t dest,
+		char *user_buffer, int len)
+{
+#ifdef i386
+	static mach_device_t 	eth_device = 0; 
+#else
+	static device_t 	eth_device = 0;
+#endif
+	static unsigned char	hwaddr[ETHER_HWADDR_SIZE+2];
+
+	io_return_t rc;
+	kern_return_t open_res, kr;
+	dev_mode_t mode = D_WRITE;
+	/* register */ io_req_t ior = NULL;
+	struct ether_header *ehdr;
+	fipc_header_t *fhdr;
+	int *d_addr;
+	int data_count;
+	char *fipc_buf, *data_buffer;
+#ifdef FIPC_LOOPBACK
+	boolean_t local_send = FALSE;
+#endif
+
+#ifdef FI_DEBUG
+	printf("fipc_send(dest: %s, port:%d, len:%d, buf:x%x) !!!\n", 
+		ether_sprintf(dest.hwaddr), dest.port, len, user_buffer);
+#endif
+
+	if (dest.port > MAX_FIPC_PORT_NUM || 
+		len > FIPC_MSG_SIZE)
+	{
+#ifdef FI_DEBUG
+			printf ("len: %d, dest.port: %u\n", len, dest.port);
+#endif
+			return KERN_INVALID_ARGUMENT;
+	}
+
+	/* We should only need to probe the device once. */
+
+	if (!eth_device)
+	{
+		unsigned char net_hwaddr[ETHER_HWADDR_SIZE+2];
+		int stat_count = sizeof(net_hwaddr)/sizeof(int);
+
+		/* XXX Automatic lookup for ne0 or ne1 was failing... */
+		eth_device = device_lookup(ETHER_DEVICE_NAME); 
+#ifdef i386
+		if (eth_device == (mach_device_t) DEVICE_NULL || 
+			eth_device == (mach_device_t)D_NO_SUCH_DEVICE) 
+#else
+		if (eth_device == DEVICE_NULL || 
+			eth_device == (device_t)D_NO_SUCH_DEVICE) 
+#endif
+			{	
+#ifdef FI_DEBUG
+				printf ("FIPC: Couldn't find ethernet device %s.\n",
+					ETHER_DEVICE_NAME);
+#endif
+				return (KERN_FAILURE); 
+			}
+
+		/* The device should be open! */
+		if (eth_device->state != DEV_STATE_OPEN)
+		{
+#ifdef FI_DEBUG
+			printf ("Opening ethernet device.\n");
+#endif
+
+			io_req_alloc (ior, 0);
+
+			io_req_alloc (ior, 0);
+
+			ior->io_device = eth_device;
+			ior->io_unit = eth_device->dev_number;
+			ior->io_op = IO_OPEN | IO_CALL;
+			ior->io_mode = mode; 
+			ior->io_error = 0;
+			ior->io_done = 0;
+			ior->io_reply_port = MACH_PORT_NULL;
+			ior->io_reply_port_type = 0;
+			
+			/* open the device */
+			open_res = 
+				(*eth_device->dev_ops->d_open)
+					(eth_device->dev_number, 
+					(int)mode, ior);
+			if (ior->io_error != D_SUCCESS)
+			{
+#ifdef FI_DEBUG
+				printf ("Failed to open device ne0\n");
+#endif
+				return open_res;
+			}
+		}	
+#ifdef i386
+		rc = mach_device_get_status(eth_device, NET_ADDRESS,
+					    net_hwaddr, &stat_count);
+#else
+		rc = ds_device_get_status(eth_device, NET_ADDRESS, net_hwaddr,
+					  &stat_count);
+#endif
+		if (rc != D_SUCCESS)
+		{
+#ifdef FI_DEBUG
+			printf("FIPC: Couldn't determine hardware ethernet address: %d\n", 
+					rc);
+#endif
+			return KERN_FAILURE;
+		}
+		*(int*)hwaddr = ntohl(*(int*)net_hwaddr);
+		*(int*)(hwaddr+4) = ntohl(*(int*)(net_hwaddr+4));
+#ifdef FI_DEBUG
+		printf ("host: %s\n", ether_sprintf(hwaddr));
+#endif
+	}	
+		
+#ifdef FIPC_LOOPBACK
+	if (!memcmp(dest.hwaddr, hwaddr, ETHER_HWADDR_SIZE))
+/*
+	if ((*(int*)dest.hwaddr == *(int*)hwaddr) &&
+		((*(int*)(((char*)dest.hwaddr+4) >> 16)) ==
+		((*(int*)(((char*)hwaddr+4) >> 16)))))
+*/
+	{
+		local_send = TRUE;
+#ifdef FI_DEBUG
+		printf ("loopback: \n");
+		printf ("host: %s, ", ether_sprintf(hwaddr));
+		printf ("dest: %s\n", ether_sprintf(dest.hwaddr));
+#endif
+	}
+#endif
+
+	data_count = len + sizeof (struct ether_header) 
+				 + sizeof (fipc_header_t);
+
+#ifdef FIPC_LOOPBACK
+	fipc_buf = get_fipc_buffer(data_count, local_send, FALSE) ;
+#else
+	fipc_buf = get_fipc_buffer(data_count, FALSE, FALSE) ;
+#endif
+
+	if (fipc_buf == NULL)
+		return KERN_RESOURCE_SHORTAGE;
+
+	ehdr = (struct ether_header *)fipc_buf;
+	d_addr = (int *)ehdr->ether_dhost;
+
+	*(int *)ehdr->ether_dhost = *(int*)dest.hwaddr;
+	*(int *)(ehdr->ether_dhost+4) = *(int*)(dest.hwaddr+4);
+	*(int *)ehdr->ether_shost = *(int *)hwaddr;
+	*(int *)(ehdr->ether_shost+4) = *(int *)(hwaddr+4);
+	ehdr->ether_type = 0x1234;                /* Yep. */
+
+#ifdef FIPC_LOOPBACK
+	if (!local_send)
+	{
+#endif
+		if (!ior)
+			io_req_alloc (ior, 0);
+	
+		/* Set up the device information. */
+		ior->io_device      = eth_device;
+		ior->io_unit        = eth_device->dev_number;
+		ior->io_op	    = IO_WRITE | IO_INBAND | IO_INTERNAL;
+		ior->io_mode        = D_WRITE;
+		ior->io_recnum      = 0;     
+		ior->io_data        = fipc_buf; 
+		ior->io_count       = data_count;
+		ior->io_total       = data_count;
+		ior->io_alloc_size  = 0;
+		ior->io_residual    = 0;
+		ior->io_error       = 0;
+		ior->io_done        = fipc_done; 
+		ior->io_reply_port  = MACH_PORT_NULL; 
+		ior->io_reply_port_type = 0; 
+		ior->io_copy        = VM_MAP_COPY_NULL; 
+#ifdef FIPC_LOOPBACK
+	}	
+#endif
+
+#ifdef FI_DEBUG
+	printf("sending from %s ", ether_sprintf(ehdr->ether_shost));
+	printf("to %s, type x%x, user_port x%x\n",
+		ether_sprintf(ehdr->ether_dhost),
+		(int)ehdr->ether_type,
+		(int)dest.port);
+#endif
+
+	if (len <= FIPC_MSG_SIZE)
+	{
+		fhdr = (fipc_header_t*)(fipc_buf+sizeof(struct ether_header));
+		fhdr->dest_port = dest.port;
+		fhdr->msg_size = len;
+		data_buffer = (char*)fhdr+sizeof(fipc_header_t);
+
+		copyin (user_buffer, data_buffer, 
+			min (FIPC_BUFFER_SIZE-sizeof(fipc_header_t), len));
+
+#ifdef FIPC_LOOPBACK
+		/*
+	 	* Sending to same node.  Queue on dest.port of this node.
+	 	* We just call fipc_packet after setting up the necessary info
+		* and return.  fipc_packet queues the packet on the receive
+		* queue for the destination port.
+	 	*/
+		if (local_send)
+			return (loopback(fipc_buf));
+#endif
+
+		/* Now write to the device */
+		/* d_port_death has been co-opted for fipc stuff.
+	  	 * It maps to nefoutput(). */
+
+		rc = (*eth_device->dev_ops->d_port_death) /* that's the one */
+				(eth_device->dev_number, ior);
+	}
+#ifdef FI_DEBUG
+	else	/* len > ETHERMTU: multi-packet request */
+		printf  ("### multi-packet messages are not supported.\n");
+#endif
+
+	if (rc == D_IO_QUEUED)
+		return KERN_SUCCESS;
+	else
+		return KERN_FAILURE;
+}
+
+#ifdef FIPC_LOOPBACK
+	if (!local_send)
+	{
+#endif
+		if (!ior)
+			io_req_alloc (ior, 0);
+	
+		/* Set up the device information. */
+		ior->io_device      = eth_device;
+		ior->io_unit        = eth_device->dev_number;
+		ior->io_op	    = IO_WRITE | IO_INBAND | IO_INTERNAL;
+		ior->io_mode        = D_WRITE;
+		ior->io_recnum      = 0;     
+		ior->io_data        = fipc_buf; 
+		ior->io_count       = data_count;
+		ior->io_total       = data_count;
+		ior->io_alloc_size  = 0;
+		ior->io_residual    = 0;
+		ior->io_error       = 0;
+		ior->io_done        = fipc_done; 
+		ior->io_reply_port  = MACH_PORT_NULL; 
+		ior->io_reply_port_type = 0; 
+		ior->io_copy        = VM_MAP_COPY_NULL; 
+#ifdef FIPC_LOOPBACK
+	}	
+#endif
+
+/********************************************************************
+/* syscall_fipc_recv()
+/*
+/********************************************************************/
+
+kern_return_t syscall_fipc_recv(unsigned short user_port, 
+	char *user_buffer, int *user_size, fipc_endpoint_t *user_sender)
+{
+	char* f_buffer;
+	fipc_port_t *cfp; 
+	fipc_buffer_q_ent *crqe;
+	int *head;
+	int msg_size;
+	int fport_num = fipc_lookup(user_port);
+	spl_t spl;
+
+#ifdef FI_DEBUG
+	printf("fipc_recv(0x%x, 0x%x) !!!\n", user_port, user_buffer);
+#endif
+
+	if (user_port > MAX_FIPC_PORT_NUM)
+	{
+#ifdef FI_DEBUG
+		printf ("Invalid FIPC port: %u\n", user_port);
+#endif
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	if (fport_num == INVALID)
+		return KERN_RESOURCE_SHORTAGE;
+
+	cfp = &fports[fport_num]; 
+	head = &cfp->rq_head;
+	crqe = &cfp->recv_q[*head];
+
+	if (cfp->bound != FALSE)
+	{
+#ifdef FI_DEBUG
+		printf ("FIPC Port %u is currently bound.\n", user_port);
+#endif
+		return KERN_RESOURCE_SHORTAGE;
+	}
+
+	copyin(user_size, &msg_size, sizeof(int));
+
+	spl = splimp();
+
+	cfp->bound = TRUE;
+	while (!(cfp->valid_msg))
+	{
+		assert_wait(&(cfp->valid_msg), TRUE);
+		splx(spl);
+		thread_block ((void(*)())0);
+		if (current_thread()->wait_result != THREAD_AWAKENED)
+		{
+			cfp->bound = FALSE;
+			return KERN_FAILURE;
+		}
+		spl = splimp();
+	}
+
+	cfp->valid_msg--;
+	f_buffer = crqe->buffer;
+	msg_size = min (crqe->size, msg_size);
+
+	crqe->buffer = NULL;
+	crqe->size = 0;
+	*head = ((*head)+1) % FIPC_RECV_Q_SIZE;
+	cfp->bound = FALSE;
+
+	splx(spl);
+
+	copyout(f_buffer+sizeof(fipc_header_t), user_buffer, msg_size); 
+	copyout(&(crqe->sender), user_sender, sizeof(fipc_endpoint_t));
+	copyout(&msg_size, user_size, sizeof(msg_size));
+
+	return_fipc_buffer(f_buffer, FIPC_BUFFER_SIZE, TRUE, FALSE);
+
+	return KERN_SUCCESS;
+}
+
+
+/*
+ * Final clean-up after the packet has been sent off.
+ */
+int fipc_done(io_req_t ior)
+{
+    return_fipc_buffer(ior->io_data, FIPC_BUFFER_SIZE, FALSE, FALSE);
+
+	return 1;
+}
+
+#endif /* FIPC */