The R13B03 release.OTP_R13B03

1 files changed, 2594 insertions, 0 deletions

diff --git a/erts/emulator/sys/vxworks/sys.c b/erts/emulator/sys/vxworks/sys.c
new file mode 100644
index 0000000000..abddc7e107
--- /dev/null
+++ b/erts/emulator/sys/vxworks/sys.c
@@ -0,0 +1,2594 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1997-2009. All Rights Reserved.
+ * 
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd%
+ */
+/*
+ * system-dependent functions
+ * 
+ */
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+#include <vxWorks.h>
+#include <version.h>
+#include <string.h>
+#include <types.h>
+#include <sigLib.h>
+#include <ioLib.h>
+#include <iosLib.h>
+#include <envLib.h>
+#include <fioLib.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <symLib.h>
+#include <sysLib.h>
+#include <sysSymTbl.h>
+#include <loadLib.h>
+#include <taskLib.h>
+#include <taskVarLib.h>
+#include <taskHookLib.h>
+#include <tickLib.h>
+#include <time.h>
+#include <rngLib.h>
+#include <semLib.h>
+#include <selectLib.h>
+#include <sockLib.h>
+#include <a_out.h>
+#include <wdLib.h>
+#include <timers.h>
+#include <ctype.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <stdarg.h>
+
+
+#ifndef WANT_NONBLOCKING
+#define WANT_NONBLOCKING
+#endif
+
+#include "sys.h"
+#include "erl_alloc.h"
+
+/* don't need global.h, but bif_table.h (included by bif.h) won't compile otherwise */
+#include "global.h" 
+#include "bif.h"
+
+#include "erl_sys_driver.h"
+
+#include "elib_stat.h"
+
+#include "reclaim_private.h" /* Some more or less private reclaim facilities */
+
+#ifndef RETSIGTYPE
+#define RETSIGTYPE void
+#endif
+
+EXTERN_FUNCTION(void, erl_start, (int, char**));
+EXTERN_FUNCTION(void, erl_exit, (int n, char*, _DOTS_));
+EXTERN_FUNCTION(void, erl_error, (char*, va_list));
+EXTERN_FUNCTION(int, driver_interrupt, (int, int));
+EXTERN_FUNCTION(void, increment_time, (int));
+EXTERN_FUNCTION(int, next_time, (_VOID_));
+EXTERN_FUNCTION(void, set_reclaim_free_function, (FreeFunction));
+EXTERN_FUNCTION(int, erl_mem_info_get, (MEM_PART_STATS *));
+EXTERN_FUNCTION(void, erl_crash_dump, (char* file, int line, char* fmt, ...));
+
+#define ISREG(st) (((st).st_mode&S_IFMT) == S_IFREG)
+
+/* these are defined in usrLib.c */
+extern int spTaskPriority, spTaskOptions;
+
+/* forward declarations */
+static FUNCTION(FUNCPTR, lookup, (char*));
+static FUNCTION(int, read_fill, (int, char*, int));
+#if (CPU == SPARC)
+static FUNCTION(RETSIGTYPE, fpe_sig_handler, (int)); /*where is this fun? */
+#elif (CPU == PPC603)
+static FUNCTION(void, fix_registers, (void));
+#endif
+static FUNCTION(void, close_pipes, (int*, int*, int));
+static FUNCTION(void, delete_hook, (void));
+static FUNCTION(void, initialize_allocation, (void));
+
+FUNCTION(STATUS, uxPipeDrv, (void));
+FUNCTION(STATUS, pipe, (int*));
+FUNCTION(void, uxPipeShow, (int));
+
+void erl_main(int argc, char **argv);
+void argcall(char *args);
+
+/* Malloc-realted functions called from the VxWorks shell */
+EXTERN_FUNCTION(int, erl_set_memory_block, 
+		(int, int, int, int, int, int, int, int, int, int));
+EXTERN_FUNCTION(int, erl_memory_show, 
+		(int, int, int, int, int, int, int, int, int, int));
+
+#define DEFAULT_PORT_STACK_SIZE  100000 
+static int port_stack_size;
+
+static int erlang_id = 0;	/* Inited at loading, set/reset at each run */
+
+/* interval time reported to emulator */
+static int sys_itime;
+
+/* XXX - This is defined in .../config/all/configAll.h (NUM_FILES),
+   and not easily accessible at compile or run time - however,
+   in VxWorks 5.1 it is stored in the (undocumented?) maxFiles variable;
+   probably shouldn't depend on it, but we try to pick it up... */
+static int max_files = 50;	/* default configAll.h */
+
+int erts_vxworks_max_files;
+
+/* 
+ * used by the break handler (set by signal handler on ctl-c)
+ */
+volatile int erts_break_requested;
+
+/********************* General functions ****************************/
+
+Uint
+erts_sys_misc_mem_sz(void)
+{
+    Uint res = erts_check_io_size();
+    /* res += FIXME */
+    return res;
+}
+
+/*
+ * XXX This declaration should not be here.
+ */
+void erl_sys_schedule_loop(void);
+
+#ifdef SOFTDEBUG
+static void do_trace(int line, char *file, char *format, ...)
+{
+    va_list va;
+    int tid = taskIdSelf();
+    char buff[512];
+
+    va_start(va, format);
+    sprintf(buff,"Trace: Task: 0x%08x, %s:%d - ",
+	    tid, file, line);
+    vsprintf(buff + strlen(buff), format, va);
+    va_end(va);
+    strcat(buff,"\r\n");
+    write(2,buff,strlen(buff));
+}
+
+#define TRACE() do_trace(__LINE__, __FILE__,"")
+#define TRACEF(Args...) do_trace(__LINE__,__FILE__, ## Args)
+#endif
+
+void
+erts_sys_pre_init(void)
+{
+    if (erlang_id != 0) {
+	/* NOTE: This particular case must *not* call erl_exit() */
+	erts_fprintf(stderr, "Sorry, erlang is already running (as task %d)\n",
+		     erlang_id);
+	exit(1);
+    }
+
+    /* This must be done as early as possible... */
+    if(!reclaim_init()) 
+	fprintf(stderr, "Warning : reclaim facility should be initiated before "
+		"erlang is started!\n");
+    erts_vxworks_max_files = max_files = reclaim_max_files();
+
+    /* Floating point exceptions */
+#if (CPU == SPARC)
+    sys_sigset(SIGFPE, fpe_sig_handler);
+#elif (CPU == PPC603)
+    fix_registers();
+#endif
+
+    /* register the private delete hook in reclaim */
+    save_delete_hook((FUNCPTR)delete_hook, (caddr_t)0);
+    erlang_id = taskIdSelf();
+#ifdef DEBUG
+    printf("emulator task id = 0x%x\n", erlang_id);
+#endif
+}
+
+void erts_sys_alloc_init(void)
+{
+    initialize_allocation();
+}
+
+void
+erl_sys_init(void)
+{
+    setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
+    /* XXX Bug in VxWorks stdio loses fputch()'ed output after the
+       setvbuf() but before a *printf(), and possibly worse (malloc
+       errors, crash?) - so let's give it a *printf().... */
+    fprintf(stdout, "%s","");
+}
+
+void
+erl_sys_args(int* argc, char** argv)
+{
+    erts_init_check_io();
+    max_files = erts_check_io_max_files();
+    ASSERT(max_files <= erts_vxworks_max_files);
+}
+
+/*
+ * Called from schedule() when it runs out of runnable processes,
+ * or when Erlang code has performed INPUT_REDUCTIONS reduction
+ * steps. runnable == 0 iff there are no runnable Erlang processes.
+ */
+void
+erl_sys_schedule(int runnable)
+{	
+    erts_check_io_interrupt(0);
+    erts_check_io(!runnable);
+}
+
+void erts_do_break_handling(void)
+{
+    SET_BLOCKING(0);
+    /* call the break handling function, reset the flag */
+    do_break();
+    erts_break_requested = 0;
+    SET_NONBLOCKING(0);
+}
+
+/* signal handling */
+RETSIGTYPE (*sys_sigset(sig, func))()
+     int sig;
+     RETSIGTYPE (*func)();
+{
+  struct sigaction act, oact;
+
+  sigemptyset(&act.sa_mask);
+  act.sa_flags = 0;
+  act.sa_handler = func;
+  sigaction(sig, &act, &oact);
+  return(oact.sa_handler);
+}
+
+void sys_sigblock(int sig)
+{
+  sigset_t mask;
+
+  sigemptyset(&mask);
+  sigaddset(&mask, sig);
+  sigprocmask(SIG_BLOCK, &mask, (sigset_t *)NULL);
+}
+
+void sys_sigrelease(int sig)
+{
+  sigset_t mask;
+
+  sigemptyset(&mask);
+  sigaddset(&mask, sig);
+  sigprocmask(SIG_UNBLOCK, &mask, (sigset_t *)NULL);
+}
+
+void
+erts_sys_prepare_crash_dump(void)
+{
+    
+}
+
+/* register signal handlers XXX - they don't work, need to find out why... */
+/* set up signal handlers for break and quit */
+static void request_break(void)
+{
+  /* just set a flag - checked for and handled 
+   * in main thread (not signal handler).
+   * see check_io() 
+   */
+#ifdef DEBUG
+  fprintf(stderr,"break!\n");
+#endif
+  erts_break_requested = 1;
+  erts_check_io_interrupt(1); /* Make sure we don't sleep in erts_poll_wait */
+}
+
+static void do_quit(void)
+{
+    halt_0(0);
+}
+
+void erts_set_ignore_break(void) {
+}
+
+void init_break_handler(void)
+{
+  sys_sigset(SIGINT, request_break);
+  sys_sigset(SIGQUIT, do_quit);
+}
+
+void erts_replace_intr(void) {
+}
+
+int sys_max_files(void) 
+{
+  return(max_files);
+}
+
+/******************* Routines for time measurement *********************/
+
+int sys_init_time(void) 
+{
+    erts_clock_rate =  sysClkRateGet();
+    /*
+    ** One could imagine that it would be better returning 
+    ** a resolution more near the clock rate, like in:
+    ** return 1000 / erts_clock_rate; 
+    ** but tests show that such isn't the case (rounding errors?)
+    ** Well, we go for the Unix variant of returning 1 
+    ** as a constant virtual clock rate.
+    */
+    return SYS_CLOCK_RESOLUTION;
+}
+
+int erts_clock_rate;
+static volatile int ticks_inuse;
+static volatile unsigned long ticks_collected; /* will wrap */
+static WDOG_ID watchdog_id;
+static ULONG user_time;
+static int this_task_id, sys_itime;
+static SysHrTime hrtime_wrap;
+static unsigned long last_tick_count;
+
+static void tolerant_time_clockint(int count)
+{
+  if (watchdog_id != NULL) {
+    if (taskIsReady(this_task_id))
+      user_time += 1;
+    ++count;
+    if (!ticks_inuse) {
+      ticks_collected += count;
+      count = 0;
+    }
+    wdStart(watchdog_id, 1, (FUNCPTR)tolerant_time_clockint, count);
+  }
+}
+
+int sys_init_hrtime(void)
+{
+    this_task_id = taskIdSelf(); /* OK, this only works for one single task
+				    in the system... */
+    user_time = 0;
+
+    ticks_inuse = 0;
+    ticks_collected = 0;
+    hrtime_wrap = 0;
+    last_tick_count = 0;
+
+    sys_itime = 1000 / erts_clock_rate;
+    watchdog_id = wdCreate();
+    wdStart(watchdog_id, 1, (FUNCPTR) tolerant_time_clockint, 0);
+    return 0;
+}
+
+SysHrTime sys_gethrtime(void) 
+{
+    SysHrTime ticks;
+
+    ++ticks_inuse;
+    ticks = (SysHrTime) (ticks_collected & 0x7FFFFFFF);
+    ticks_inuse = 0;
+    if (ticks < (SysHrTime) last_tick_count) {
+	hrtime_wrap += 1UL << 31;
+    }
+    last_tick_count = ticks;
+    return (ticks + hrtime_wrap) * ((SysHrTime) (1000000000UL / 
+						 erts_clock_rate));
+}
+    
+void sys_gettimeofday(SysTimeval *tvp)
+{
+    struct timespec now;
+    
+    clock_gettime(CLOCK_REALTIME, &now);
+    tvp->tv_sec = now.tv_sec;
+    tvp->tv_usec = now.tv_nsec / 1000;
+}
+
+clock_t sys_times(SysTimes *t)
+{
+    t->tms_stime = t->tms_cutime = t->tms_cstime = 0;
+    ++ticks_inuse;
+    t->tms_utime = user_time;
+    ticks_inuse = 0;
+    return tickGet(); /* The best we can do... */
+}
+
+/* This is called when *this task* is deleted */
+static void delete_hook(void)
+{
+  if (watchdog_id != NULL) {
+    wdDelete(watchdog_id);
+    watchdog_id = NULL;
+  }
+  erlang_id = 0;
+  this_task_id = 0;
+}
+
+/************************** OS info *******************************/
+
+/* Used by erlang:info/1. */
+/* (This code was formerly in drv.XXX/XXX_os_drv.c) */
+
+#define MAX_VER_STR 9           /* Number of characters to
+                                   consider in version string */                              
+
+static FUNCTION(int, get_number, (char** str_ptr));
+
+char os_type[] = "vxworks";
+
+static int
+get_number(char **str_ptr)
+{
+    char* s = *str_ptr;		/* Pointer to beginning of string. */
+    char* dot;			/* Pointer to dot in string or NULL. */
+
+    if (!isdigit(*s))
+	return 0;
+    if ((dot = strchr(s, '.')) == NULL) {
+	*str_ptr = s+strlen(s);
+	return atoi(s);
+    } else {
+	*dot = '\0';
+	*str_ptr = dot+1;
+	return atoi(s);
+    }
+}
+
+/* namebuf;     Where to return the name. */
+/* size;	Size of name buffer. */
+void
+os_flavor(char *namebuf, unsigned size)
+{
+    strcpy(namebuf, "-");
+}
+
+/* int* pMajor;			Pointer to major version. */
+/* int* pMinor;			Pointer to minor version. */
+/* int* pBuild;			Pointer to build number. */
+void
+os_version(int *pMajor, int *pMinor, int *pBuild)
+{
+    char os_ver[MAX_VER_STR+2];
+    char* release;		/* Pointer to the release string:
+				 * X.Y or X.Y.Z.
+				 */
+    strncpy(os_ver, vxWorksVersion, MAX_VER_STR);
+    release = os_ver;
+    *pMajor = get_number(&release);
+    *pMinor = get_number(&release);
+    *pBuild = get_number(&release);
+}
+
+void init_getenv_state(GETENV_STATE *state)
+{
+   *state = NULL;
+}
+
+char *getenv_string(GETENV_STATE *state0)
+{
+   return NULL;
+}
+
+void fini_getenv_state(GETENV_STATE *state)
+{
+   *state = NULL;
+}
+
+/************************** Port I/O *******************************/
+
+
+/* I. Common stuff */
+
+#define TMP_BUF_MAX (tmp_buf_size - 1024)
+static byte *tmp_buf;
+static Uint tmp_buf_size;
+
+/* II. The spawn/fd/vanilla drivers */
+
+/* This data is shared by these drivers - initialized by spawn_init() */
+static struct driver_data {
+    int port_num, ofd, packet_bytes, report_exit;
+    int exitcode, exit_reported; /* For returning of exit codes. */
+} *driver_data;			/* indexed by fd */
+
+/* 
+ * Locking only for exitcodes and exit_reported, one global sem for all
+ * spawn ports as this is rare.
+ */
+static SEM_ID driver_data_sem = NULL;
+/*
+ * Also locking when looking up entries in the load table
+ */
+static SEM_ID entry_data_sem = NULL;
+
+/* We maintain a linked fifo queue of these structs in order */
+/* to manage unfinnished reads/and writes on differenet fd's */
+
+typedef struct pend {
+    char *cpos;
+    int fd;
+    int remain;
+    struct pend *next;
+    char buf[1];   /* this is a trick to be able to malloc one chunk */
+} Pend;
+
+static struct fd_data {
+    int inport, outport;
+    char *buf, *cpos;
+    int sz, remain;  /* for input on fd */
+    Pend* pending;   /* pending outputs */
+
+} *fd_data;			/* indexed by fd */
+    
+
+/* Driver interfaces */
+static ErlDrvData spawn_start(ErlDrvPort port_num, char *name, SysDriverOpts* opts);
+static ErlDrvData fd_start(ErlDrvPort port_num, char *name, SysDriverOpts* opts);
+static ErlDrvData vanilla_start(ErlDrvPort port_num, char *name, SysDriverOpts* opts);
+static int spawn_init(void);
+static void fd_stop(ErlDrvData);
+static void stop(ErlDrvData);
+static void ready_input(ErlDrvData fd, ErlDrvEvent ready_fd);
+static void ready_output(ErlDrvData fd, ErlDrvEvent ready_fd);
+static void output(ErlDrvData fd, char *buf, int len);
+static void stop_select(ErlDrvEvent, void*);
+
+struct erl_drv_entry spawn_driver_entry = {
+    spawn_init,
+    spawn_start,
+    stop,
+    output,
+    ready_input,
+    ready_output,
+    "spawn",
+    NULL, /* finish */
+    NULL, /* handle */
+    NULL, /* control */
+    NULL, /* timeout */
+    NULL, /* outputv */
+    NULL, /* ready_async */
+    NULL, /* flush */
+    NULL, /* call */
+    NULL, /* event */
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0, /* ERL_DRV_FLAGs */
+    NULL, /* handle2 */
+    NULL, /* process_exit */
+    stop_select
+
+};
+struct erl_drv_entry fd_driver_entry = {
+    NULL,
+    fd_start,
+    fd_stop,
+    output,
+    ready_input,
+    ready_output,
+    "fd",
+    NULL, /* finish */
+    NULL, /* handle */
+    NULL, /* control */
+    NULL, /* timeout */
+    NULL, /* outputv */
+    NULL, /* ready_async */
+    NULL, /* flush */
+    NULL, /* call */
+    NULL, /* event */
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0, /* ERL_DRV_FLAGs */
+    NULL, /* handle2 */
+    NULL, /* process_exit */
+    stop_select
+};
+struct erl_drv_entry vanilla_driver_entry = {
+    NULL,
+    vanilla_start,
+    stop,
+    output,
+    ready_input,
+    ready_output,
+    "vanilla",
+    NULL, /* finish */
+    NULL, /* handle */
+    NULL, /* control */
+    NULL, /* timeout */
+    NULL, /* outputv */
+    NULL, /* ready_async */
+    NULL, /* flush */
+    NULL, /* call */
+    NULL, /* event */
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0, /* ERL_DRV_FLAGs */
+    NULL, /* handle2 */
+    NULL, /* process_exit */
+    stop_select
+};
+
+/*
+** Set up enough of the driver_data structure to be able to report exit status.
+** Some things may be initiated again, but that is no real problem.
+*/
+static int pre_set_driver_data(int ifd, int ofd, 
+			       int read_write, int report_exit) {
+  if (read_write & DO_READ) {
+    driver_data[ifd].report_exit = report_exit;
+    driver_data[ifd].exitcode = 0;
+    driver_data[ifd].exit_reported = 0;
+    if (read_write & DO_WRITE) {
+      driver_data[ifd].ofd = ofd;
+      if (ifd != ofd) {
+	driver_data[ofd] = driver_data[ifd];
+	driver_data[ofd].report_exit = 0;
+      }
+    } else {			/* DO_READ only */
+      driver_data[ifd].ofd = -1;
+    }
+    return(ifd);
+  } else {			/* DO_WRITE only */
+    driver_data[ofd].report_exit = 0;
+    driver_data[ofd].exitcode = 0;
+    driver_data[ofd].exit_reported = 0;
+    driver_data[ofd].ofd = ofd;
+    return(ofd);
+  }
+}
+    
+/*
+** Set up the driver_data structure, it may have been initiated
+** partly by the function above, but we dont care. 
+*/
+static int set_driver_data(int port_num, int ifd, int ofd, 
+			   int packet_bytes, int read_write,
+			   int report_exit)
+{
+  if (read_write & DO_READ) {
+    driver_data[ifd].packet_bytes = packet_bytes;
+    driver_data[ifd].port_num = port_num;
+    driver_data[ifd].report_exit = report_exit;
+    if (read_write & DO_WRITE) {
+      driver_data[ifd].ofd = ofd;
+      if (ifd != ofd) {
+	driver_data[ofd] = driver_data[ifd];
+	driver_data[ofd].report_exit = 0;
+      }
+    } else {			/* DO_READ only */
+      driver_data[ifd].ofd = -1;
+    }
+    (void) driver_select(port_num, ifd, ERL_DRV_READ|ERL_DRV_USE, 1);
+    return(ifd);
+  } else {			/* DO_WRITE only */
+    driver_data[ofd].packet_bytes = packet_bytes;
+    driver_data[ofd].port_num = port_num;
+    driver_data[ofd].report_exit = 0;
+    driver_data[ofd].ofd = ofd;
+    return(ofd);
+  }
+}
+
+static int need_new_sems = 1;
+
+static int spawn_init(void)
+{
+  char *stackenv;
+  int size;
+  driver_data = (struct driver_data *)
+      erts_alloc(ERTS_ALC_T_DRV_TAB, max_files * sizeof(struct driver_data));
+  if (need_new_sems) {
+      driver_data_sem = semMCreate
+	  (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
+      entry_data_sem = semMCreate
+	  (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
+  }
+  if (driver_data_sem == NULL || entry_data_sem == NULL) {
+      erl_exit(1,"Could not allocate driver locking semaphore.");
+  }
+  need_new_sems = 0;
+
+  (void)uxPipeDrv();		/* Install pipe driver */
+
+  if ((stackenv = getenv("ERLPORTSTACKSIZE")) != NULL &&
+      (size = atoi(stackenv)) > 0)
+    port_stack_size = size;
+  else
+    port_stack_size = DEFAULT_PORT_STACK_SIZE;
+  return 0;
+}
+
+/* Argv has to be built vith the save_xxx routines, not with whathever 
+   sys_xxx2 has in mind... */
+#define argv_alloc save_malloc
+#define argv_realloc save_realloc
+#define argv_free save_free
+/* Build argv, return argc or -1 on failure */
+static int build_argv(char *name, char ***argvp)
+{
+  int argvsize = 10, argc = 0;
+  char *args, *arglast = NULL, *argp;
+  char **argv;
+
+#ifdef DEBUG
+  fdprintf(2, "Building argv, %s =>\n", name);
+#endif
+  if ((argv = (char **)argv_alloc(argvsize * sizeof(char *))) == NULL)
+    return(-1);
+  if ((args = argv_alloc(strlen(name) + 1)) == NULL)
+    return(-1);
+  strcpy(args, name);
+  argp = strtok_r(args, " \t", &arglast);
+  while (argp != NULL) {
+    if (argc + 1 >= argvsize) {
+      argvsize += 10;
+      argv = (char **)argv_realloc((char *)argv, argvsize*sizeof(char *));
+      if (argv == NULL) {
+	argv_free(args);
+	return(-1);
+      }
+    }
+#ifdef DEBUG
+  fdprintf(2, "%s\n", argp);
+#endif
+    argv[argc++] = argp;
+    argp = strtok_r((char *)NULL, " \t", &arglast);
+  }
+  argv[argc] = NULL;
+  *argvp = argv;
+  return(argc);
+}
+#undef argv_alloc
+#undef argv_realloc
+#undef argv_free
+
+
+/* Lookup and return global text symbol or NULL on failure
+   Symbol name is null-terminated and without the leading '_' */
+static FUNCPTR
+lookup(char *sym)
+{
+  char buf[256];
+  char *symname = buf;
+  int len;
+  FUNCPTR entry;
+  SYM_TYPE type;
+
+  len = strlen(sym);
+  if (len > 254 && (symname = malloc(len+2)) == NULL)
+    return(NULL);
+#if defined _ARCH_PPC || defined SIMSPARCSOLARIS
+  /* GCC for PPC and SIMSPARC doesn't add a leading _ to symbols */
+  strcpy(symname, sym);
+#else
+  sprintf(symname, "_%s", sym);
+#endif
+  if (symFindByNameAndType(sysSymTbl, symname, (char **)&entry,
+			   &type, N_EXT | N_TEXT, N_EXT | N_TEXT) != OK)
+    entry = NULL;
+  if (symname != buf)
+    free(symname);
+  return(entry);
+}
+
+/* This function is spawned to build argc, argv, lookup the symbol to call,
+   connect and set up file descriptors, and make the actual call.
+   N.B. 'name' was allocated by the Erlang task (through plain_malloc) and
+   is freed by this port program task.
+   Note: 'name' may be a path containing '/'. */
+
+static void call_proc(char *name, int ifd, int ofd, int read_write, 
+		      int redir_stderr, int driver_index, 
+		      int p6, int p7, int p8, int p9)
+{
+  int argc;
+  char **argv, *bname;
+  FUNCPTR entry;
+  int ret = -1;
+
+  /* Must consume 'name' */
+  argc = build_argv(name, &argv);
+  plain_free(name);
+  /* Find basename of path */
+  if ((bname = strrchr(argv[0], '/')) != NULL) {
+    bname++;
+  } else {
+    bname = argv[0];
+  }
+#ifdef DEBUG
+  fdprintf(2, "Port program name: %s\n", bname);
+#endif
+  semTake(entry_data_sem, WAIT_FOREVER);
+
+  if (argc > 0) {
+    if ((entry = lookup(bname)) == NULL) {
+      int fd;
+      char *fn;
+      /* NOTE: We don't check the return value of loadModule,
+	 since that was incompatibly changed from 5.0.2b to 5.1,
+	 but rather do a repeated lookup().   */
+      if ((fd = open(argv[0], O_RDONLY)) > 0) {
+	(void) loadModule(fd, GLOBAL_SYMBOLS);
+	close(fd);
+	entry = lookup(bname);
+      }
+      if (entry == NULL) {
+	/* filename == func failed, try func.o */
+	if ((fn = malloc(strlen(argv[0]) + 3)) != NULL) { /* ".o\0" */
+	  strcpy(fn, argv[0]);
+	  strcat(fn, ".o");
+	  if ((fd = open(fn, O_RDONLY)) > 0) {
+	    (void) loadModule(fd, GLOBAL_SYMBOLS);
+	    close(fd);
+	    entry = lookup(bname);
+	  }
+	  free(fn);
+	}
+      }
+    }
+  } else {
+    entry = NULL;
+  }
+  semGive(entry_data_sem);
+    
+  if (read_write & DO_READ) {	/* emulator read */
+    save_fd(ofd);
+    ioTaskStdSet(0, 1, ofd);	/* stdout for process */
+    if(redir_stderr)
+	ioTaskStdSet(0, 2, ofd);/* stderr for process */
+  }
+  if (read_write & DO_WRITE) { /* emulator write */
+    save_fd(ifd);
+    ioTaskStdSet(0, 0, ifd);	/* stdin for process */
+  }
+  if (entry != NULL) {
+    ret = (*entry)(argc, argv, (char **)NULL); /* NULL for envp */
+  } else {
+    fdprintf(2, "Could not exec \"%s\"\n", argv[0]);
+    ret = -1;
+  }
+  if (driver_data[driver_index].report_exit) {
+      semTake(driver_data_sem, WAIT_FOREVER);
+      driver_data[driver_index].exitcode = ret;
+      driver_data[driver_index].exit_reported = 1;
+      semGive(driver_data_sem);
+  }
+  /* We *don't* want to close the pipes here, but let the delete
+     hook take care of it - it might want to flush stdout and there'd
+     better be an open descriptor to flush to...   */
+  exit(ret);
+}
+
+static void close_pipes(int ifd[2], int ofd[2], int read_write)
+{
+  if (read_write & DO_READ) {
+    (void) close(ifd[0]);
+    (void) close(ifd[1]);
+  }
+  if (read_write & DO_WRITE) {
+    (void) close(ofd[0]);
+    (void) close(ofd[1]);
+  }
+}
+
+static void init_fd_data(int fd, int port_unused_argument)
+{
+  SET_NONBLOCKING(fd);
+  fd_data[fd].pending = NULL;
+  fd_data[fd].buf = fd_data[fd].cpos = NULL;
+  fd_data[fd].remain = fd_data[fd].sz = 0;
+}
+
+static ErlDrvData spawn_start(ErlDrvPort port_num, char *name,SysDriverOpts* opts)
+{
+    int ifd[2], ofd[2], len, nl, id;
+    char taskname[11], *progname, *bname;
+    char *space_in_command;
+    int packet_bytes = opts->packet_bytes;
+    int read_write = opts->read_write;
+    int use_stdio = opts->use_stdio;
+    int redir_stderr = opts->redir_stderr;
+    int driver_index;
+
+    if (!use_stdio){
+	return (ErlDrvData) -3;
+  }
+
+    /* Create pipes and set the Erlang task as owner of its 
+     * read and write ends (through save_fd()).
+     */
+    switch (read_write) {
+    case DO_READ:
+	if (pipe(ifd) < 0){
+	    return (ErlDrvData) -2;
+	}
+	if (ifd[0] >= max_files) {
+	    close_pipes(ifd, ofd, read_write);
+	    errno = ENFILE;
+	    return (ErlDrvData) -2;
+	}
+	save_fd(ifd[0]);
+	break;
+    case DO_WRITE:
+	if (pipe(ofd) < 0) {
+	    return (ErlDrvData) -2;
+	}
+	if (ofd[1] >= max_files) {
+	    close_pipes(ifd, ofd, read_write);
+	    errno = ENFILE;
+	    return (ErlDrvData) -2;
+	}
+	save_fd(ofd[1]);
+	break;
+    case DO_READ|DO_WRITE:
+	if (pipe(ifd) < 0){
+	    return (ErlDrvData) -2;
+	}
+	if (ifd[0] >= max_files || pipe(ofd) < 0) {
+	    close_pipes(ifd, ofd, DO_READ);
+	    errno = ENFILE;
+	    return (ErlDrvData) -2;
+	}
+	if (ofd[1] >= max_files) {
+	    close_pipes(ifd, ofd, read_write);
+	    errno = ENFILE;
+	    return (ErlDrvData) -2;
+	}
+	save_fd(ifd[0]);
+	save_fd(ofd[1]);
+	break;
+    default:
+	return (ErlDrvData) -1;
+    }
+
+    /* Allocate space for program name to be freed by the
+     * spawned task. We use plain_malloc so that the allocated
+     * space is not owned by the Erlang task.
+     */
+
+    if ((progname = plain_malloc(strlen(name) + 1)) == NULL) {
+	close_pipes(ifd, ofd, read_write);
+	errno = ENOMEM;
+	return (ErlDrvData) -2;
+    }
+    strcpy(progname, name);
+
+    /* Check if name contains a space 
+     *  (e.g "port_test -o/home/gandalf/tornado/wind/target/erlang")
+     */
+    if ((space_in_command = strrchr(progname, ' ')) != NULL) {
+	*space_in_command = '\0';
+    }
+
+    /* resulting in "port_test" */
+    if ((bname = strrchr(progname, '/')) != NULL)
+	bname++;
+    else
+	bname = progname;
+
+    /* resulting in "port_test" */
+    len = strlen(bname);
+    nl = len > 10 ? 10 : len;
+    strncpy(taskname, bname, nl);
+    taskname[nl] = '\0';
+    if (space_in_command != NULL) 
+	*space_in_command = ' ';
+    driver_index = pre_set_driver_data(ifd[0], ofd[1], 
+				       read_write, opts->exit_status);
+
+  /* resetting to "port_test -o/home/gandalf/tornado/wind/target/erlang" */
+    if ((id = taskSpawn(taskname, spTaskPriority, spTaskOptions,
+			port_stack_size, (FUNCPTR)call_proc, (int)progname,
+			ofd[0], ifd[1], read_write, redir_stderr, driver_index,
+			0,0,0,0))
+	== ERROR) {
+	close_pipes(ifd, ofd, read_write);
+	plain_free(progname);	/* only when spawn fails */
+	errno = ENOMEM;
+	return (ErlDrvData) -2;
+    }    
+#ifdef DEBUG
+    fdprintf(2, "Spawned %s as %s[0x%x]\n", name, taskname, id);
+#endif
+    if (read_write & DO_READ) 
+	init_fd_data(ifd[0], port_num);
+    if (read_write & DO_WRITE) 
+	init_fd_data(ofd[1], port_num);
+    return (ErlDrvData) (set_driver_data(port_num, ifd[0], ofd[1],
+					 packet_bytes,read_write,
+					 opts->exit_status));
+}
+
+static ErlDrvData fd_start(ErlDrvPort port_num, char *name, SysDriverOpts* opts)
+{
+    if (((opts->read_write & DO_READ) && opts->ifd >= max_files) ||
+	((opts->read_write & DO_WRITE) && opts->ofd >= max_files)) {
+	return (ErlDrvData) -1;
+    }
+
+    if (opts->read_write & DO_READ) 
+	init_fd_data(opts->ifd, port_num);
+    if (opts->read_write & DO_WRITE) 
+	init_fd_data(opts->ofd, port_num);
+    return (ErlDrvData) (set_driver_data(port_num, opts->ifd, opts->ofd,
+					 opts->packet_bytes, opts->read_write, 0));
+}
+
+static void clear_fd_data(int fd) 
+{
+    
+  if (fd_data[fd].sz > 0) 
+    erts_free(ERTS_ALC_T_FD_ENTRY_BUF, (void *) fd_data[fd].buf);
+  fd_data[fd].buf = NULL;
+  fd_data[fd].sz = 0;
+  fd_data[fd].remain = 0;
+  fd_data[fd].cpos = NULL;
+}
+
+static void nbio_stop_fd(int port_num, int fd)
+{
+  Pend *p, *p1;
+    
+  driver_select(port_num, fd, ERL_DRV_READ|ERL_DRV_WRITE, 0);
+  clear_fd_data(fd);
+  p = fd_data[fd].pending;
+  SET_BLOCKING(fd);
+  while (p) {
+    p1 = p->next;
+    free(p);
+    p = p1;
+  }
+  fd_data[fd].pending = NULL;
+}
+
+static void fd_stop(ErlDrvData drv_data)
+{
+    int ofd;
+    int fd = (int) drv_data;
+
+    nbio_stop_fd(driver_data[fd].port_num, (int)fd);
+    ofd = driver_data[fd].ofd;
+    if (ofd != fd && ofd != -1) 
+	nbio_stop_fd(driver_data[fd].port_num, (int)ofd); /* XXX fd = ofd? */
+}
+
+static ErlDrvData
+vanilla_start(ErlDrvPort port_num, char *name, SysDriverOpts* opts)
+{
+    int flags, fd;
+    struct stat statbuf;
+
+    DEBUGF(("vanilla_start, name: %s [r=%1i w=%1i]\n", name, 
+	    opts->read_write & DO_READ, 
+	    opts->read_write & DO_WRITE));
+  
+    flags = (opts->read_write == DO_READ ? O_RDONLY :
+	     opts->read_write == DO_WRITE ? O_WRONLY|O_CREAT|O_TRUNC :
+	     O_RDWR|O_CREAT);
+    if ((fd = open(name, flags, 0666)) < 0){
+	errno = ENFILE;
+	return (ErlDrvData) -2;
+    }
+    if (fd >= max_files) {
+	close(fd);
+	errno = ENFILE;
+	return (ErlDrvData) -2;
+    }
+    if (fstat(fd, &statbuf) < 0) {
+	close(fd);
+	errno = ENFILE;
+	return (ErlDrvData) -2;
+    }
+
+    /* Return error for reading regular files (doesn't work) */
+    if (ISREG(statbuf) && ((opts->read_write) & DO_READ)) {
+	close(fd);
+	return (ErlDrvData) -3;
+    }
+    init_fd_data(fd, port_num);
+    return (ErlDrvData) (set_driver_data(port_num, fd, fd,
+					 opts->packet_bytes, opts->read_write, 0));
+}
+
+/* Note that driver_data[fd].ifd == fd if the port was opened for reading, */
+/* otherwise (i.e. write only) driver_data[fd].ofd = fd.  */
+
+static void stop(ErlDrvData drv_data)
+{
+    int port_num, ofd;
+    int fd = (int) drv_data;
+
+    port_num = driver_data[fd].port_num;
+    nbio_stop_fd(port_num, fd);
+    driver_select(port_num, fd, ERL_DRV_USE, 0); /* close(fd) */
+
+    ofd = driver_data[fd].ofd;
+    if (ofd != fd && ofd != -1) {
+	nbio_stop_fd(port_num, ofd);
+	driver_select(port_num, ofd, ERL_DRV_USE, 0); /* close(fd) */
+    }
+}
+
+static int sched_write(int port_num,int fd, char *buf, int len, int pb)
+{
+  Pend *p, *p2, *p3;
+  int p_bytes = len;
+
+  p = (Pend*) erts_alloc_fnf(ERTS_ALC_T_PEND_DATA, pb + len + sizeof(Pend));
+  if (!p) {
+    driver_failure(port_num, -1);
+    return(-1);
+  }
+
+  switch(pb) {
+  case 4: put_int32(len, p->buf); break;
+  case 2: put_int16(len, p->buf); break;
+  case 1: put_int8(len, p->buf); break;
+  case 0: break;		/* Handles this case too */
+  }
+  sys_memcpy(p->buf + pb, buf, len);
+  driver_select(port_num, fd, ERL_DRV_WRITE|ERL_DRV_USE, 1);
+  p->cpos = p->buf;
+  p->fd = fd;
+  p->next = NULL;
+  p->remain = len + pb;
+  p2 = fd_data[fd].pending;
+  if (p2 == NULL) 
+    fd_data[fd].pending = p;
+  else {
+    p3 = p2->next;
+    while(p3) {
+      p_bytes += p2->remain;
+      p2 = p2->next;
+      p3 = p3->next;
+    }
+    p2->next = p;
+  }
+  if (p_bytes > (1 << 13))	/* More than 8 k pending */
+    set_busy_port(port_num, 1);
+  return(0);
+}
+
+/* Fd is the value returned as drv_data by the start func */
+static void output(ErlDrvData drv_data, char *buf, int len)
+{
+    int buf_done, port_num, wval, pb, ofd;
+    byte lb[4];
+    struct iovec iv[2];
+    int fd = (int) drv_data;
+
+    pb = driver_data[fd].packet_bytes;
+    port_num = driver_data[fd].port_num;
+
+    if ((ofd = driver_data[fd].ofd) == -1) {
+	return;
+    }
+
+    if (fd_data[ofd].pending) {
+	sched_write(port_num, ofd, buf, len, pb);
+	return;
+    }
+    
+    if ((pb == 2 && len > 65535) || (pb == 1 && len > 255)) {
+	driver_failure_posix(port_num, EINVAL);
+	return;
+    }
+    if (pb == 0) {
+	wval = write(ofd, buf, len);
+    } else {
+	lb[0] = (len >> 24) & 255;	/* MSB */
+	lb[1] = (len >> 16) & 255;
+	lb[2] = (len >> 8) & 255;
+	lb[3] = len & 255;		/* LSB */
+	iv[0].iov_base = (char*) lb + (4 - pb);
+	iv[0].iov_len = pb;
+	iv[1].iov_base = buf;
+	iv[1].iov_len = len;
+	wval = writev(ofd, iv, 2);
+    }
+    if (wval == pb + len ) {
+	return;
+    }
+    if (wval < 0) {
+	if ((errno == EINTR) || (errno == ERRNO_BLOCK)) {
+	    if (pb) {
+		sched_write(port_num, ofd, buf ,len, pb);
+	    } else if (pb == 0) {
+		sched_write(port_num, ofd, buf ,len, 0);
+	    }
+	    return;
+	}
+	driver_failure_posix(driver_data[fd].port_num, EINVAL);
+	return;
+    }
+    if (wval < pb) {
+	sched_write(port_num, ofd, (lb +4 -pb)  + wval, pb-wval, 0);
+	sched_write(port_num, ofd, buf ,len, 0);
+	return;
+    }
+
+    /* we now know that  wval < (pb + len) */
+    buf_done = wval - pb;
+    sched_write(port_num, ofd, buf + buf_done, len - buf_done,0);
+}
+
+static void stop_select(ErlDrvEvent fd, void* _)
+{
+    close((int)fd);
+}
+
+static int ensure_header(int fd,char *buf,int packet_size, int sofar)
+{
+  int res = 0;
+  int remaining = packet_size - sofar;
+
+  SET_BLOCKING(fd);
+  if (read_fill(fd, buf+sofar, remaining) != remaining)
+    return -1;
+  switch (packet_size) {
+  case 1: res = get_int8(buf); break;
+  case 2: res = get_int16(buf); break;
+  case 4: res = get_int32(buf); break;
+  }
+  SET_NONBLOCKING(fd);
+  return(res);
+}
+
+static int port_inp_failure(int port_num, int ready_fd, int res)
+{
+    (void) driver_select(port_num, ready_fd, ERL_DRV_READ|ERL_DRV_WRITE, 0); 
+    clear_fd_data(ready_fd);
+    if (res == 0) {
+	if (driver_data[ready_fd].report_exit) {
+	    int tmpexit = 0;
+	    int reported;
+	    /* Lock the driver_data structure */
+	    semTake(driver_data_sem, WAIT_FOREVER);
+	    if ((reported = driver_data[ready_fd].exit_reported))
+		tmpexit = driver_data[ready_fd].exitcode;
+	    semGive(driver_data_sem);
+	    if (reported) {
+		erts_fprintf(stderr,"Exitcode %d reported\r\n", tmpexit);
+		driver_report_exit(port_num, tmpexit);
+	    }
+	}
+	driver_failure_eof(port_num);
+    } else {
+	driver_failure(port_num, res);
+    }
+    return 0;
+}
+
+/* fd is the drv_data that is returned from the */
+/* initial start routine                        */
+/* ready_fd is the descriptor that is ready to read */
+
+static void ready_input(ErlDrvData drv_data, ErlDrvEvent drv_event)
+{
+  int port_num, packet_bytes, res;
+  Uint h = 0;
+  char *buf;
+  int fd = (int) drv_data;
+  int ready_fd = (int) drv_event;
+
+  port_num = driver_data[fd].port_num;
+  packet_bytes = driver_data[fd].packet_bytes;
+
+  if (packet_bytes == 0) {
+    if ((res = read(ready_fd, tmp_buf, tmp_buf_size)) > 0) {
+      driver_output(port_num, (char*)tmp_buf, res);
+      return;
+    }
+    port_inp_failure(port_num, ready_fd, res);
+    return;
+  }
+
+  if (fd_data[ready_fd].remain > 0) { /* We try to read the remainder */
+    /* space is allocated in buf */
+    res = read(ready_fd, fd_data[ready_fd].cpos, 
+	       fd_data[ready_fd].remain);
+    if (res < 0) {
+      if ((errno == EINTR) || (errno == ERRNO_BLOCK)) {
+	  ;
+      } else {
+	  port_inp_failure(port_num, ready_fd, res);
+      }
+    } else if (res == 0) { 
+	port_inp_failure(port_num, ready_fd, res);
+    } else if (res == fd_data[ready_fd].remain) { /* we're done  */
+	driver_output(port_num, fd_data[ready_fd].buf, 
+		      fd_data[ready_fd].sz);
+	clear_fd_data(ready_fd);
+    } else {			/*  if (res < fd_data[ready_fd].remain) */
+	fd_data[ready_fd].cpos += res;
+	fd_data[ready_fd].remain -= res;
+    }
+    return;
+  }
+
+
+  if (fd_data[ready_fd].remain == 0) { /* clean fd */
+    /* We make one read attempt and see what happens */
+    res = read(ready_fd, tmp_buf, tmp_buf_size);
+    if (res < 0) {  
+      if ((errno == EINTR) || (errno == ERRNO_BLOCK))
+	return;
+      port_inp_failure(port_num, ready_fd, res);
+      return;
+    }
+    else if (res == 0) {		/* eof */
+      port_inp_failure(port_num, ready_fd, res);
+      return;
+    }
+    else if (res < packet_bytes) { /* Ugly case... get at least */
+      if ((h = ensure_header(ready_fd, tmp_buf, packet_bytes, res))==-1) {
+	port_inp_failure(port_num, ready_fd, -1);
+	return;
+      }
+      buf = erts_alloc_fnf(ERTS_ALC_T_FD_ENTRY_BUF, h);
+      if (!buf) {
+	port_inp_failure(port_num, ready_fd, -1);
+	return;
+      }
+      fd_data[ready_fd].buf = buf;
+      fd_data[ready_fd].sz = h;
+      fd_data[ready_fd].remain = h;
+      fd_data[ready_fd].cpos = buf;
+      return;
+    }
+    else  {			/* if (res >= packet_bytes) */
+      unsigned char* cpos = tmp_buf;
+      int bytes_left = res;
+      while (1) {		/* driver_output as many as possible */
+	  if (bytes_left == 0) {
+	      clear_fd_data(ready_fd);
+	      return;
+	  }
+	  if (bytes_left < packet_bytes) { /* Yet an ugly case */
+	      if((h=ensure_header(ready_fd, cpos, 
+				  packet_bytes, bytes_left))==-1) {
+		  port_inp_failure(port_num, ready_fd, -1);
+		  return;
+	      }
+	      buf = erts_alloc_fnf(ERTS_ALC_T_FD_ENTRY_BUF, h);
+	      if (!buf) 
+		  port_inp_failure(port_num, ready_fd, -1);
+	      fd_data[ready_fd].buf = buf;
+	      fd_data[ready_fd].sz = h;
+	      fd_data[ready_fd].remain = h;
+	      fd_data[ready_fd].cpos = buf;
+	      return;
+	  }
+	  switch (packet_bytes) {
+	  case 1: h = get_int8(cpos); cpos += 1; break;
+	  case 2: h = get_int16(cpos); cpos += 2; break;
+	  case 4: h = get_int32(cpos); cpos += 4; break;
+	  }
+	  bytes_left -= packet_bytes;
+	  /* we've got the header, now check if we've got the data */
+	  if (h <= (bytes_left)) {
+	      driver_output(port_num, (char*) cpos, h);
+	      cpos += h;
+	      bytes_left -= h;
+	      continue;
+	  }
+	  else {			/* The last message we got was split */
+	      buf = erts_alloc_fnf(ERTS_ALC_T_FD_ENTRY_BUF, h);
+	      if (!buf) {
+		  port_inp_failure(port_num, ready_fd, -1);
+	      }
+	      sys_memcpy(buf, cpos, bytes_left);
+	      fd_data[ready_fd].buf = buf;
+	      fd_data[ready_fd].sz = h;
+	      fd_data[ready_fd].remain = h - bytes_left;
+	      fd_data[ready_fd].cpos = buf + bytes_left;
+	      return;
+	  }
+      }
+      return;
+    }
+  }
+  fprintf(stderr, "remain %d \n", fd_data[ready_fd].remain);
+  port_inp_failure(port_num, ready_fd, -1);
+}
+
+
+/* fd is the drv_data that is returned from the */
+/* initial start routine                        */
+/* ready_fd is the descriptor that is ready to read */
+
+static void ready_output(ErlDrvData drv_data, ErlDrvEvent drv_event)
+{
+  Pend *p;
+  int wval;
+
+  int fd = (int) drv_data;
+  int ready_fd = (int) drv_event;
+
+  while(1) {
+    if ((p = fd_data[ready_fd].pending) == NULL) {
+      driver_select(driver_data[fd].port_num, ready_fd, 
+		    ERL_DRV_WRITE, 0);
+      return;
+    }
+    wval = write(p->fd, p->cpos, p->remain);
+    if (wval == p->remain) {
+      fd_data[ready_fd].pending = p->next;
+      erts_free(ERTS_ALC_T_PEND_DATA, p);
+      if (fd_data[ready_fd].pending == NULL) {
+	driver_select(driver_data[fd].port_num, ready_fd, 
+		      ERL_DRV_WRITE, 0);
+	set_busy_port(driver_data[fd].port_num, 0);
+	return;
+      }
+      else
+	continue;
+    }
+    else if (wval < 0) {
+      if (errno == ERRNO_BLOCK || errno == EINTR)
+	return;
+      else {
+	driver_select(driver_data[fd].port_num, ready_fd, 
+		      ERL_DRV_WRITE, 0);
+	driver_failure(driver_data[fd].port_num, -1);
+	return;
+      }
+    }
+    else if (wval < p->remain) {
+      p->cpos += wval;
+      p->remain -= wval;
+      return;
+    }
+  }
+}
+
+/* Fills in the systems representation of the jam/beam process identifier.
+** The Pid is put in STRING representation in the supplied buffer,
+** no interpretatione of this should be done by the rest of the
+** emulator. The buffer should be at least 21 bytes long.
+*/
+void sys_get_pid(char *buffer){
+    int p = taskIdSelf(); /* Hmm, may be negative??? requires some GB of
+			     memory to make the TCB address convert to a
+			     negative value. */
+    sprintf(buffer,"%d", p);
+}
+
+int
+erts_sys_putenv(char *buffer, int sep_ix)
+{
+    return putenv(buffer);
+}
+
+int
+erts_sys_getenv(char *key, char *value, size_t *size)
+{
+    char *orig_value;
+    int res;
+    orig_value = getenv(key);
+    if (!orig_value)
+	res = -1;
+    else {
+	size_t len = sys_strlen(orig_value);
+	if (len >= *size) {
+	    *size = len + 1;
+	    res = 1;
+	}
+	else {
+	    *size = len;
+	    sys_memcpy((void *) value, (void *) orig_value, len+1);
+	    res = 0;
+	}
+    }
+    return res;
+}
+
+void
+sys_init_io(void)
+{
+  tmp_buf = (byte *) erts_alloc(ERTS_ALC_T_SYS_TMP_BUF, SYS_TMP_BUF_SIZE);
+  tmp_buf_size = SYS_TMP_BUF_SIZE;
+  fd_data = (struct fd_data *)
+      erts_alloc(ERTS_ALC_T_FD_TAB, max_files * sizeof(struct fd_data));
+}
+
+
+/* Fill buffer, return buffer length, 0 for EOF, < 0 for error. */
+
+static int read_fill(int fd, char *buf, int len)
+{
+  int i, got = 0;
+  do {
+    if ((i = read(fd, buf+got, len-got)) <= 0) {
+      return i;
+    }
+    got += i;
+  } while (got < len);
+  return (len);
+}	
+
+
+/************************** Misc... *******************************/
+
+extern const char pre_loaded_code[];
+extern char* const pre_loaded[];
+
+
+/* Float conversion */
+
+int sys_chars_to_double(char *buf, double *fp)
+{
+  char *s = buf;
+
+  /* The following check is incorporated from the Vee machine */
+    
+#define ISDIGIT(d) ((d) >= '0' && (d) <= '9')
+
+  /* Robert says that something like this is what he really wanted:
+   *
+   * 7 == sscanf(Tbuf, "%[+-]%[0-9].%[0-9]%[eE]%[+-]%[0-9]%s", ....);
+   * if (*s2 == 0 || *s3 == 0 || *s4 == 0 || *s6 == 0 || *s7)
+   *   break;
+   */
+
+  /* Scan string to check syntax. */
+  if (*s == '+' || *s == '-')
+    s++;
+	    
+  if (!ISDIGIT(*s))		/* Leading digits. */
+    return -1;
+  while (ISDIGIT(*s)) s++;
+  if (*s++ != '.')		/* Decimal part. */
+    return -1;
+  if (!ISDIGIT(*s))
+    return -1;
+  while (ISDIGIT(*s)) s++;
+  if (*s == 'e' || *s == 'E') {
+    /* There is an exponent. */
+    s++;
+    if (*s == '+' || *s == '-')
+      s++;
+    if (!ISDIGIT(*s))
+      return -1;
+    while (ISDIGIT(*s)) s++;
+  }
+  if (*s)			/* That should be it */
+    return -1;
+    
+  if (sscanf(buf, "%lf", fp) != 1)
+    return -1;
+  return 0;
+}
+
+/* 
+ ** Convert a double to ascii format 0.dddde[+|-]ddd
+ ** return number of characters converted
+ */
+
+int sys_double_to_chars(double fp, char *buf)
+{
+  (void) sprintf(buf, "%.20e", fp);
+  return strlen(buf);
+}
+
+
+/* Floating point exceptions */
+
+#if (CPU == SPARC)
+jmp_buf fpe_jmp;
+
+RETSIGTYPE fpe_sig_handler(int sig)
+{
+  longjmp(fpe_jmp, 1);
+}
+
+#elif (CPU == PPC603)
+static void fix_registers(void){
+    FP_CONTEXT fpcontext;
+    fppSave(&fpcontext);
+    fpcontext.fpcsr &= ~(_PPC_FPSCR_INIT);
+    fppRestore(&fpcontext);
+}
+#endif
+
+
+/* Return a pointer to a vector of names of preloaded modules */
+
+Preload* sys_preloaded(void)
+{
+    return (Preload *) pre_loaded;
+}
+
+/* Return a pointer to preloaded code for module "module" */
+unsigned char* sys_preload_begin(Preload *pp)
+{
+    return pp->code;
+}
+
+/* Clean up if allocated */
+void sys_preload_end(Preload *pp)
+{
+    /* Nothing */
+}
+
+/* Read a key from console (?) */
+
+int sys_get_key(int fd)
+{
+  int c;
+  unsigned char rbuf[64];
+
+  fflush(stdout);		/* Flush query ??? */
+
+  if ((c = read(fd,rbuf,64)) <= 0)
+    return c;
+  return rbuf[0];
+}
+
+
+/* A real printf that does the equivalent of fprintf(stdout, ...) */
+
+/* ARGSUSED */
+static STATUS
+stdio_write(char *buf, int nchars, int fp)
+{
+  if (fwrite(buf, sizeof(char), nchars, (FILE *)fp) == 0)
+    return(ERROR);
+  return(OK);
+}
+
+int real_printf(const char *fmt, ...)
+{
+  va_list ap;
+  int err;
+  
+  va_start(ap, fmt);
+  err = fioFormatV(fmt, ap, stdio_write, (int)stdout);
+  va_end(ap);
+  return(err);
+}
+	
+	
+/* 
+ * Little function to do argc, argv calls from (e.g.) VxWorks shell
+ *  The arguments should be in the form of a single ""-enclosed string
+ *  NOTE: This isn't really part of the emulator, just included here
+ *  so we can use the handy functions and memory reclamation.
+ */
+void argcall(char *args)
+{
+  int argc;
+  char **argv;
+  FUNCPTR entry;
+
+  if (args != NULL) {
+    if ((argc = build_argv(args, &argv)) > 0) {
+      if ((entry = lookup(argv[0])) != NULL)
+	(*entry)(argc, argv, (char **)NULL); /* NULL for envp */
+      else
+	fprintf(stderr, "Couldn't find %s\n", argv[0]);
+    } else
+      fprintf(stderr, "Failed to build argv!\n");
+  } else
+    fprintf(stderr, "No argument list!\n");
+}
+
+
+/* That concludes the Erlang stuff - now we just need to implement an OS...
+   - Just kidding, but resource reclamation isn't the strength of VxWorks */
+#undef calloc
+#undef free
+#undef cfree
+#undef malloc
+#undef realloc
+#undef open
+#undef creat
+#undef socket
+#undef accept
+#undef close
+#undef fopen
+#undef fdopen
+#undef freopen
+#undef fclose
+
+/********************* Using elib_malloc ****************************/
+/* This gives us yet another level of malloc wrappers. The purpouse */
+/* is to be able to select between different varieties of memory    */
+/* allocation without recompiling.                                  */
+/* Maybe the performance is somewhat degraded by this, but          */
+/* on the other hand, performance may be much better if the most    */
+/* suiting malloc is used (not to mention the much lower            */
+/* fragmentation).                                                  */
+/* /Patrik N                                                        */
+/********************************************************************/
+
+/* 
+ * I don't want to include the whole elib header, especially
+ * as it uses char * for generic pointers. Let's fool ANSI C instead.
+ */
+extern void *elib_malloc(size_t);
+extern void *elib_realloc(void *, size_t);
+extern void elib_free(void *);
+extern void elib_init(void *, int);
+extern void elib_force_init(void *, int);
+extern size_t elib_sizeof(void *);
+
+/* Flags */
+#define USING_ELIB_MALLOC         1   /* We are using the elib_malloc */
+#define WARN_MALLOC_MIX           2   /* Warn if plain malloc or save_malloc
+					 is mixed with sys_free2 or 
+					 sys_realloc2 */
+#define REALLOC_MOVES             4   /* Always move on realloc 
+					 (less fragmentation) */
+#define USER_POOL                 8   /* The user supplied the memory
+					 pool, it was not save_alloced. */
+#define RECLAIM_USER_POOL        16   /* Use the reclaim mechanism in the
+					 user pool. */
+#define NEW_USER_POOL            32   /* The user pool is newly suppllied,
+					 any old pool should be discarded */
+
+
+#define ELIB_LOCK \
+if(alloc_flags & USING_ELIB_MALLOC) \
+    semTake(elib_malloc_sem, WAIT_FOREVER)
+
+#define ELIB_UNLOCK \
+if(alloc_flags & USING_ELIB_MALLOC) \
+    semGive(elib_malloc_sem)
+
+#define USER_RECLAIM() ((alloc_flags & USING_ELIB_MALLOC) && \
+			(alloc_flags & USER_POOL) && \
+			(alloc_flags & RECLAIM_USER_POOL))
+
+/*
+ * Global state
+ * The use of function pointers for the malloc/realloc/free functions
+ * is actually only useful in the malloc case, we must know what kind of
+ * realloc/free we are going to use, so we could call elib_xxx directly.
+ * However, as the overhead is small and this construction makes it 
+ * fairly easy to add another malloc algorithm, the function pointers
+ * are used in realloc/free to.
+ */
+static MallocFunction actual_alloc = &save_malloc;
+static ReallocFunction actual_realloc = &save_realloc;
+static FreeFunction actual_free = &save_free;
+static int alloc_flags = 0;
+static int alloc_pool_size = 0;
+static void *alloc_pool_ptr = NULL;
+static SEM_ID elib_malloc_sem = NULL; 
+
+/*
+ * Descide if we should use the save_free instead of elib_free or, 
+ * in the case of the free used in a delete hook, if we should
+ * use plain free instead of elib_free.
+ */
+static int use_save_free(void *ptr){
+    register int diff = ((char *) ptr) - ((char *) alloc_pool_ptr);
+    /* 
+     * Hmmm... should it be save_free even if diff is exactly 0? 
+     * The answer is Yes if the whole area is save_alloced and No if not,
+     * so reclaim_free_hook is NOT run in the case of one save_alloced area. 
+     */
+    return (!(alloc_flags & USING_ELIB_MALLOC) ||
+	    (diff < 0 || diff >= alloc_pool_size));
+}
+
+/*
+ * A free function used by the task deletion hook for the save_xxx functions.
+ * Set with the set_reclaim_free_function function.
+ */
+static void reclaim_free_hook(void *ptr){
+    if(use_save_free(ptr)){
+	free(ptr);
+    } else {
+	ELIB_LOCK;
+	(*actual_free)(ptr);
+	ELIB_UNLOCK;
+    }
+}
+    
+
+/*
+ * Initialize, sets the values of pointers based on
+ * either nothing (the default) or what's set previously by the
+ * erl_set_memory_block function.
+ */
+static void initialize_allocation(void){
+    set_reclaim_free_function(NULL);
+    if(alloc_pool_size == 0){
+	actual_alloc = (void *(*)(size_t))&save_malloc;
+	actual_realloc = (void *(*)(void *, size_t))&save_realloc;
+	actual_free = &save_free;
+	alloc_flags &= ~(USING_ELIB_MALLOC | USER_POOL | RECLAIM_USER_POOL);
+    } else {
+	if(elib_malloc_sem == NULL)
+	    elib_malloc_sem = semMCreate
+		(SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
+	if(elib_malloc_sem == NULL)
+	    erl_exit(1,"Could not create mutex semaphore for elib_malloc");
+	if(!(alloc_flags & USER_POOL)){
+	    if((alloc_pool_ptr = save_malloc(alloc_pool_size)) == NULL)
+		erl_exit(1,"Erlang set to allocate a %d byte block initially;"
+			 " not enough memory available.", alloc_pool_size);
+	    elib_force_init(alloc_pool_ptr, alloc_pool_size);
+	} else if(alloc_flags & NEW_USER_POOL){
+	    elib_force_init(alloc_pool_ptr, alloc_pool_size);
+	}
+	actual_alloc=&elib_malloc;
+	actual_realloc=&elib_realloc;
+	actual_free=&elib_free;
+	alloc_flags |= USING_ELIB_MALLOC;
+	/* We MUST see to that the right free function is used
+	   otherwise we'll get a very nasty crash! */
+	if(USER_RECLAIM())
+	    set_reclaim_free_function(&reclaim_free_hook);
+    }
+    alloc_flags &= ~(NEW_USER_POOL); /* It's never new after initialization*/
+}
+
+/* This does not exist on other platforms, we just use it in sys.c 
+   and the BSD resolver */
+void *sys_calloc2(Uint nelem, Uint elsize){
+    void *ptr = erts_alloc_fnf(ERTS_ALC_T_UNDEF, nelem*elsize);
+    if(ptr != NULL)
+	memset(ptr,0,nelem*elsize);
+    return ptr;
+}
+
+/*
+ * The malloc wrapper
+ */
+void *
+erts_sys_alloc(ErtsAlcType_t type, void *extra, Uint size)
+{
+    register void *ret;
+    ELIB_LOCK;
+    if(USER_RECLAIM())
+	ret = save_malloc2((size_t)size,actual_alloc);
+    else
+	ret = (*actual_alloc)((size_t)size);
+    ELIB_UNLOCK;
+    return ret;
+}
+
+/*
+ * The realloc wrapper, may respond to the "realloc-always-moves" flag
+ * if the area is initially allocated with elib_malloc.
+ */
+void *
+erts_sys_realloc(ErtsAlcType_t type, void *extra, void *ptr, Uint size)
+{
+    register void *ret;
+    if(use_save_free(ptr)){
+	if((alloc_flags & WARN_MALLOC_MIX) && 
+	   (alloc_flags & USING_ELIB_MALLOC))
+	    erts_fprintf(stderr,"Warning, save_malloced data realloced "
+		       "by sys_realloc2\n");
+	return save_realloc(ptr, (size_t) size);
+    } else {	
+	ELIB_LOCK;
+	if((alloc_flags & REALLOC_MOVES) && 
+	   (alloc_flags & USING_ELIB_MALLOC)){
+	    size_t osz = elib_sizeof(ptr);
+	    if(USER_RECLAIM())
+		ret = save_malloc2((size_t) size, actual_alloc);
+	    else
+		ret = (*actual_alloc)((size_t) size);
+	    if(ret != NULL){
+		memcpy(ret,ptr,(((size_t)size) < osz) ? ((size_t)size) : osz);
+		if(USER_RECLAIM())
+		    save_free2(ptr,actual_free);
+		else
+		    (*actual_free)(ptr);
+	    }
+	} else {
+	    if(USER_RECLAIM())
+		ret = save_realloc2(ptr,(size_t)size,actual_realloc);
+	    else
+		ret = (*actual_realloc)(ptr,(size_t)size);
+	}
+	ELIB_UNLOCK;
+	return ret;
+    }
+}
+
+/*
+ * Wrapped free().
+ */
+void
+erts_sys_free(ErtsAlcType_t type, void *extra, void *ptr)
+{
+    if(use_save_free(ptr)){
+	/* 
+	 * This might happen when linked in drivers use save_malloc etc 
+	 * directly. 
+	 */
+	if((alloc_flags & WARN_MALLOC_MIX) && 
+	   (alloc_flags & USING_ELIB_MALLOC))
+	    erts_fprintf(stderr,"Warning, save_malloced data freed by "
+		       "sys_free2\n");
+	save_free(ptr);
+    } else {
+	ELIB_LOCK;
+	if(USER_RECLAIM())
+	    save_free2(ptr,actual_free);
+	else
+	    (*actual_free)(ptr);
+	ELIB_UNLOCK;
+    }
+}
+
+/* 
+ * External interface to be called before erlang is started 
+ * Parameters:
+ * isize: The size of the memory block where erlang should malloc().
+ * iptr: (optional) A pointer to a user supplied memory block of 
+ *       size isize.
+ * warn_save: Instructs sys_free2 and sys_realloc2 to warn if
+ *            memory allocation/reallocation/freeing is mixed between
+ *            pure malloc/save_malloc/sys_alloc2 routines (only
+ *            warns if elib is actually used in the sys_alloc2 routines).
+ * realloc_moves: Always allocate a fresh memory block on reallocation 
+ *                (less fragmentation).
+ * reclaim_in_supplied: Use memory reclaim mechanisms inside the user
+ *                      supplied area, this makes one area reusable between
+ *                      starts of erlang and might be nice for drivers etc.
+ */
+
+int erl_set_memory_block(int isize, int iptr, int warn_save, 
+			 int realloc_moves, int reclaim_in_supplied, int p5,
+			 int p6, int p7, int p8, int p9){
+    if(erlang_id != 0){
+	erts_fprintf(stderr,"Error, cannot set erlang memory block while an "
+		     "erlang task is running!\n");
+	return 1;
+    }
+    if(isize < 8 * 1024 *1024)
+	erts_fprintf(stderr,
+		     "Warning, the memory pool of %dMb may be to small to "
+		     "run erlang in!\n", isize / (1024 * 1024));
+    alloc_pool_size = (size_t) isize;
+    alloc_pool_ptr = (void *) iptr;
+    alloc_flags = 0;
+    /* USING_ELIB_MALLOC gets set by the initialization routine */
+    if((void *)iptr != NULL)
+	alloc_flags |= (USER_POOL | NEW_USER_POOL);
+    if(realloc_moves)
+	alloc_flags |= REALLOC_MOVES;
+    if(warn_save)
+	alloc_flags |= WARN_MALLOC_MIX;
+    if((void *)iptr != NULL && reclaim_in_supplied)
+	alloc_flags |= RECLAIM_USER_POOL;
+    return 0;
+}
+
+/* External statistics interface */
+int erl_memory_show(int p0, int p1, int p2, int p3, int p4, int p5,
+		    int p6, int p7, int p8, int p9){
+    struct elib_stat statistics;
+    if(!(alloc_flags & USING_ELIB_MALLOC) && erlang_id != 0){
+	erts_printf("Using plain save_alloc, use memShow instead.\n");
+	return 1;
+    }
+    if(erlang_id == 0 && !((alloc_flags & USER_POOL) && 
+			   !(alloc_flags & NEW_USER_POOL))){
+	erts_printf("Sorry, no allocation statistics until erlang "
+		   "is started.\n");
+	return 1;
+    }
+    erts_printf("Allocation settings:\n");
+    erts_printf("Using elib_malloc with memory pool size of %lu bytes.\n",
+	       (unsigned long) alloc_pool_size);
+    erts_printf("Realloc-always-moves is %s\n", 
+	       (alloc_flags & REALLOC_MOVES) ? "on" : "off");
+    erts_printf("Warnings about mixed malloc/free's are %s\n", 
+	       (alloc_flags & WARN_MALLOC_MIX) ? "on" : "off");
+    if(alloc_flags & USER_POOL){
+	erts_printf("The memory block used by elib is user supplied "
+		   "at 0x%08x.\n", (unsigned int) alloc_pool_ptr);
+	if(alloc_flags & RECLAIM_USER_POOL)
+	    erts_printf("Allocated memory within the user supplied pool\n"
+		       "  will be automatically reclaimed at task exit.\n");
+    } else {
+	erts_printf("The memory block used by elib is save_malloc'ed "
+		   "at 0x%08x.\n", (unsigned int) alloc_pool_ptr);
+    }
+#ifdef NO_FIX_ALLOC
+    erts_printf("Fix_alloc is disabled in this build\n");
+#endif
+    erts_printf("Statistics from elib_malloc:\n");
+    ELIB_LOCK;
+
+    elib_stat(&statistics);
+    ELIB_UNLOCK;
+    erts_printf("Type          Size (bytes) Number of blocks\n");
+    erts_printf("============= ============ ================\n");
+    erts_printf("Total:        %12lu %16lu\n",
+	       (unsigned long) statistics.mem_total*4,
+	       (unsigned long) statistics.mem_blocks);
+    erts_printf("Allocated:    %12lu %16lu\n",
+	       (unsigned long) statistics.mem_alloc*4,
+	       (unsigned long) statistics.mem_blocks-statistics.free_blocks);
+    erts_printf("Free:         %12lu %16lu\n",
+	       (unsigned long) statistics.mem_free*4,
+	       (unsigned long) statistics.free_blocks);
+    erts_printf("Largest free: %12lu                -\n\n",
+	       (unsigned long) statistics.max_free*4);
+    return 0;
+}
+
+
+/*
+** More programmer friendly (as opposed to user friendly ;-) interface
+** to the memory statistics. Resembles the VxWorks memPartInfoGet but
+** does not take a partition id as parameter...
+*/    
+int erl_mem_info_get(MEM_PART_STATS *stats){
+    struct elib_stat statistics;
+    if(!(alloc_flags & USING_ELIB_MALLOC))
+	return -1;
+    ELIB_LOCK;
+    elib_stat(&statistics);
+    ELIB_UNLOCK;
+    stats->numBytesFree = statistics.mem_free*4;
+    stats->numBlocksFree = statistics.free_blocks;
+    stats->maxBlockSizeFree = statistics.max_free*4;
+    stats->numBytesAlloc = statistics.mem_alloc*4;
+    stats->numBlocksAlloc = statistics.mem_blocks-statistics.free_blocks;
+    return 0;
+}
+
+/********************* Pipe driver **********************************/
+/*
+ * Purpose:  Pipe driver with Unix (unnamed) pipe semantics.
+ * Author:   Peter Hogfeldt ([email protected]) from an outline
+ *           by Per Hedeland ([email protected]).
+ *
+ * Note: This driver must *not* use the reclaim facilities, hence it 
+ * is placed here. (after the #undef's of open,malloc etc)
+ *
+ * This driver supports select() and non-blocking I/O via 
+ * ioctl(fd, FIONBIO, val).
+ * 
+ * 1997-03-21 Peter Hogfeldt
+ *            Added non-blocking I/O.
+ *
+ */
+
+/* 
+ *  SEMAPHORES
+ *
+ *  Each end of a pipe has two semaphores: semExcl for serialising access to 
+ *  the pipe end, and semBlock for blocking I/O.
+ *
+ *  reader->semBlock         is available (full) if and only if the pipe is
+ *                           not empty, or the write end is closed. Otherwise
+ *                           it is unavailable (empty). It is initially
+ *                           unavailable.
+ *
+ *  writer->semBlock         is available (full) if and only if the pipe is
+ *                           not full, or if the reader end is closed. 
+ *                           Otherwise it is unavailable. It is initially
+ *                           available.
+ */
+
+#define UXPIPE_SIZE 4096
+
+/* Forward declaration */
+typedef struct uxPipeDev UXPIPE_DEV;
+
+/*
+ * Pipe descriptor (one for each open pipe).
+ */
+typedef struct {
+  int drvNum;
+  UXPIPE_DEV *reader, *writer;
+  RING_ID ringId;
+}     UXPIPE;
+
+/*
+ * Device descriptor (one for each of the read and write
+		      * ends of an open pipe).
+		      */
+struct uxPipeDev {
+  UXPIPE *pipe;
+  int blocking;
+  SEL_WAKEUP_LIST wakeupList;
+  SEM_ID semExcl;
+  SEM_ID semBlock;
+};
+
+int uxPipeDrvNum = 0; /* driver number of pipe driver */
+
+#define PIPE_NAME 	"/uxpipe" /* only used internally */
+#define PIPE_READ 	"/r"	/* ditto */
+#define PIPE_WRITE 	"/w"	/* ditto */
+
+LOCAL char pipeRead[64], pipeWrite[64];
+LOCAL DEV_HDR devHdr;
+LOCAL UXPIPE *newPipe; /* communicate btwn open()s in pipe() */
+LOCAL SEM_ID pipeSem; /* mutual exclusion in pipe() */
+
+/* forward declarations */
+LOCAL int uxPipeOpen(DEV_HDR *pDv, char *name, int mode);
+LOCAL int uxPipeClose(UXPIPE_DEV *pDev);
+LOCAL int uxPipeRead(UXPIPE_DEV *pDev, char *buffer, int maxbytes);
+LOCAL int uxPipeWrite(UXPIPE_DEV *pDev, char *buffer, int nbytes);
+LOCAL STATUS uxPipeIoctl(FAST UXPIPE_DEV *pDev, FAST int function, int arg);
+
+
+/***************************************************************************
+ *
+ * uxPipeDrv - install Unix pipe driver
+ *
+ * This routine initializes the Unix pipe driver.  It must be called
+ * before any other routine in this driver.
+ *
+ * RETURNS:
+ *    OK, or ERROR if I/O system is unable to install driver.
+ */
+
+STATUS
+uxPipeDrv(void)
+{
+  if (uxPipeDrvNum > 0)
+    return (OK);		/* driver already installed */
+  if ((uxPipeDrvNum = iosDrvInstall((FUNCPTR) NULL, (FUNCPTR) NULL,
+				    uxPipeOpen, uxPipeClose, uxPipeRead,
+				    uxPipeWrite, uxPipeIoctl)) == ERROR)
+    return (ERROR);
+  if (iosDevAdd(&devHdr, PIPE_NAME, uxPipeDrvNum) == ERROR)
+    return (ERROR);
+  strcpy(pipeRead, PIPE_NAME);
+  strcat(pipeRead, PIPE_READ);
+  strcpy(pipeWrite, PIPE_NAME);
+  strcat(pipeWrite, PIPE_WRITE);
+  if ((pipeSem = semMCreate(SEM_Q_PRIORITY | SEM_DELETE_SAFE)) == NULL)
+    return (ERROR);
+  return (OK);
+}
+
+/***************************************************************************
+ *
+ * uxPipeOpen - open a pipe
+ *
+ * RETURNS: Pointer to device descriptor, or ERROR if memory cannot be
+ * allocated (errno = ENOMEM),  or invalid argument (errno = EINVAL).
+ */
+
+/*
+ * DEV_HDR *pDv;  pointer to device header (dummy) 
+ * char *name;  name of pipe to open ("/r" or "/w") 
+ * int   mode;  access mode (O_RDONLY or O_WRONLY)
+ */		      
+LOCAL int
+uxPipeOpen(DEV_HDR *pDv, char *name, int mode)
+{
+  UXPIPE_DEV *reader, *writer;
+
+  if (mode == O_RDONLY && strcmp(name, PIPE_READ) == 0) {
+    /* reader open */
+    if ((newPipe = (UXPIPE *) malloc(sizeof(UXPIPE))) != NULL) {
+      if ((newPipe->ringId = rngCreate(UXPIPE_SIZE)) != NULL) {
+	if ((reader = (UXPIPE_DEV *) malloc(sizeof(UXPIPE_DEV))) != NULL) {
+	  if ((reader->semExcl = semBCreate(SEM_Q_FIFO, SEM_FULL)) != NULL) {
+	    if ((reader->semBlock = semBCreate(SEM_Q_FIFO, SEM_EMPTY)) != NULL) {
+	      reader->pipe = newPipe;
+	      reader->blocking = 1;
+	      selWakeupListInit(&reader->wakeupList);
+	      newPipe->reader = reader;
+	      newPipe->writer = NULL;
+	      newPipe->drvNum = uxPipeDrvNum;
+	      return ((int) reader);
+	    }
+	    semDelete(reader->semExcl);
+	  }
+	  free(reader);
+	}
+	rngDelete(newPipe->ringId);
+      }
+      free(newPipe);
+      newPipe = NULL;
+      errno = ENOMEM;
+    }
+  } else if (mode == O_WRONLY && strcmp(name, PIPE_WRITE) == 0) {
+    /* writer open */
+    if (newPipe != NULL &&
+	(writer = (UXPIPE_DEV *) malloc(sizeof(UXPIPE_DEV))) != NULL) {
+      if ((writer->semExcl = semBCreate(SEM_Q_FIFO, SEM_FULL)) != NULL) {
+	if ((writer->semBlock = semBCreate(SEM_Q_FIFO, SEM_FULL)) != NULL) {
+	  writer->blocking = 1;
+	  writer->pipe = newPipe;
+	  selWakeupListInit(&writer->wakeupList);
+	  newPipe->writer = writer;
+	  newPipe = NULL;
+	  return ((int) writer);
+	}
+	semDelete(writer->semExcl);
+      }
+      free(writer);
+    }
+    if (newPipe != NULL)
+      free(newPipe);
+    newPipe = NULL;
+    errno = ENOMEM;
+  } else {
+    errno = EINVAL;
+  }
+  return (ERROR);
+}
+
+/***************************************************************************
+ *
+ * uxPipeClose - close read or write end of a pipe.
+ *
+ * RETURNS:
+ *    OK, or ERROR if device descriptor does not refer to an open read or
+ write end of a pipe (errno = EBADF).
+ */
+
+LOCAL int
+uxPipeClose(UXPIPE_DEV *pDev)
+{
+  UXPIPE *pajp = pDev->pipe;
+
+  taskLock();
+  if (pDev == pajp->reader) {
+    /* Close this end */
+    semDelete(pDev->semExcl);
+    semDelete(pDev->semBlock);
+    free(pDev);
+    pajp->reader = NULL;
+    /* Inform the other end */
+    if (pajp->writer != NULL) {
+      selWakeupAll(&pajp->writer->wakeupList, SELWRITE);
+      semGive(pajp->writer->semBlock);
+    }
+  } else if (pDev == pajp->writer) {
+    /* Close this end */
+    semDelete(pDev->semExcl);
+    semDelete(pDev->semBlock);
+    free(pDev);
+    pajp->writer = NULL;
+    /* Inform the other end */
+    if (pajp->reader != NULL) {
+      selWakeupAll(&pajp->reader->wakeupList, SELREAD);
+      semGive(pajp->reader->semBlock);
+    }
+  } else {
+    errno = EBADF;
+    taskUnlock();
+    return (ERROR);
+  }
+  if (pajp->reader == NULL && pajp->writer == NULL) {
+    rngDelete(pajp->ringId);
+    pajp->drvNum = 0;
+    free(pajp);
+  }
+  taskUnlock();
+  return (OK);
+}
+/***************************************************************************
+ *
+ * uxPipeRead - read from a pipe.
+ *
+ * Reads at most maxbytes bytes from the pipe. Blocks if blocking mode is
+ * set and the pipe is empty.
+ *
+ * RETURNS:
+ *    number of bytes read, 0 on EOF, or ERROR if device descriptor does
+ *    not refer to an open read end of a pipe (errno = EBADF), or if 
+ *    non-blocking mode is set and the pipe is empty (errno = EWOULDBLOCK).
+ */
+
+LOCAL int
+uxPipeRead(UXPIPE_DEV *pDev, char *buffer, int maxbytes)
+{
+  UXPIPE *pajp = pDev->pipe;
+  int   nbytes = 0;
+
+  if (pDev != pajp->reader) {
+    errno = EBADF;
+    return (ERROR);
+  }
+  if (maxbytes == 0)
+    return (0);
+  semTake(pDev->semExcl, WAIT_FOREVER);
+  /* 
+   * Note that semBlock may be full, although there is nothing to read.
+   * This happens e.g. after the following sequence of operations: a 
+   * reader task blocks, a writer task writes two times (the first 
+   * write unblocks the reader task, the second write makes semBlock
+   * full).
+   */
+  while (nbytes == 0) {
+    if (pDev->blocking) 
+      semTake(pDev->semBlock, WAIT_FOREVER);
+    /* 
+     * Reading and updating of the write end must not be interleaved
+     * with a write from another task - hence we lock this task.
+     */
+    taskLock();
+    nbytes = rngBufGet(pajp->ringId, buffer, maxbytes);
+    if (nbytes > 0) {
+      /* Give own semaphore if bytes remain or if write end is closed */
+      if ((!rngIsEmpty(pajp->ringId) || pajp->writer == NULL) &&
+	  pDev->blocking)
+	semGive(pDev->semBlock);
+      /* Inform write end */
+      if (pajp->writer != NULL) {
+	if (pajp->writer->blocking) 
+	  semGive(pajp->writer->semBlock);
+	selWakeupAll(&pajp->writer->wakeupList, SELWRITE);
+      }
+    } else if (pajp->writer == NULL) {
+      nbytes = 0;		/* EOF */
+      /* Give semaphore when write end is closed */
+      if (pDev->blocking) 
+	semGive(pDev->semBlock);
+      taskUnlock();
+      semGive(pDev->semExcl);
+      return (nbytes);
+    } else if (!pDev->blocking) {
+      taskUnlock();
+      semGive(pDev->semExcl);
+      errno = EWOULDBLOCK;
+      return (ERROR);
+    }      
+    taskUnlock();
+  }
+  semGive(pDev->semExcl);
+  return (nbytes);
+}
+
+/***************************************************************************
+ *
+ * uxPipeWrite - write to a pipe.
+ *
+ * Writes nbytes bytes to the pipe. Blocks if blocking mode is set, and if 
+ * the pipe is full.
+ *
+ * RETURNS:
+ * number of bytes written, or ERROR if the device descriptor does not
+ * refer to an open write end of a pipe (errno = EBADF); or if the read end
+ * of the pipe is closed (errno = EPIPE); or if non-blocking mode is set
+ * and the pipe is full (errno = EWOULDBLOCK).
+ *
+ */
+
+LOCAL int
+uxPipeWrite(UXPIPE_DEV *pDev, char *buffer, int nbytes)
+{
+
+  UXPIPE *pajp = pDev->pipe;
+  int   sofar = 0, written;
+
+  if (pDev != pajp->writer) {
+    errno = EBADF;
+    return (ERROR);
+  }
+  if (pajp->reader == NULL) {
+    errno = EPIPE;
+    return (ERROR);
+  }
+  if (nbytes == 0)
+    return (0);
+  semTake(pDev->semExcl, WAIT_FOREVER);
+  while (sofar < nbytes) {
+    if (pDev->blocking)
+      semTake(pDev->semBlock, WAIT_FOREVER);
+    if (pajp->reader == NULL) {
+      errno = EPIPE;
+      semGive(pDev->semBlock);
+      semGive(pDev->semExcl);
+      return (ERROR);
+    }
+    /* Writing and updating of the read end must not be interleaved
+     * with a read from another task - hence we lock this task.
+     */
+    taskLock();
+    written = rngBufPut(pajp->ringId, buffer + sofar, nbytes - sofar);
+    sofar += written;
+    /* Inform the read end if we really wrote something */
+    if (written > 0 && pajp->reader != NULL) {
+      selWakeupAll(&pajp->reader->wakeupList, SELREAD);
+      if (pajp->reader->blocking)
+	semGive(pajp->reader->semBlock);
+    }
+    taskUnlock();
+    if (!pDev->blocking) {
+      if (sofar == 0) {
+      errno = EWOULDBLOCK;
+      sofar = ERROR;
+      }
+      break;
+    }
+  }
+  /* Give own semaphore if space remains */
+  if (!rngIsFull(pajp->ringId) && pDev->blocking)
+    semGive(pDev->semBlock);
+  semGive(pDev->semExcl);
+  return (sofar);
+}
+
+/***************************************************************************
+ *
+ * uxPipeIoctl - do device specific I/O control
+ *
+ * RETURNS:
+ *    OK or ERROR.
+ */
+
+LOCAL STATUS
+uxPipeIoctl(FAST UXPIPE_DEV *pDev, FAST int function, int arg)
+     
+{
+  UXPIPE *pajp = pDev->pipe;
+  int   status = OK;
+
+  switch (function) {
+  case FIONBIO:
+    pDev->blocking = (*(int *)arg) ? 0 : 1;
+    break;
+  case FIOSELECT:
+    taskLock();
+    selNodeAdd(&pDev->wakeupList, (SEL_WAKEUP_NODE *) arg);
+    if (selWakeupType((SEL_WAKEUP_NODE *) arg) == SELREAD &&
+	pDev == pajp->reader &&
+	(!rngIsEmpty(pajp->ringId) || pajp->writer == NULL))
+      selWakeup((SEL_WAKEUP_NODE *) arg);
+    if (selWakeupType((SEL_WAKEUP_NODE *) arg) == SELWRITE &&
+	pDev == pajp->writer &&
+	(!rngIsFull(pajp->ringId) || pajp->reader == NULL))
+      selWakeup((SEL_WAKEUP_NODE *) arg);
+    taskUnlock();
+    break;
+  case FIOUNSELECT:
+    selNodeDelete(&pDev->wakeupList, (SEL_WAKEUP_NODE *) arg);
+    break;
+  default:
+    status = ERROR;
+    break;
+  }
+  return (status);
+}
+
+/***************************************************************************
+ *
+ * pipe - create an intertask channel
+ *
+ * Creates a pipe. fd[0] (fd[1]) is the read (write) file descriptor.
+ *
+ * RETURNS:
+ *    OK or ERROR, if the pipe could not be created.
+ */
+
+STATUS
+pipe(int fd[2])
+{
+  semTake(pipeSem, WAIT_FOREVER);
+  if ((fd[0] = open(pipeRead, O_RDONLY, 0)) != ERROR) {
+    if ((fd[1] = open(pipeWrite, O_WRONLY, 0)) != ERROR) {
+      semGive(pipeSem);
+      return (OK);
+    }
+    (void) close(fd[0]);
+  }
+  errno &= 0xFFFF;
+  if((errno & 0xFFFF) == EINTR) /* Why on earth EINTR??? */
+      errno = ENFILE;           /* It means we are out of file descriptors...*/
+  semGive(pipeSem);
+  return (ERROR);
+}
+
+/***************************************************************************
+ *
+ * uxPipeShow - display pipe information
+ *
+ * RETURNS:
+ *    N/A.
+ */
+
+void
+uxPipeShow(int fd)
+{
+  UXPIPE_DEV *pDev;
+  UXPIPE *pajp;
+  int drvValue;
+
+  if ((drvValue = iosFdValue(fd)) == ERROR) {
+    erts_fprintf(stderr, "Error: file descriptor invalid\n");
+    return;
+  }
+  pDev = (UXPIPE_DEV *)drvValue;
+  pajp = pDev->pipe;
+  if (pajp->drvNum != uxPipeDrvNum) {
+    erts_fprintf(stderr, "Error: Not a ux pipe device\n");
+    return;
+  }
+  erts_fprintf(stderr, "Device              : 0x%x\n", (int) pDev);
+  erts_fprintf(stderr, "Buffer size         : %d\n", UXPIPE_SIZE);
+  erts_fprintf(stderr, "Bytes in buffer     : %d\n\n", rngNBytes(pajp->ringId));
+  erts_fprintf(stderr, "READ END\n\n");
+  if (pajp->reader != NULL) {
+    erts_fprintf(stderr, "Mode                : ");
+    erts_fprintf(stderr, "%s\n", 
+	       (pajp->reader->blocking) ? "blocking" : "non-blocking");
+  }
+  erts_fprintf(stderr, "Status              : ");
+  if (pajp->reader != NULL) {
+    erts_fprintf(stderr, "OPEN\n");
+    erts_fprintf(stderr, "Wake-up list        : %d\n\n", 
+	       selWakeupListLen(&pajp->reader->wakeupList));
+    erts_fprintf(stderr, "Exclusion Semaphore\n");
+    semShow(pajp->reader->semExcl, 1);
+    erts_fprintf(stderr, "Blocking Semaphore\n");
+    semShow(pajp->reader->semBlock, 1);
+  } else 
+    erts_fprintf(stderr, "CLOSED\n\n");
+  erts_fprintf(stderr, "WRITE END\n\n");
+  if (pajp->writer != NULL) {
+    erts_fprintf(stderr, "Mode                : ");
+    erts_fprintf(stderr, "%s\n", 
+	       (pajp->writer->blocking) ? "blocking" : "non-blocking");
+  }
+  erts_fprintf(stderr, "Status              : ");
+  if (pajp->writer != NULL) {
+    erts_fprintf(stderr, "OPEN\n");
+    erts_fprintf(stderr, "Wake-up list        : %d\n\n", 
+	       selWakeupListLen(&pajp->writer->wakeupList));
+    erts_fprintf(stderr, "Exclusion Semaphore\n");
+    semShow(pajp->writer->semExcl, 1);
+    erts_fprintf(stderr, "Blocking Semaphore\n");
+    semShow(pajp->writer->semBlock, 1);
+  } else 
+    erts_fprintf(stderr, "CLOSED\n\n");
+}
+
+#ifdef DEBUG
+void
+erl_assert_error(char* expr, char* file, int line)
+{   
+    fflush(stdout);
+    fprintf(stderr, "Assertion failed: %s in %s, line %d\n",
+	    expr, file, line);
+    fflush(stderr);
+    erl_crash_dump(file, line, "Assertion failed: %s\n", expr);
+    abort();
+}
+void
+erl_debug(char* fmt, ...)
+{
+    char sbuf[1024];		/* Temporary buffer. */
+    va_list va;
+    
+    va_start(va, fmt);
+    vsprintf(sbuf, fmt, va);
+    va_end(va);
+    fprintf(stderr, "%s\n", sbuf);
+}
+#endif