diff options
Diffstat (limited to 'ipc/fipc.c')
| -rw-r--r-- | ipc/fipc.c | 795 |
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 */ |