Merge branch 'lukas/ose/master/OTP-11334'

* lukas/ose/master/OTP-11334: (71 commits)
  erts: Fix unix efile assert
  ose: Use -O2 when building
  ose: Expand OSE docs
  ose: Add dummy ttsl driver
  ose: Cleanup cleanup of mutex selection defines
  ose: Polish mmap configure checks
  ose: Add ose specific x-compile flags
  ose: Updating fd_driver and spawn_driver for OSE
  ose: Updating event and signal API for OSE
  ose: Cleanup of mutex selection defines
  win32: Compile erl_log.exe
  ose: Remove uneccesary define
  ose: Fix ssl configure test for osx
  erts: Fix sys_msg_dispatcher assert
  ose: Fix broken doc links
  ose: Thread priorities configurable from lmconf
  ose: Yielding the cpu is done "the OSE" way
  ose: Start using ppdata for tse key
  ose: Do not use spinlocks on OSE
  ose: Fix support for crypto
  ...

Conflicts:
	lib/crypto/c_src/crypto.c

9 files changed, 2235 insertions, 5 deletions

diff --git a/erts/emulator/drivers/common/efile_drv.c b/erts/emulator/drivers/common/efile_drv.c
index e040864d24..b62e9a0306 100644
--- a/erts/emulator/drivers/common/efile_drv.c
+++ b/erts/emulator/drivers/common/efile_drv.c
@@ -99,7 +99,16 @@
 #ifdef HAVE_CONFIG_H
 #  include "config.h"
 #endif
+
+#ifndef __OSE__
+#include <ctype.h>
+#include <sys/types.h>
 #include <stdlib.h>
+#else
+#include "ctype.h"
+#include "sys/types.h"
+#include "stdlib.h"
+#endif
 
 /* Need (NON)BLOCKING macros for sendfile */
 #ifndef WANT_NONBLOCKING
@@ -113,8 +122,7 @@
 #include "erl_threads.h"
 #include "gzio.h"
 #include "dtrace-wrapper.h" 
-#include <ctype.h>
-#include <sys/types.h>
+
 
 void erl_exit(int n, char *fmt, ...);
 
@@ -765,6 +773,9 @@ file_init(void)
 			    : 0);
     driver_system_info(&sys_info, sizeof(ErlDrvSysInfo));
 
+    /* run initiation of efile_driver if needed */
+    efile_init();
+
 #ifdef  USE_VM_PROBES
     erts_mtx_init(&dt_driver_mutex, "efile_drv dtrace mutex");
     pthread_key_create(&dt_driver_key, NULL);
@@ -911,6 +922,7 @@ static void reply_Uint_posix_error(file_descriptor *desc, Uint num,
     driver_output2(desc->port, response, t-response, NULL, 0);
 }
 
+#ifdef HAVE_SENDFILE
 static void reply_string_error(file_descriptor *desc, char* str) {
     char response[256];		/* Response buffer. */
     char* s;
@@ -921,6 +933,7 @@ static void reply_string_error(file_descriptor *desc, char* str) {
 	*t = tolower(*s);
     driver_output2(desc->port, response, t-response, NULL, 0);
 }
+#endif
 
 static int reply_error(file_descriptor *desc, 
 		       Efile_error *errInfo) /* The error codes. */
diff --git a/erts/emulator/drivers/common/erl_efile.h b/erts/emulator/drivers/common/erl_efile.h
index 95c036db8f..5a8e3bc5db 100644
--- a/erts/emulator/drivers/common/erl_efile.h
+++ b/erts/emulator/drivers/common/erl_efile.h
@@ -127,7 +127,7 @@ struct t_sendfile_hdtl {
 /*
  * Functions.
  */
-
+int efile_init(void);
 int efile_mkdir(Efile_error* errInfo, char* name);
 int efile_rmdir(Efile_error* errInfo, char* name);
 int efile_delete_file(Efile_error* errInfo, char* name);
diff --git a/erts/emulator/drivers/common/gzio.c b/erts/emulator/drivers/common/gzio.c
index 8ec2c3f762..ef539f8f9b 100644
--- a/erts/emulator/drivers/common/gzio.c
+++ b/erts/emulator/drivers/common/gzio.c
@@ -20,6 +20,7 @@
 #endif
 #include <ctype.h>
 #include "erl_driver.h"
+#include "erl_efile.h"
 #include "sys.h"
 
 #ifdef __WIN32__
@@ -597,6 +598,15 @@ erts_gzseek(ErtsGzFile file, int offset, int whence)
     int pos;
     gz_stream* s = (gz_stream *) file;
 
+    switch (whence) {
+    case EFILE_SEEK_SET: whence = SEEK_SET; break;
+    case EFILE_SEEK_CUR: whence = SEEK_CUR; break;
+    case EFILE_SEEK_END: whence = SEEK_END; break;
+    default:
+	errno = EINVAL;
+	return -1;
+    }
+
     if (s == NULL) {
 	errno = EINVAL;
 	return -1;
diff --git a/erts/emulator/drivers/common/inet_drv.c b/erts/emulator/drivers/common/inet_drv.c
index 4a861b121c..357a4b7bcb 100644
--- a/erts/emulator/drivers/common/inet_drv.c
+++ b/erts/emulator/drivers/common/inet_drv.c
@@ -121,6 +121,10 @@ typedef unsigned long long llu_t;
 #undef WANT_NONBLOCKING
 #include "sys.h"
 
+#ifdef __OSE__
+#include "inet.h"
+#endif
+
 #undef EWOULDBLOCK
 #undef ETIMEDOUT
 
@@ -289,7 +293,111 @@ static BOOL (WINAPI *fpSetHandleInformation)(HANDLE,DWORD,DWORD);
 static unsigned long zero_value = 0;
 static unsigned long one_value = 1;
 
-#else /* #ifdef __WIN32__ */
+#elif defined (__OSE__)
+#include "sys/socket.h"
+#include "sys/uio.h"
+#include "sfk/sys/sfk_uio.h"
+#include "netinet/in.h"
+#include "netinet/tcp.h"
+#include "netdb.h"
+
+ssize_t writev(int fd, const struct iovec *iov, int iovcnt)
+{
+   return 0;
+}
+
+#define INVALID_SOCKET -1
+#define INVALID_EVENT  -1
+#define SOCKET_ERROR   -1
+
+#define SOCKET int
+#define HANDLE long int
+#define FD_READ    ERL_DRV_READ
+#define FD_WRITE   ERL_DRV_WRITE
+#define FD_CLOSE   0
+#define FD_CONNECT ERL_DRV_WRITE
+#define FD_ACCEPT  ERL_DRV_READ
+
+#define sock_connect(s, addr, len)  connect((s), (addr), (len))
+#define sock_listen(s, b)           listen((s), (b))
+#define sock_bind(s, addr, len)     bind((s), (addr), (len))
+#define sock_getopt(s,t,n,v,l)      getsockopt((s),(t),(n),(v),(l))
+#define sock_setopt(s,t,n,v,l)      setsockopt((s),(t),(n),(v),(l))
+#define sock_name(s, addr, len)     getsockname((s), (addr), (len))
+#define sock_peer(s, addr, len)     getpeername((s), (addr), (len))
+#define sock_ntohs(x)               ntohs((x))
+#define sock_ntohl(x)               ntohl((x))
+#define sock_htons(x)               htons((x))
+#define sock_htonl(x)               htonl((x))
+
+#define sock_accept(s, addr, len)   accept((s), (addr), (len))
+#define sock_send(s,buf,len,flag)   inet_send((s),(buf),(len),(flag))
+#define sock_sendto(s,buf,blen,flag,addr,alen) \
+                sendto((s),(buf),(blen),(flag),(addr),(alen))
+#define sock_sendv(s, vec, size, np, flag) \
+		(*(np) = writev((s), (struct iovec*)(vec), (size)))
+#define sock_sendmsg(s,msghdr,flag) sendmsg((s),(msghdr),(flag))
+
+#define sock_open(af, type, proto)  socket((af), (type), (proto))
+#define sock_close(s)               close((s))
+#define sock_shutdown(s, how)       shutdown((s), (how))
+
+#define sock_hostname(buf, len)     gethostname((buf), (len))
+#define sock_getservbyname(name,proto) getservbyname((name), (proto))
+#define sock_getservbyport(port,proto) getservbyport((port), (proto))
+
+#define sock_recv(s,buf,len,flag)   recv((s),(buf),(len),(flag))
+#define sock_recvfrom(s,buf,blen,flag,addr,alen) \
+                recvfrom((s),(buf),(blen),(flag),(addr),(alen))
+#define sock_recvmsg(s,msghdr,flag) recvmsg((s),(msghdr),(flag))
+
+#define sock_errno()                errno
+#define sock_create_event(d)        ((d)->s) /* return file descriptor */
+#define sock_close_event(e)                  /* do nothing */
+
+#define inet_driver_select(port, e, mode, on) \
+                                    driver_select(port, e, mode | (on?ERL_DRV_USE:0), on)
+
+#define sock_select(d, flags, onoff) do { \
+        ASSERT(!(d)->is_ignored); \
+        (d)->event_mask = (onoff) ? \
+                 ((d)->event_mask | (flags)) : \
+                 ((d)->event_mask & ~(flags)); \
+        DEBUGF(("sock_select(%ld): flags=%02X, onoff=%d, event_mask=%02lX\r\n", \
+		(long) (d)->port, (flags), (onoff), (unsigned long) (d)->event_mask)); \
+        inet_driver_select((d)->port, (ErlDrvEvent)(long)(d)->event, (flags), (onoff)); \
+   } while(0)
+
+#ifndef WANT_NONBLOCKING
+#define WANT_NONBLOCKING
+#endif
+#include "sys.h"
+
+typedef unsigned long  u_long;
+#define  IN_CLASSA(a)      ((((in_addr_t)(a)) & 0x80000000) == 0)
+#define  IN_CLASSA_NET     0xff000000
+#define  IN_CLASSA_NSHIFT  24
+#define  IN_CLASSA_HOST    (0xffffffff & ~IN_CLASSA_NET)
+#define  IN_CLASSA_MAX     128
+
+#define  IN_CLASSB(a)      ((((in_addr_t)(a)) & 0xc0000000) == 0x80000000)
+#define  IN_CLASSB_NET     0xffff0000
+#define  IN_CLASSB_NSHIFT  16
+#define  IN_CLASSB_HOST    (0xffffffff & ~IN_CLASSB_NET)
+#define  IN_CLASSB_MAX     65536
+
+#define  IN_CLASSC(a)      ((((in_addr_t)(a)) & 0xe0000000) == 0xc0000000)
+#define  IN_CLASSC_NET     0xffffff00
+#define  IN_CLASSC_NSHIFT  8
+#define  IN_CLASSC_HOST    (0xffffffff & ~IN_CLASSC_NET)
+
+#define  IN_CLASSD(a)      ((((in_addr_t)(a)) & 0xf0000000) == 0xe0000000)
+#define  IN_MULTICAST(a)      IN_CLASSD(a)
+
+#define  IN_EXPERIMENTAL(a)   ((((in_addr_t)(a)) & 0xe0000000) == 0xe0000000)
+#define  IN_BADCLASS(a)    ((((in_addr_t)(a)) & 0xf0000000) == 0xf0000000)
+
+#else /* !__OSE__ && !__WIN32__ */
 
 #include <sys/time.h>
 #ifdef NETDB_H_NEEDS_IN_H
diff --git a/erts/emulator/drivers/ose/ose_efile.c b/erts/emulator/drivers/ose/ose_efile.c
new file mode 100644
index 0000000000..035ff81a9b
--- /dev/null
+++ b/erts/emulator/drivers/ose/ose_efile.c
@@ -0,0 +1,1124 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 1997-2012. 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%
+ */
+/*
+ * Purpose: Provides file and directory operations for OSE.
+ */
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+#if defined(HAVE_POSIX_FALLOCATE) && !defined(__sun) && !defined(__sun__)
+#define _XOPEN_SOURCE 600
+#endif
+#if !defined(_GNU_SOURCE) && defined(HAVE_LINUX_FALLOC_H)
+#define _GNU_SOURCE
+#endif
+#include "sys.h"
+#include "erl_driver.h"
+#include "erl_efile.h"
+#if defined(DARWIN) || defined(HAVE_LINUX_FALLOC_H) || defined(HAVE_POSIX_FALLOCATE)
+#include "fcntl.h"
+#endif
+#include "ose.h"
+#include "unistd.h"
+#include "sys/stat.h"
+#include "dirent.h"
+#include "sys/time.h"
+#include "time.h"
+#include "assert.h"
+
+/* Find a definition of MAXIOV, that is used in the code later. */
+#if defined IOV_MAX
+#define MAXIOV IOV_MAX
+#elif defined UIO_MAXIOV
+#define MAXIOV UIO_MAXIOV
+#else
+#define MAXIOV 16
+#endif
+
+/*
+ * Macros for testing file types.
+ */
+
+#define ISDIR(st) (((st).st_mode & S_IFMT) == S_IFDIR)
+#define ISREG(st) (((st).st_mode & S_IFMT) == S_IFREG)
+#define ISDEV(st) \
+    (((st).st_mode&S_IFMT) == S_IFCHR || ((st).st_mode&S_IFMT) == S_IFBLK)
+#define ISLNK(st) (((st).st_mode & S_IFLNK) == S_IFLNK)
+#ifdef NO_UMASK
+#define FILE_MODE 0644
+#define DIR_MODE  0755
+#else
+#define FILE_MODE 0666
+#define DIR_MODE  0777
+#endif
+
+#define IS_DOT_OR_DOTDOT(s) \
+    (s[0] == '.' && (s[1] == '\0' || (s[1] == '.' && s[2] == '\0')))
+
+/*
+ * Macros for handling local file descriptors
+ * and mutexes.
+ *
+ * Handling of files like this is necessary because OSE
+ * does not allow seeking after the end of a file. So
+ * what we do it emulate this by keeping track of the size
+ * of the file and where the file's positions is. If a
+ * write happens after eof then we pad it.
+ *
+ * Given time this should be rewritten to get rid of the
+ * mutex and use the port lock to protect the data. This
+ * could be done be done by adapting the efile api for some
+ * calls to allow some meta-data to be associated with the
+ * open file.
+ */
+
+#define L_FD_IS_VALID(fd_data) ((fd_data)->beyond_eof > 0)
+#define L_FD_INVALIDATE(fd_data) (fd_data)->beyond_eof = 0
+#define L_FD_CUR(fd_data) (fd_data)->pos
+#define L_FD_OFFS_BEYOND_EOF(fd_data, offs) \
+    (((fd_data)->size > offs) ? 0 : 1)
+
+#define L_FD_FAIL -1
+#define L_FD_SUCCESS 1
+#define L_FD_PAD_SIZE 255
+
+struct fd_meta {
+    ErlDrvMutex *meta_mtx;
+    struct fd_data *fd_data_list;
+};
+
+struct fd_data {
+    int fd;
+    struct fd_data *next;
+    struct fd_data *prev;
+    int pos;
+    int beyond_eof;
+    size_t size;
+#ifdef DEBUG
+    PROCESS owner;
+#endif
+};
+
+static int l_invalidate_local_fd(int fd);
+static int l_pad_file(struct fd_data *fd_data, off_t offset);
+static int check_error(int result, Efile_error* errInfo);
+static struct fd_data* l_new_fd(void);
+static int l_remove_local_fd(int fd);
+static struct fd_data* l_find_local_fd(int fd);
+static int l_update_local_fd(int fd, int pos, int size);
+
+static struct fd_meta* fdm = NULL;
+
+
+/***************************************************************************/
+
+static int
+l_remove_local_fd(int fd)
+{
+    struct fd_data *fd_data;
+    fd_data = l_find_local_fd(fd);
+
+    if (fd_data == NULL) {
+        return L_FD_FAIL;
+    }
+#ifdef DEBUG
+    assert(fd_data->owner == current_process());
+#endif
+    erl_drv_mutex_lock(fdm->meta_mtx);
+    /* head ? */
+    if (fd_data == fdm->fd_data_list) {
+        if (fd_data->next != NULL) {
+            /* remove link to head */
+            fd_data->next->prev = NULL;
+            /* set new head */
+            fdm->fd_data_list = fd_data->next;
+        }
+        else {
+            /* head is lonely */
+            fdm->fd_data_list = NULL;
+        }
+    }
+    else { /* not head */
+        if (fd_data->prev == NULL) {
+            erl_drv_mutex_unlock(fdm->meta_mtx);
+            return L_FD_FAIL;
+        }
+        else {
+            if (fd_data->next != NULL) {
+                fd_data->next->prev = fd_data->prev;
+                fd_data->prev->next = fd_data->next;
+            }
+            else {
+                fd_data->prev->next = NULL;
+            }
+        }
+    }
+
+    /* scramble values */
+    fd_data->beyond_eof = -1;
+    fd_data->next = NULL;
+    fd_data->prev = NULL;
+    fd_data->fd = -1;
+
+    /* unlock and clean */
+    driver_free(fd_data);
+    erl_drv_mutex_unlock(fdm->meta_mtx);
+
+    return L_FD_SUCCESS;
+}
+
+/***************************************************************************/
+
+static int
+l_invalidate_local_fd(int fd) {
+    struct fd_data *fd_data;
+
+    if ((fd_data = l_find_local_fd(fd)) == NULL) {
+        return L_FD_FAIL;
+    }
+
+    fd_data->beyond_eof = 0;
+    return L_FD_SUCCESS;
+}
+
+/****************************************************************************/
+
+static struct fd_data*
+l_find_local_fd(int fd) {
+    struct fd_data *fd_data;
+
+    fd_data = NULL;
+    erl_drv_mutex_lock(fdm->meta_mtx);
+    for (fd_data = fdm->fd_data_list; fd_data != NULL; ) {
+        if (fd_data->fd == fd) {
+#ifdef DEBUG
+            assert(fd_data->owner == current_process());
+#endif
+            break;
+        }
+        fd_data = fd_data->next;
+    }
+    erl_drv_mutex_unlock(fdm->meta_mtx);
+    return fd_data;
+}
+
+/***************************************************************************/
+
+static struct fd_data*
+l_new_fd(void) {
+    struct fd_data *fd_data;
+
+    fd_data = driver_alloc(sizeof(struct fd_data));
+    if (fd_data == NULL) {
+        return NULL;
+    }
+    erl_drv_mutex_lock(fdm->meta_mtx);
+    if (fdm->fd_data_list == NULL) {
+        fdm->fd_data_list = fd_data;
+        fdm->fd_data_list->prev = NULL;
+        fdm->fd_data_list->next = NULL;
+    }
+    else {
+        fd_data->next = fdm->fd_data_list;
+        fdm->fd_data_list = fd_data;
+        fdm->fd_data_list->prev = NULL;
+    }
+#ifdef DEBUG
+    fd_data->owner = current_process();
+#endif
+    erl_drv_mutex_unlock(fdm->meta_mtx);
+    return fd_data;
+}
+
+/***************************************************************************/
+
+static int
+l_update_local_fd(int fd, int pos, int size) {
+    struct fd_data *fd_data = NULL;
+
+    fd_data = l_find_local_fd(fd);
+    /* new fd to handle? */
+    if (fd_data == NULL) {
+        fd_data = l_new_fd();
+        if (fd_data == NULL) {
+            /* out of memory */
+            return L_FD_FAIL;
+        }
+    }
+    fd_data->size = size;
+    fd_data->pos = pos;
+    fd_data->fd = fd;
+    fd_data->beyond_eof = 1;
+
+    return L_FD_SUCCESS;
+}
+
+/***************************************************************************/
+
+static int
+l_pad_file(struct fd_data *fd_data, off_t offset) {
+    int size_dif;
+    int written = 0;
+    int ret_val = L_FD_SUCCESS;
+    char padding[L_FD_PAD_SIZE];
+
+    size_dif = (offset - fd_data->size);
+    memset(&padding, '\0', L_FD_PAD_SIZE);
+
+    while (size_dif > 0) {
+        written = write(fd_data->fd, padding,
+                (size_dif < L_FD_PAD_SIZE) ?
+                size_dif : L_FD_PAD_SIZE);
+        if (written < 0 && errno != EINTR && errno != EAGAIN) {
+            ret_val = -1;
+            break;
+        }
+        size_dif -= written;
+    }
+    L_FD_INVALIDATE(fd_data);
+    return ret_val;
+}
+
+/***************************************************************************/
+
+static int
+check_error(int result, Efile_error *errInfo) {
+    if (result < 0) {
+        errInfo->posix_errno = errInfo->os_errno = errno;
+        return 0;
+    }
+    return 1;
+}
+
+/***************************************************************************/
+
+int
+efile_init() {
+    fdm = driver_alloc(sizeof(struct fd_meta));
+    if (fdm == NULL) {
+        return L_FD_FAIL;
+    }
+    fdm->meta_mtx = erl_drv_mutex_create("ose_efile local fd mutex\n");
+    erl_drv_mutex_lock(fdm->meta_mtx);
+    fdm->fd_data_list = NULL;
+    erl_drv_mutex_unlock(fdm->meta_mtx);
+    return L_FD_SUCCESS;
+}
+
+/***************************************************************************/
+
+int
+efile_mkdir(Efile_error* errInfo,       /* Where to return error codes. */
+        char* name)                 /* Name of directory to create. */
+{
+#ifdef NO_MKDIR_MODE
+    return check_error(mkdir(name), errInfo);
+#else
+    int res = mkdir(name, DIR_MODE);
+    if (res < 0 && errno == EINVAL) {
+      errno = ENOENT;
+    }
+    return check_error(res, errInfo);
+#endif
+}
+
+/***************************************************************************/
+
+int
+efile_rmdir(Efile_error* errInfo,       /* Where to return error codes. */
+        char* name)                 /* Name of directory to delete. */
+{
+    if (rmdir(name) == 0) {
+        return 1;
+    }
+    if (errno == ENOTEMPTY) {
+        errno = EEXIST;
+    }
+    if (errno == EEXIST || errno == EINVAL) {
+        int saved_errno = errno;
+        struct stat file_stat;
+        struct stat cwd_stat;
+
+        if(stat(name, &file_stat) != 0) {
+            errno = ENOENT;
+            return check_error(-1, errInfo);
+        }
+        /*
+         *  The error code might be wrong if this is the current directory.
+         */
+        if (stat(name, &file_stat) == 0 && stat(".", &cwd_stat) == 0 &&
+                file_stat.st_ino == cwd_stat.st_ino &&
+                file_stat.st_dev == cwd_stat.st_dev) {
+            saved_errno = EACCES;
+        }
+        errno = saved_errno;
+    }
+    return check_error(-1, errInfo);
+}
+
+/***************************************************************************/
+
+int
+efile_delete_file(Efile_error* errInfo, /* Where to return error codes. */
+        char* name)           /* Name of file to delete. */
+{
+    struct stat statbuf;
+
+    if (stat(name, &statbuf) >= 0) {
+        /* Do not let unlink() remove directories */
+        if (ISDIR(statbuf)) {
+            errno = EPERM;
+            return check_error(-1, errInfo);
+        }
+
+        if (unlink(name) == 0) {
+            return 1;
+        }
+
+        if (errno == EISDIR) {
+            errno = EPERM;
+            return check_error(-1, errInfo);
+        }
+    }
+    else {
+        if (errno == EINVAL) {
+            errno = ENOENT;
+            return check_error(-1, errInfo);
+        }
+    }
+    return check_error(-1, errInfo);
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ *      Changes the name of an existing file or directory, from src to dst.
+ *      If src and dst refer to the same file or directory, does nothing
+ *      and returns success.  Otherwise if dst already exists, it will be
+ *      deleted and replaced by src subject to the following conditions:
+ *          If src is a directory, dst may be an empty directory.
+ *          If src is a file, dst may be a file.
+ *      In any other situation where dst already exists, the rename will
+ *      fail.
+ *
+ * Results:
+ *      If the directory was successfully created, returns 1.
+ *      Otherwise the return value is 0 and errno is set to
+ *      indicate the error.  Some possible values for errno are:
+ *
+ *      EACCES:     src or dst parent directory can't be read and/or written.
+ *      EEXIST:     dst is a non-empty directory.
+ *      EINVAL:     src is a root directory or dst is a subdirectory of src.
+ *      EISDIR:     dst is a directory, but src is not.
+ *      ENOENT:     src doesn't exist, or src or dst is "".
+ *      ENOTDIR:    src is a directory, but dst is not.
+ *      EXDEV:      src and dst are on different filesystems.
+ *
+ * Side effects:
+ *      The implementation of rename may allow cross-filesystem renames,
+ *      but the caller should be prepared to emulate it with copy and
+ *      delete if errno is EXDEV.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+int
+efile_rename(Efile_error* errInfo,      /* Where to return error codes. */
+        char* src,                 /* Original name. */
+        char* dst)                 /* New name. */
+{
+
+    /* temporary fix AFM does not recognize ./<file name>
+     * in destination remove pending on adaption of AFM fix
+     */
+
+    char *dot_str;
+    if (dst != NULL) {
+        dot_str = strchr(dst, '.');
+        if (dot_str && dot_str == dst && dot_str[1] == '/') {
+            dst = dst+2;
+        }
+    }
+
+    if (rename(src, dst) == 0) {
+        return 1;
+    }
+    if (errno == ENOTEMPTY) {
+        errno = EEXIST;
+    }
+    if (errno == EINVAL) {
+        struct stat file_stat;
+
+        if (stat(dst, &file_stat)== 0) {
+            if (ISDIR(file_stat)) {
+                errno = EISDIR;
+            }
+            else if (ISREG(file_stat)) {
+                errno = ENOTDIR;
+            }
+            else {
+                errno = EINVAL;
+            }
+        }
+        else {
+            errno = EINVAL;
+        }
+    }
+
+    if (strcmp(src, "/") == 0) {
+        errno = EINVAL;
+    }
+    return check_error(-1, errInfo);
+}
+
+/***************************************************************************/
+
+int
+efile_chdir(Efile_error* errInfo,   /* Where to return error codes. */
+        char* name)             /* Name of directory to make current. */
+{
+    return check_error(chdir(name), errInfo);
+}
+
+/***************************************************************************/
+
+int
+efile_getdcwd(Efile_error* errInfo,     /* Where to return error codes. */
+        int drive,                /* 0 - current, 1 - A, 2 - B etc. */
+        char* buffer,             /* Where to return the current
+                                     directory. */
+        size_t size)              /* Size of buffer. */
+{
+    if (drive == 0) {
+        if (getcwd(buffer, size) == NULL)
+            return check_error(-1, errInfo);
+
+        return 1;
+    }
+
+    /*
+     * Drives other than 0 is not supported on Unix.
+     */
+
+    errno = ENOTSUP;
+    return check_error(-1, errInfo);
+}
+
+/***************************************************************************/
+
+int
+efile_readdir(Efile_error* errInfo,     /* Where to return error codes. */
+        char* name,               /* Name of directory to open. */
+        EFILE_DIR_HANDLE* p_dir_handle,   /* Pointer to directory
+                                             handle of
+                                             open directory.*/
+        char* buffer,             /* Pointer to buffer for
+                                     one filename. */
+        size_t *size)             /* in-out Size of buffer, length
+                                     of name. */
+{
+    DIR *dp;                    /* Pointer to directory structure. */
+    struct dirent* dirp;        /* Pointer to directory entry. */
+
+    /*
+     * If this is the first call, we must open the directory.
+     */
+
+    if (*p_dir_handle == NULL) {
+        dp = opendir(name);
+        if (dp == NULL)
+            return check_error(-1, errInfo);
+        *p_dir_handle = (EFILE_DIR_HANDLE) dp;
+    }
+
+    /*
+     * Retrieve the name of the next file using the directory handle.
+     */
+
+    dp = *((DIR **)((void *)p_dir_handle));
+    for (;;) {
+        dirp = readdir(dp);
+        if (dirp == NULL) {
+            closedir(dp);
+            return 0;
+        }
+        if (IS_DOT_OR_DOTDOT(dirp->d_name))
+            continue;
+        buffer[0] = '\0';
+        strncat(buffer, dirp->d_name, (*size)-1);
+        *size = strlen(dirp->d_name);
+        return 1;
+    }
+}
+
+/***************************************************************************/
+
+int
+efile_openfile(Efile_error* errInfo,    /* Where to return error codes. */
+        char* name,              /* Name of directory to open. */
+        int flags,               /* Flags to user for opening. */
+        int* pfd,                /* Where to store the file
+                                    descriptor. */
+        Sint64 *pSize)           /* Where to store the size of the
+                                    file. */
+{
+    struct stat statbuf;
+    int fd;
+    int mode;                   /* Open mode. */
+
+    if (stat(name, &statbuf) >= 0 && !ISREG(statbuf)) {
+        errno = EISDIR;
+        return check_error(-1, errInfo);
+    }
+
+    switch (flags & (EFILE_MODE_READ|EFILE_MODE_WRITE)) {
+        case EFILE_MODE_READ:
+            mode = O_RDONLY;
+            break;
+        case EFILE_MODE_WRITE:
+            if (flags & EFILE_NO_TRUNCATE)
+                mode = O_WRONLY | O_CREAT;
+            else
+                mode = O_WRONLY | O_CREAT | O_TRUNC;
+            break;
+        case EFILE_MODE_READ_WRITE:
+            mode = O_RDWR | O_CREAT;
+            break;
+        default:
+            errno = EINVAL;
+            return check_error(-1, errInfo);
+    }
+
+
+    if (flags & EFILE_MODE_APPEND) {
+        mode &= ~O_TRUNC;
+        mode |= O_APPEND;
+    }
+
+    if (flags & EFILE_MODE_EXCL) {
+        mode |= O_EXCL;
+    }
+
+    fd = open(name, mode, FILE_MODE);
+
+    if (!check_error(fd, errInfo))
+        return 0;
+
+    *pfd = fd;
+    if (pSize) {
+        *pSize = statbuf.st_size;
+    }
+    return 1;
+}
+
+/***************************************************************************/
+
+int
+efile_may_openfile(Efile_error* errInfo, char *name) {
+    struct stat statbuf;        /* Information about the file */
+    int result;
+
+    result = stat(name, &statbuf);
+    if (!check_error(result, errInfo))
+        return 0;
+    if (!ISREG(statbuf)) {
+        errno = EISDIR;
+        return check_error(-1, errInfo);
+    }
+    return 1;
+}
+
+/***************************************************************************/
+
+void
+efile_closefile(int fd)
+{
+    if (l_find_local_fd(fd) != NULL) {
+        l_remove_local_fd(fd);
+    }
+    close(fd);
+}
+
+/***************************************************************************/
+
+int
+efile_fdatasync(Efile_error *errInfo, /* Where to return error codes. */
+        int fd)               /* File descriptor for file to sync data. */
+{
+    return efile_fsync(errInfo, fd);
+}
+
+/***************************************************************************/
+
+int
+efile_fsync(Efile_error *errInfo, /* Where to return error codes. */
+        int fd)               /* File descriptor for file to sync. */
+{
+    return check_error(fsync(fd), errInfo);
+}
+
+/***************************************************************************/
+
+int
+efile_fileinfo(Efile_error* errInfo, Efile_info* pInfo,
+        char* name, int info_for_link)
+{
+    struct stat statbuf;        /* Information about the file */
+    int result;
+
+    result = stat(name, &statbuf);
+    if (!check_error(result, errInfo)) {
+        return 0;
+    }
+
+#if SIZEOF_OFF_T == 4
+    pInfo->size_high = 0;
+#else
+    pInfo->size_high = (Uint32)(statbuf.st_size >> 32);
+#endif
+    pInfo->size_low = (Uint32)statbuf.st_size;
+
+#ifdef NO_ACCESS
+    /* Just look at read/write access for owner. */
+
+    pInfo->access = ((statbuf.st_mode >> 6) & 07) >> 1;
+
+#else
+    pInfo->access = FA_NONE;
+    if (access(name, R_OK) == 0)
+        pInfo->access |= FA_READ;
+    if (access(name, W_OK) == 0)
+        pInfo->access |= FA_WRITE;
+
+#endif
+
+    if (ISDEV(statbuf))
+        pInfo->type = FT_DEVICE;
+    else if (ISDIR(statbuf))
+        pInfo->type = FT_DIRECTORY;
+    else if (ISREG(statbuf))
+        pInfo->type = FT_REGULAR;
+    else if (ISLNK(statbuf))
+        pInfo->type = FT_SYMLINK;
+    else
+        pInfo->type = FT_OTHER;
+
+    pInfo->accessTime   = statbuf.st_atime;
+    pInfo->modifyTime   = statbuf.st_mtime;
+    pInfo->cTime        = statbuf.st_ctime;
+
+    pInfo->mode         = statbuf.st_mode;
+    pInfo->links        = statbuf.st_nlink;
+    pInfo->major_device = statbuf.st_dev;
+    pInfo->inode        = statbuf.st_ino;
+    pInfo->uid          = statbuf.st_uid;
+    pInfo->gid          = statbuf.st_gid;
+
+    return 1;
+}
+
+/***************************************************************************/
+
+int
+efile_write_info(Efile_error *errInfo, Efile_info *pInfo, char *name)
+{
+    /*
+     * On some systems chown will always fail for a non-root user unless
+     * POSIX_CHOWN_RESTRICTED is not set.  Others will succeed as long as
+     * you don't try to chown a file to someone besides youself.
+     */
+    if (pInfo->mode != -1) {
+        mode_t newMode = pInfo->mode & (S_ISUID | S_ISGID |
+                S_IRWXU | S_IRWXG | S_IRWXO);
+        if (chmod(name, newMode)) {
+            newMode &= ~(S_ISUID | S_ISGID);
+            if (chmod(name, newMode)) {
+                return check_error(-1, errInfo);
+            }
+        }
+    }
+
+    return 1;
+}
+
+/***************************************************************************/
+
+int
+efile_write(Efile_error* errInfo,       /* Where to return error codes. */
+        int flags,                  /* Flags given when file was
+                                       opened. */
+        int fd,                     /* File descriptor to write to. */
+        char* buf,                  /* Buffer to write. */
+        size_t count)               /* Number of bytes to write. */
+{
+    ssize_t written;                    /* Bytes written in last operation. */
+    struct fd_data *fd_data;
+
+    if ((fd_data = l_find_local_fd(fd)) != NULL) {
+        if (L_FD_IS_VALID(fd_data)) {
+            /* we are beyond eof and need to pad*/
+            if (l_pad_file(fd_data, L_FD_CUR(fd_data)) < 0) {
+                return check_error(-1, errInfo);
+            }
+        }
+    }
+
+    while (count > 0)  {
+        if ((written = write(fd, buf, count)) < 0) {
+            if (errno != EINTR) {
+                return check_error(-1, errInfo);
+            }
+            else {
+                written = 0;
+            }
+        }
+        ASSERT(written <= count);
+        buf += written;
+        count -= written;
+    }
+    return 1;
+}
+
+/***************************************************************************/
+
+int
+efile_writev(Efile_error* errInfo,   /* Where to return error codes */
+        int flags,              /* Flags given when file was
+                                 * opened */
+        int fd,                 /* File descriptor to write to */
+        SysIOVec* iov,          /* Vector of buffer structs.
+                                 * The structs may be changed i.e.
+                                 * due to incomplete writes */
+        int iovcnt)             /* Number of structs in vector */
+{
+    struct fd_data *fd_data;
+    int cnt = 0;                     /* Buffers so far written */
+
+    ASSERT(iovcnt >= 0);
+    if ((fd_data = l_find_local_fd(fd)) != NULL) {
+        if (L_FD_IS_VALID(fd_data)) {
+            /* we are beyond eof and need to pad*/
+            if (l_pad_file(fd_data, L_FD_CUR(fd_data)) < 0) {
+                return check_error(-1, errInfo);
+            }
+        }
+    }
+    while (cnt < iovcnt) {
+        if ((! iov[cnt].iov_base) || (iov[cnt].iov_len <= 0)) {
+            /* Empty buffer - skip */
+            cnt++;
+        }
+        else { /* Non-empty buffer */
+            ssize_t w;                   /* Bytes written in this call */
+            do {
+                w = write(fd, iov[cnt].iov_base, iov[cnt].iov_len);
+            } while (w < 0 && errno == EINTR);
+
+            ASSERT(w <= iov[cnt].iov_len || w == -1);
+
+            if (w < 0) {
+                return check_error(-1, errInfo);
+            }
+            /* Move forward to next buffer to write */
+            for (; cnt < iovcnt && w > 0; cnt++) {
+                if (iov[cnt].iov_base && iov[cnt].iov_len > 0) {
+                    if (w < iov[cnt].iov_len) {
+                        /* Adjust the buffer for next write */
+                        iov[cnt].iov_len -= w;
+                        iov[cnt].iov_base += w;
+                        w = 0;
+                        break;
+                    }
+                    else {
+                        w -= iov[cnt].iov_len;
+                    }
+                }
+            }
+            ASSERT(w == 0);
+        } /* else Non-empty buffer */
+    } /* while (cnt< iovcnt) */
+    return 1;
+}
+
+/***************************************************************************/
+
+int
+efile_read(Efile_error* errInfo,     /* Where to return error codes. */
+        int flags,                  /* Flags given when file was opened. */
+        int fd,                     /* File descriptor to read from. */
+        char* buf,                  /* Buffer to read into. */
+        size_t count,       /* Number of bytes to read. */
+        size_t *pBytesRead)         /* Where to return number of
+                                       bytes read. */
+{
+    ssize_t n;
+    struct fd_data *fd_data;
+
+    if ((fd_data = l_find_local_fd(fd)) != NULL) {
+        if (L_FD_IS_VALID(fd_data)) {
+            *pBytesRead = 0;
+            return 1;
+        }
+    }
+    for (;;)  {
+        if ((n = read(fd, buf, count)) >= 0) {
+            break;
+        }
+        else if (errno != EINTR) {
+            return check_error(-1, errInfo);
+        }
+    }
+    if (fd_data != NULL && L_FD_IS_VALID(fd_data)) {
+        L_FD_INVALIDATE(fd_data);
+    }
+    *pBytesRead = (size_t) n;
+    return 1;
+}
+
+/* pread() and pwrite()                                                   */
+/* Some unix systems, notably Solaris has these syscalls                  */
+/* It is especially nice for i.e. the dets module to have support         */
+/* for this, even if the underlying OS dosn't support it, it is           */
+/* reasonably easy to work around by first calling seek, and then         */
+/* calling read().                                                        */
+/* This later strategy however changes the file pointer, which pread()    */
+/* does not do. We choose to ignore this and say that the location        */
+/* of the file pointer is undefined after a call to any of the p functions*/
+
+
+int
+efile_pread(Efile_error* errInfo,     /* Where to return error codes. */
+        int fd,                /* File descriptor to read from. */
+        Sint64 offset,            /* Offset in bytes from BOF. */
+        char* buf,                     /* Buffer to read into. */
+        size_t count,          /* Number of bytes to read. */
+        size_t *pBytesRead)            /* Where to return
+                                          number of bytes read. */
+{
+    int res = efile_seek(errInfo, fd, offset, EFILE_SEEK_SET, NULL);
+    if (res) {
+        return efile_read(errInfo, 0, fd, buf, count, pBytesRead);
+    } else {
+        return res;
+    }
+}
+
+
+/***************************************************************************/
+
+int
+efile_pwrite(Efile_error* errInfo,  /* Where to return error codes. */
+        int fd,                /* File descriptor to write to. */
+        char* buf,             /* Buffer to write. */
+        size_t count,          /* Number of bytes to write. */
+        Sint64 offset)         /* where to write it */
+{
+    int res = efile_seek(errInfo, fd, offset, EFILE_SEEK_SET, NULL);
+
+    if (res) {
+        return efile_write(errInfo, 0, fd, buf, count);
+    } else {
+        return res;
+    }
+}
+
+/***************************************************************************/
+
+int
+efile_seek(Efile_error* errInfo,      /* Where to return error codes. */
+        int fd,                    /* File descriptor to do the seek on. */
+        Sint64 offset,             /* Offset in bytes from the given
+                                      origin. */
+        int origin,                /* Origin of seek (SEEK_SET, SEEK_CUR,
+                                      SEEK_END). */
+        Sint64 *new_location)      /* Resulting new location in file. */
+{
+    off_t off, result;
+    off = (off_t) offset;
+
+    switch (origin) {
+        case EFILE_SEEK_SET:
+            origin = SEEK_SET;
+            break;
+        case EFILE_SEEK_CUR:
+            origin = SEEK_CUR;
+            break;
+        case EFILE_SEEK_END:
+            origin = SEEK_END;
+            break;
+        default:
+            errno = EINVAL;
+            return check_error(-1, errInfo);
+    }
+
+    if (off != offset) {
+        errno = EINVAL;
+        return check_error(-1, errInfo);
+    }
+
+    errno = 0;
+    result = lseek(fd, off, origin);
+
+    if (result >= 0) {
+        l_invalidate_local_fd(fd);
+    }
+
+    if (result < 0)
+    {
+        if (errno == ENOSYS) {
+            int size, cur_pos;
+
+            if (off < 0) {
+                errno = EINVAL;
+                return check_error(-1, errInfo);
+            }
+
+            cur_pos = lseek(fd, 0, SEEK_CUR);
+            size = lseek(fd, 0, SEEK_END);
+
+            if (origin == SEEK_SET) {
+                result = offset;
+            }
+            else if (origin == SEEK_CUR) {
+                result = offset + cur_pos;
+            }
+            else if (origin == SEEK_END) {
+                result = size + offset;
+            }
+
+            /* sanity check our result */
+            if (size > result) {
+                return check_error(-1, errInfo);
+            }
+
+            /* store the data localy */
+            l_update_local_fd(fd, result, size);
+
+            /* reset the original file position */
+            if (origin != SEEK_END) {
+                lseek(fd, cur_pos, SEEK_SET);
+            }
+        }
+        else if (errno == 0) {
+            errno = EINVAL;
+        }
+    }
+
+    if (new_location) {
+        *new_location = result;
+    }
+
+    return 1;
+}
+
+/***************************************************************************/
+
+int
+efile_truncate_file(Efile_error* errInfo, int *fd, int flags)
+{
+    off_t offset;
+    struct fd_data *fd_data;
+
+    if ((fd_data = l_find_local_fd(*fd)) != NULL && L_FD_IS_VALID(fd_data)) {
+        offset = L_FD_CUR(fd_data);
+    }
+    else {
+        offset = lseek(*fd, 0, SEEK_CUR);
+    }
+
+    return check_error(((offset >= 0) &&
+                (ftruncate(*fd, offset) == 0)) ? 1 : -1, errInfo);
+}
+
+/***************************************************************************/
+
+int
+efile_readlink(Efile_error* errInfo, char* name, char* buffer, size_t size)
+{
+    errno = ENOTSUP;
+    return check_error(-1, errInfo);
+}
+
+/***************************************************************************/
+
+int
+efile_altname(Efile_error* errInfo, char* name, char* buffer, size_t size)
+{
+    errno = ENOTSUP;
+    return check_error(-1, errInfo);
+}
+
+/***************************************************************************/
+
+int
+efile_link(Efile_error* errInfo, char* old, char* new)
+{
+    errno = ENOTSUP;
+    return check_error(-1, errInfo);
+}
+
+/***************************************************************************/
+
+int
+efile_symlink(Efile_error* errInfo, char* old, char* new)
+{
+    errno = ENOTSUP;
+    return check_error(-1, errInfo);
+}
+
+/***************************************************************************/
+
+int
+efile_fadvise(Efile_error* errInfo, int fd, Sint64 offset,
+        Sint64 length, int advise)
+{
+    return check_error(posix_fadvise(fd, offset, length, advise), errInfo);
+}
+
+/***************************************************************************/
+
+static int
+call_posix_fallocate(int fd, Sint64 offset, Sint64 length)
+{
+    int ret;
+
+    /*
+     * On Linux and Solaris for example, posix_fallocate() returns
+     * a positive error number on error and it does not set errno.
+     * On FreeBSD however (9.0 at least), it returns -1 on error
+     * and it sets errno.
+     */
+    do {
+        ret = posix_fallocate(fd, (off_t) offset, (off_t) length);
+        if (ret > 0) {
+            errno = ret;
+            ret = -1;
+        }
+    } while (ret != 0 && errno == EINTR);
+
+    return ret;
+}
+
+/***************************************************************************/
+
+int
+efile_fallocate(Efile_error* errInfo, int fd, Sint64 offset, Sint64 length)
+{
+    return check_error(call_posix_fallocate(fd, offset, length), errInfo);
+}
diff --git a/erts/emulator/drivers/ose/ose_signal_drv.c b/erts/emulator/drivers/ose/ose_signal_drv.c
new file mode 100644
index 0000000000..4929b53856
--- /dev/null
+++ b/erts/emulator/drivers/ose/ose_signal_drv.c
@@ -0,0 +1,896 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2013-2013. 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%
+ */
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "errno.h"
+#include "stdio.h"
+#include "string.h"
+#include "stddef.h"
+
+#include "sys.h"
+#include "erl_driver.h"
+#include "ose.h"
+
+
+#ifdef HAVE_OSE_SPI_H
+#include "ose_spi/ose_spi.h"
+#endif
+
+#define DEBUG_ATTACH   0
+#define DEBUG_HUNT     0
+#define DEBUG_SEND     0
+#define DEBUG_LISTEN   0
+
+#if 0
+#define DEBUGP(FMT,...) printf(FMT, __VA_ARGS__)
+#else
+#define DEBUGP(FMT,...)
+#endif
+
+#if DEBUG_ATTACH
+#define DEBUGP_ATTACH(...) DEBUGP( __VA_ARGS__)
+#else
+#define DEBUGP_ATTACH(...)
+#endif
+
+#if DEBUG_HUNT
+#define DEBUGP_HUNT(...) DEBUGP( __VA_ARGS__)
+#else
+#define DEBUGP_HUNT(...)
+#endif
+
+#if DEBUG_LISTEN
+#define DEBUGP_LISTEN(...) DEBUGP( __VA_ARGS__)
+#else
+#define DEBUGP_LISTEN(...)
+#endif
+
+#if DEBUG_SEND
+#define DEBUGP_SEND(...) DEBUGP( __VA_ARGS__)
+#else
+#define DEBUGP_SEND(...)
+#endif
+
+
+#define DRIVER_NAME "ose_signal_drv"
+#define GET_SPID        1
+#define GET_NAME        2
+#define HUNT          100
+#define DEHUNT        101
+#define ATTACH        102
+#define DETACH        103
+#define SEND          104
+#define SEND_W_S      105
+#define LISTEN        106
+#define OPEN          200
+
+#define REF_SEGMENT_SIZE 8
+
+struct async {
+  SIGSELECT signo;
+  ErlDrvTermData port;
+  ErlDrvTermData proc;
+  PROCESS spid;
+  PROCESS target;
+  Uint32 ref;
+};
+
+/**
+ * OSE signals
+ **/
+union SIGNAL {
+  SIGSELECT signo;
+  struct async async;
+};
+
+/**
+ * The driver's context
+ **/
+typedef struct _driver_context {
+  ErlDrvPort port;
+  PROCESS spid;
+  ErlDrvEvent perm_events[2];
+  ErlDrvEvent *events;
+  Uint32 event_cnt;
+  Uint32 ref;
+  Uint32 *outstanding_refs;
+  Uint32 outstanding_refs_max;
+  Uint32 outstanding_refs_cnt;
+} driver_context_t;
+
+/**
+ * Global variables
+ **/
+static ErlDrvTermData a_ok;
+static ErlDrvTermData a_error;
+static ErlDrvTermData a_enomem;
+static ErlDrvTermData a_enoent;
+static ErlDrvTermData a_badarg;
+static ErlDrvTermData a_mailbox_up;
+static ErlDrvTermData a_mailbox_down;
+static ErlDrvTermData a_ose_drv_reply;
+static ErlDrvTermData a_message;
+static PROCESS proxy_proc;
+
+
+/**
+ * Serialize/unserialize unsigned 32-bit values
+ **/
+static char *put_u32(unsigned int value, char *ptr) {
+  *ptr++ = (value & 0xff000000) >> 24;
+  *ptr++ = (value & 0x00ff0000) >> 16;
+  *ptr++ = (value & 0x0000ff00) >> 8;
+  *ptr++ = (value & 0xff);
+
+  return ptr;
+}
+
+static unsigned int get_u32(char *ptr) {
+  unsigned int result = 0;
+  result += (ptr[0] & 0xff) << 24;
+  result += (ptr[1] & 0xff) << 16;
+  result += (ptr[2] & 0xff) << 8;
+  result += (ptr[3] & 0xff);
+
+  return result;
+}
+
+
+/* Stolen from efile_drv.c */
+
+/* char EV_CHAR_P(ErlIOVec *ev, int p, int q) */
+#define EV_CHAR_P(ev, p, q)                   \
+    (((char *)(ev)->iov[(q)].iov_base) + (p))
+
+/* int EV_GET_CHAR(ErlIOVec *ev, char *p, int *pp, int *qp) */
+#define EV_GET_CHAR(ev, p, pp, qp) ev_get_char(ev, p ,pp, qp)
+static int
+ev_get_char(ErlIOVec *ev, char *p, int *pp, int *qp) {
+  if (*(pp)+1 <= (ev)->iov[*(qp)].iov_len) {
+    *(p) = *EV_CHAR_P(ev, *(pp), *(qp));
+    if (*(pp)+1 < (ev)->iov[*(qp)].iov_len)
+      *(pp) = *(pp)+1;
+    else {
+      (*(qp))++;
+      *pp = 0;
+    }
+    return !0;
+  }
+  return 0;
+}
+
+/* Uint32 EV_UINT32(ErlIOVec *ev, int p, int q)*/
+#define EV_UINT32(ev, p, q) \
+    ((Uint32) *(((unsigned char *)(ev)->iov[(q)].iov_base) + (p)))
+
+/* int EV_GET_UINT32(ErlIOVec *ev, Uint32 *p, int *pp, int *qp) */
+#define EV_GET_UINT32(ev, p, pp, qp) ev_get_uint32(ev,(Uint32*)(p),pp,qp)
+static int
+ev_get_uint32(ErlIOVec *ev, Uint32 *p, int *pp, int *qp) {
+  if (*(pp)+4 <= (ev)->iov[*(qp)].iov_len) {
+    *(p) = (EV_UINT32(ev, *(pp),   *(qp)) << 24)
+      | (EV_UINT32(ev, *(pp)+1, *(qp)) << 16)
+      | (EV_UINT32(ev, *(pp)+2, *(qp)) << 8)
+      | (EV_UINT32(ev, *(pp)+3, *(qp)));
+    if (*(pp)+4 < (ev)->iov[*(qp)].iov_len)
+      *(pp) = *(pp)+4;
+    else {
+      (*(qp))++;
+      *pp = 0;
+    }
+    return !0;
+  }
+  return 0;
+}
+
+/**
+ * Convinience macros
+ **/
+#define send_response(port,output) erl_drv_send_term(driver_mk_port(port),\
+    driver_caller(port), output, sizeof(output) / sizeof(output[0]));
+
+void iov_memcpy(void *dest,ErlIOVec *ev,int ind,int off);
+void iov_memcpy(void *dest,ErlIOVec *ev,int ind,int off) {
+  int i;
+  memcpy(dest,ev->iov[ind].iov_base+off,ev->iov[ind].iov_len-off);
+  for (i = ind+1; i < ev->vsize; i++)
+    memcpy(dest,ev->iov[i].iov_base,ev->iov[i].iov_len);
+}
+
+/**
+ * Reference handling
+ **/
+
+static int add_reference(driver_context_t *ctxt, Uint32 ref) {
+
+  /*
+   * Premature optimizations may be evil, but they sure are fun.
+   */
+
+  if (ctxt->outstanding_refs == NULL) {
+    /* First ref to be ignored */
+    ctxt->outstanding_refs = driver_alloc(REF_SEGMENT_SIZE*sizeof(Uint32));
+    if (!ctxt->outstanding_refs)
+      return 1;
+
+    memset(ctxt->outstanding_refs,0,REF_SEGMENT_SIZE*sizeof(Uint32));
+    ctxt->outstanding_refs_max += REF_SEGMENT_SIZE;
+    ctxt->outstanding_refs[ctxt->outstanding_refs_cnt++] = ref;
+  } else if (ctxt->outstanding_refs_cnt == ctxt->outstanding_refs_max) {
+    /* Expand ref array */
+    Uint32 *new_array;
+    ctxt->outstanding_refs_max += REF_SEGMENT_SIZE;
+    new_array = driver_realloc(ctxt->outstanding_refs,
+			       ctxt->outstanding_refs_max*sizeof(Uint32));
+
+    if (!new_array) {
+      ctxt->outstanding_refs_max -= REF_SEGMENT_SIZE;
+      return 1;
+    }
+
+    ctxt->outstanding_refs = new_array;
+
+    memset(ctxt->outstanding_refs+ctxt->outstanding_refs_cnt,0,
+	   REF_SEGMENT_SIZE*sizeof(Uint32));
+    ctxt->outstanding_refs[ctxt->outstanding_refs_cnt++] = ref;
+
+  } else {
+    /* Find an empty slot:
+     *   First we try current index,
+     *   then we scan for a slot.
+     */
+    if (!ctxt->outstanding_refs[ctxt->outstanding_refs_cnt]) {
+      ctxt->outstanding_refs[ctxt->outstanding_refs_cnt++] = ref;
+    } else {
+      int i;
+      ASSERT(ctxt->outstanding_refs_cnt < ctxt->outstanding_refs_max);
+      for (i = 0; i < ctxt->outstanding_refs_max; i++)
+	if (!ctxt->outstanding_refs[i])
+	  break;
+      ASSERT(ctxt->outstanding_refs[i] == 0);
+      ctxt->outstanding_refs[i] = ref;
+      ctxt->outstanding_refs_cnt++;
+    }
+  }
+  return 0;
+}
+
+/* Return 0 if removed, 1 if does not exist, */
+static int remove_reference(driver_context_t *ctxt, Uint32 ref) {
+  int i,j;
+
+  if (ctxt->outstanding_refs_max == 0 && ctxt->outstanding_refs_cnt == 0) {
+    ASSERT(ctxt->outstanding_refs == NULL);
+    return 1;
+  }
+
+  for (i = 0; i < ctxt->outstanding_refs_max; i++) {
+    if (ctxt->outstanding_refs[i] == ref) {
+      ctxt->outstanding_refs[i] = 0;
+      ctxt->outstanding_refs_cnt--;
+      i = -1;
+      break;
+    }
+  }
+
+  if (i != -1)
+    return 1;
+
+  if (ctxt->outstanding_refs_cnt == 0) {
+    driver_free(ctxt->outstanding_refs);
+    ctxt->outstanding_refs = NULL;
+    ctxt->outstanding_refs_max = 0;
+  } else if (ctxt->outstanding_refs_cnt == (ctxt->outstanding_refs_max - REF_SEGMENT_SIZE)) {
+    Uint32 *new_array;
+    for (i = 0, j = 0; i < ctxt->outstanding_refs_cnt; i++) {
+      if (ctxt->outstanding_refs[i] == 0) {
+	for (j = i+1; j < ctxt->outstanding_refs_max; j++)
+	  if (ctxt->outstanding_refs[j]) {
+	    ctxt->outstanding_refs[i] = ctxt->outstanding_refs[j];
+	    ctxt->outstanding_refs[j] = 0;
+	    break;
+	  }
+      }
+    }
+    ctxt->outstanding_refs_max -= REF_SEGMENT_SIZE;
+    new_array = driver_realloc(ctxt->outstanding_refs,
+			       ctxt->outstanding_refs_max*sizeof(Uint32));
+    if (!new_array) {
+      ctxt->outstanding_refs_max += REF_SEGMENT_SIZE;
+      return 2;
+    }
+
+    ctxt->outstanding_refs = new_array;
+
+  }
+
+  return 0;
+}
+
+/**
+ * The OSE proxy process. This only handles ERTS_SIGNAL_OSE_DRV_ATTACH.
+ * The process is needed because signals triggered by attach ignore
+ * redir tables.
+ *
+ * We have one global proxy process to save memory. An attempt to make each
+ * port phantom into a proxy was made, but that used way to much memory.
+ */
+static OS_PROCESS(driver_proxy_process) {
+  SIGSELECT sigs[] = {1,ERTS_SIGNAL_OSE_DRV_ATTACH};
+  PROCESS master = 0;
+
+  while (1) {
+    union SIGNAL *sig = receive(sigs);
+
+    if (sig->signo == ERTS_SIGNAL_OSE_DRV_ATTACH) {
+
+      /* The first message is used to determine who to send messages to. */
+      if (master == 0)
+	master = sender(&sig);
+
+      if (sig->async.target == 0) {
+	PROCESS from = sender(&sig);
+	restore(sig);
+	DEBUGP_ATTACH("0x%x: got attach 0x%x, sending to 0x%x\n",
+		      current_process(),from,master);
+	sig->async.target = from;
+	send(&sig,master);
+      } else {
+	PROCESS target = sig->async.target;
+	restore(sig);
+	sig->async.target = 0;
+	DEBUGP_ATTACH("0x%x: doing attach on 0x%x\n",current_process(),target);
+	attach(&sig,target);
+      }
+    }
+  }
+}
+
+
+/**
+ * Init routine for the driver
+ **/
+static int drv_init(void) {
+
+  a_ok = driver_mk_atom("ok");
+  a_error = driver_mk_atom("error");
+  a_enomem = driver_mk_atom("enomem");
+  a_enoent = driver_mk_atom("enoent");
+  a_badarg = driver_mk_atom("badarg");
+  a_mailbox_up = driver_mk_atom("mailbox_up");
+  a_mailbox_down = driver_mk_atom("mailbox_down");
+  a_ose_drv_reply = driver_mk_atom("ose_drv_reply");
+  a_message = driver_mk_atom("message");
+
+  proxy_proc = create_process(get_ptype(current_process()),
+			      "ose_signal_driver_proxy",
+			      driver_proxy_process, 10000,
+			      get_pri(current_process()),
+			      0, 0, NULL, 0, 0);
+
+#ifdef DEBUG
+  efs_clone(proxy_proc);
+#endif
+  start(proxy_proc);
+
+  return 0;
+}
+
+/* Signal resolution callback */
+static ErlDrvOseEventId resolve_signal(union SIGNAL* osig) {
+  union SIGNAL *sig = osig;
+  if (sig->signo == ERTS_SIGNAL_OSE_DRV_HUNT ||
+      sig->signo == ERTS_SIGNAL_OSE_DRV_ATTACH) {
+    return sig->async.spid;
+  }
+  DEBUGP("%p: Got signal %d sent to %p from 0x%p\n",
+	 current_process(),sig->signo,addressee(&sig),sender(&sig));
+  return addressee(&sig);
+}
+
+
+/**
+ * Start routine for the driver
+ **/
+static ErlDrvData drv_start(ErlDrvPort port, char *command)
+{
+  driver_context_t *ctxt = driver_alloc(sizeof(driver_context_t));
+
+  ctxt->perm_events[0] = NULL;
+  ctxt->perm_events[1] = NULL;
+
+  ctxt->spid = 0;
+  ctxt->port = port;
+  ctxt->event_cnt = 0;
+  ctxt->events = NULL;
+  ctxt->ref = 0;
+  ctxt->outstanding_refs = NULL;
+  ctxt->outstanding_refs_max = 0;
+  ctxt->outstanding_refs_cnt = 0;
+
+
+  /* Set the communication protocol to Erlang to be binary */
+  set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
+
+  /* Everything ok */
+  return (ErlDrvData)ctxt;
+}
+
+/**
+ * Stop routine for the driver
+ **/
+static void drv_stop(ErlDrvData driver_data)
+{
+  driver_context_t *ctxt = (driver_context_t *)driver_data;
+  int i;
+
+  /* HUNT + ATTACH */
+  if (ctxt->perm_events[0])
+    driver_select(ctxt->port, ctxt->perm_events[0],
+		  ERL_DRV_USE|ERL_DRV_READ, 0);
+  if (ctxt->perm_events[1])
+    driver_select(ctxt->port, ctxt->perm_events[1],
+		  ERL_DRV_USE|ERL_DRV_READ, 0);
+
+  for (i = 0; i < ctxt->event_cnt; i++) {
+    driver_select(ctxt->port, ctxt->events[i], ERL_DRV_USE|ERL_DRV_READ, 0);
+  }
+
+  if (ctxt->spid != 0)
+    kill_proc(ctxt->spid);
+  DEBUGP("0x%x: stopped\n",ctxt->spid);
+  if (ctxt->events)
+    driver_free(ctxt->events);
+  if (ctxt->outstanding_refs)
+    driver_free(ctxt->outstanding_refs);
+
+  driver_free(ctxt);
+}
+
+/**
+ * Output from Erlang
+ **/
+static void outputv(ErlDrvData driver_data, ErlIOVec *ev)
+{
+  driver_context_t *ctxt = (driver_context_t *)driver_data;
+  int p = 0, q = 1;
+  char cmd;
+
+  if (! EV_GET_CHAR(ev,&cmd,&p,&q)) {
+    ErlDrvTermData output[] = {
+      ERL_DRV_ATOM, a_ose_drv_reply,
+      ERL_DRV_PORT, driver_mk_port(ctxt->port),
+      ERL_DRV_ATOM, a_badarg,
+      ERL_DRV_TUPLE, 3};
+    send_response(ctxt->port, output);
+    return;
+  }
+
+  /* Command is in the buffer's first byte */
+  switch(cmd) {
+
+  case OPEN: {
+    char *name = driver_alloc(ev->size - 1+1);
+    struct OS_redir_entry redir[2];
+
+    redir[0].sig = 1;
+    redir[0].pid = current_process();
+
+    iov_memcpy(name,ev,q,p);
+    name[ev->size-1] = '\0';
+
+    ctxt->spid = create_process(OS_PHANTOM, name, NULL, 0,
+				0, 0, 0, redir, 0, 0);
+
+    DEBUGP("0x%x: open\n",ctxt->spid);
+
+    ctxt->perm_events[1] =
+      erl_drv_ose_event_alloc(ERTS_SIGNAL_OSE_DRV_ATTACH,(int)ctxt->spid,
+			      resolve_signal, NULL);
+    driver_select(ctxt->port,ctxt->perm_events[1],ERL_DRV_READ|ERL_DRV_USE,1);
+
+    ctxt->perm_events[0] =
+      erl_drv_ose_event_alloc(ERTS_SIGNAL_OSE_DRV_HUNT,(int)ctxt->spid,
+			      resolve_signal, NULL);
+    driver_select(ctxt->port,ctxt->perm_events[0],ERL_DRV_READ|ERL_DRV_USE,1);
+
+    start(ctxt->spid);
+
+    {
+      ErlDrvTermData output[] = {
+	ERL_DRV_ATOM, a_ose_drv_reply,
+	ERL_DRV_PORT, driver_mk_port(ctxt->port),
+	ERL_DRV_ATOM, a_ok,
+	ERL_DRV_TUPLE, 3};
+
+      send_response(ctxt->port, output);
+    }
+
+    break;
+
+  }
+
+  case ATTACH:
+  case HUNT:
+    {
+      union SIGNAL *sig = alloc(sizeof(union SIGNAL),
+				cmd == HUNT ? ERTS_SIGNAL_OSE_DRV_HUNT:ERTS_SIGNAL_OSE_DRV_ATTACH);
+
+      sig->async.port = driver_mk_port(ctxt->port);
+      sig->async.proc = driver_caller(ctxt->port);
+      sig->async.spid = ctxt->spid;
+      sig->async.ref = ++ctxt->ref;
+
+      if (add_reference(ctxt,ctxt->ref)) {
+	ErlDrvTermData output[] = {
+	  ERL_DRV_ATOM, a_ose_drv_reply,
+	  ERL_DRV_PORT, driver_mk_port(ctxt->port),
+	  ERL_DRV_ATOM, a_enomem,
+	  ERL_DRV_TUPLE, 3};
+	send_response(ctxt->port, output);
+	free_buf(&sig);
+      } else {
+	ErlDrvTermData output[] = {
+	  ERL_DRV_ATOM, a_ose_drv_reply,
+	  ERL_DRV_PORT, driver_mk_port(ctxt->port),
+	  ERL_DRV_PORT, driver_mk_port(ctxt->port),
+	  ERL_DRV_INT, (ErlDrvUInt)ctxt->ref,
+	  ERL_DRV_TUPLE, 2,
+	  ERL_DRV_TUPLE, 3};
+	send_response(ctxt->port, output);
+
+	if (cmd == HUNT) {
+	  char *huntname = driver_alloc(sizeof(char)*((ev->size-1)+1));
+
+	  iov_memcpy(huntname,ev,q,p);
+	  huntname[ev->size-1] = '\0';
+
+	  DEBUGP_HUNT("0x%x: hunt %s -> %u (%u,%u)\n",
+		      ctxt->spid,huntname,ctxt->ref,
+		      ctxt->outstanding_refs_cnt,
+		      ctxt->outstanding_refs_max);
+
+	  hunt(huntname, 0, NULL, &sig);
+
+	  driver_free(huntname);
+	} else {
+	  EV_GET_UINT32(ev,&sig->async.target,&p,&q);
+	  DEBUGP_ATTACH("0x%x: attach %u -> %u (%u,%u)\n",
+			ctxt->spid,sig->async.target,
+			ctxt->ref,
+			ctxt->outstanding_refs_cnt,
+			ctxt->outstanding_refs_max);
+
+	  send(&sig,proxy_proc);
+	}
+
+      }
+
+      break;
+    }
+
+  case DETACH:
+  case DEHUNT:
+    {
+
+        Uint32 ref;
+
+	EV_GET_UINT32(ev,&ref,&p,&q);
+	if (cmd == DETACH) {
+	  DEBUGP_ATTACH("0x%x: detach %u (%u,%u)\n",ctxt->spid,ref,
+			ctxt->outstanding_refs_cnt,
+			ctxt->outstanding_refs_max);
+	} else {
+	  DEBUGP_HUNT("0x%x: dehunt %u (%u,%u)\n",ctxt->spid,ref,
+		      ctxt->outstanding_refs_cnt,
+		      ctxt->outstanding_refs_max);
+	}
+
+	if (remove_reference(ctxt,ref)) {
+	  ErlDrvTermData output[] = {
+	    ERL_DRV_ATOM, a_ose_drv_reply,
+	    ERL_DRV_PORT, driver_mk_port(ctxt->port),
+	    ERL_DRV_ATOM, a_error,
+	    ERL_DRV_ATOM, a_enoent,
+	    ERL_DRV_TUPLE, 2,
+	    ERL_DRV_TUPLE, 3};
+
+	  send_response(ctxt->port, output);
+	} else {
+	  ErlDrvTermData output[] = {
+	    ERL_DRV_ATOM, a_ose_drv_reply,
+	    ERL_DRV_PORT, driver_mk_port(ctxt->port),
+	    ERL_DRV_ATOM, a_ok,
+	    ERL_DRV_TUPLE, 3};
+
+	  send_response(ctxt->port, output);
+	}
+
+      break;
+    }
+
+  case SEND:
+  case SEND_W_S:
+    {
+      PROCESS spid;
+      PROCESS sender;
+      SIGSELECT signo;
+      OSBUFSIZE size = ev->size-9;
+      union SIGNAL *sig;
+
+      EV_GET_UINT32(ev,&spid,&p,&q);
+
+      if (cmd == SEND_W_S) {
+	EV_GET_UINT32(ev,&sender,&p,&q);
+	size -= 4;
+      } else {
+	sender = ctxt->spid;
+      }
+
+      EV_GET_UINT32(ev,&signo,&p,&q);
+
+      sig = alloc(size + sizeof(SIGSELECT),signo);
+
+      if (cmd == SEND_W_S) {
+	DEBUGP_SEND("0x%x: send_w_s(%u,%u,%u)\n",ctxt->spid,spid,signo,sender);
+      } else {
+	DEBUGP_SEND("0x%x: send(%u,%u)\n",ctxt->spid,spid,signo);
+      }
+
+      iov_memcpy(((char *)&sig->signo) + sizeof(SIGSELECT),ev,q,p);
+
+      send_w_s(&sig, sender, spid);
+
+      break;
+    }
+
+    case LISTEN:
+    {
+      int i,j,event_cnt = (ev->size - 1)/4;
+      ErlDrvEvent *events = NULL;
+      SIGSELECT signo,tmp_signo;
+
+      if (event_cnt == 0) {
+	for (i = 0; i < ctxt->event_cnt; i++)
+	  driver_select(ctxt->port,ctxt->events[i],ERL_DRV_READ|ERL_DRV_USE,0);
+	if (ctxt->events)
+	  driver_free(ctxt->events);
+      } else {
+	events = driver_alloc(sizeof(ErlDrvEvent)*event_cnt);
+	EV_GET_UINT32(ev,&signo,&p,&q);
+	for (i = 0, j = 0; i < event_cnt || j < ctxt->event_cnt; ) {
+
+	  if (ctxt->events)
+	    erl_drv_ose_event_fetch(ctxt->events[j],&tmp_signo,NULL,NULL);
+
+	  if (signo == tmp_signo) {
+	    events[i++] = ctxt->events[j++];
+	    EV_GET_UINT32(ev,&signo,&p,&q);
+	  } else if (signo < tmp_signo || !ctxt->events) {
+	    /* New signal to select on */
+	    events[i] = erl_drv_ose_event_alloc(signo,(int)ctxt->spid,
+						resolve_signal, NULL);
+	    driver_select(ctxt->port,events[i++],ERL_DRV_READ|ERL_DRV_USE,1);
+	    EV_GET_UINT32(ev,&signo,&p,&q);
+	  } else {
+	    /* Remove old signal to select on */
+	    driver_select(ctxt->port,ctxt->events[j++],ERL_DRV_READ|ERL_DRV_USE,0);
+	  }
+	}
+	if (ctxt->events)
+	  driver_free(ctxt->events);
+      }
+      ctxt->events = events;
+      ctxt->event_cnt = event_cnt;
+
+      {
+	ErlDrvTermData output[] = {
+	  ERL_DRV_ATOM, a_ose_drv_reply,
+	  ERL_DRV_PORT, driver_mk_port(ctxt->port),
+	  ERL_DRV_ATOM, a_ok,
+	  ERL_DRV_TUPLE, 3};
+	send_response(ctxt->port, output);
+      }
+      break;
+    }
+
+    default:
+    {
+      DEBUGP("Warning: 'ose_signal_drv' unknown command '%d'\n", cmd);
+      break;
+    }
+  }
+}
+
+/**
+ * Handler for when OSE signal arrives
+ **/
+static void ready_input(ErlDrvData driver_data, ErlDrvEvent event)
+{
+  driver_context_t *ctxt = (driver_context_t *)driver_data;
+  union SIGNAL *sig = erl_drv_ose_get_signal(event);
+
+  while (sig != NULL) {
+
+    switch(sig->signo)
+      {
+	/* Remote process is available */
+      case ERTS_SIGNAL_OSE_DRV_HUNT:
+	{
+	  const PROCESS spid = sender(&sig);
+
+	  if (remove_reference(ctxt,sig->async.ref)) {
+	    DEBUGP_HUNT("0x%x: Got hunt from 0x%x -> %u (CANCELLED) (%u,%u)\n",
+			ctxt->spid,spid,sig->async.ref,
+			ctxt->outstanding_refs_cnt,
+			ctxt->outstanding_refs_max);
+	    /* Already removed by dehunt */
+	  } else {
+	    ErlDrvTermData reply[] = {
+	      ERL_DRV_ATOM, a_mailbox_up,
+	      ERL_DRV_PORT, sig->async.port,
+	      ERL_DRV_PORT, sig->async.port,
+	      ERL_DRV_UINT, (ErlDrvUInt)sig->async.ref,
+	      ERL_DRV_TUPLE, 2,
+	      ERL_DRV_UINT, (ErlDrvUInt)spid,
+	      ERL_DRV_TUPLE, 4};
+	    DEBUGP_HUNT("0x%x: Got hunt from 0x%x -> %u (%u,%u)\n",
+			ctxt->spid,spid,sig->async.ref,
+			ctxt->outstanding_refs_cnt,
+			ctxt->outstanding_refs_max);
+	    erl_drv_send_term(sig->async.port, sig->async.proc, reply,
+			      sizeof(reply) / sizeof(reply[0]));
+	  }
+	  break;
+	}
+
+	/* Remote process is down */
+      case ERTS_SIGNAL_OSE_DRV_ATTACH:
+	{
+	  PROCESS spid = sig->async.target;
+
+	  if (remove_reference(ctxt,sig->async.ref)) {
+	    DEBUGP_ATTACH("0x%x: Got attach from 0x%x -> %u (CANCELLED) (%u,%u)\n",
+			  ctxt->spid,spid,sig->async.ref,
+			  ctxt->outstanding_refs_cnt,
+			  ctxt->outstanding_refs_max);
+	    /* Already removed by detach */
+	  } else {
+	    ErlDrvTermData reply[] = {
+	      ERL_DRV_ATOM, a_mailbox_down,
+	      ERL_DRV_PORT, sig->async.port,
+	      ERL_DRV_PORT, sig->async.port,
+	      ERL_DRV_UINT, sig->async.ref,
+	      ERL_DRV_TUPLE, 2,
+	      ERL_DRV_UINT, (ErlDrvUInt)spid,
+	      ERL_DRV_TUPLE, 4};
+	     DEBUGP_ATTACH("0x%x: Got attach from 0x%x -> %u (%u,%u)\n",
+			   ctxt->spid,spid,sig->async.ref,
+			   ctxt->outstanding_refs_cnt,
+			   ctxt->outstanding_refs_max);
+	    erl_drv_send_term(sig->async.port, sig->async.proc, reply,
+			      sizeof(reply) / sizeof(reply[0]));
+	  }
+	  break;
+	}
+
+	/* Received user defined signal */
+      default:
+	{
+	  const PROCESS spid = sender(&sig);
+	  const OSBUFSIZE size = sigsize(&sig) - sizeof(SIGSELECT);
+	  const char *sig_data = ((char *)&sig->signo) + sizeof(SIGSELECT);
+
+	  ErlDrvTermData reply[] = {
+	    ERL_DRV_ATOM, a_message,
+	    ERL_DRV_PORT, driver_mk_port(ctxt->port),
+	    ERL_DRV_UINT, (ErlDrvUInt)spid,
+	    ERL_DRV_UINT, (ErlDrvUInt)ctxt->spid,
+	    ERL_DRV_UINT, (ErlDrvUInt)sig->signo,
+	    ERL_DRV_BUF2BINARY, (ErlDrvTermData)sig_data, (ErlDrvUInt)size,
+	    ERL_DRV_TUPLE, 4,
+	    ERL_DRV_TUPLE, 3};
+
+	  DEBUGP_SEND("0x%x: Got 0x%u\r\n", spid, sig->signo);
+
+	  erl_drv_output_term(driver_mk_port(ctxt->port), reply,
+			      sizeof(reply) / sizeof(reply[0]));
+	  break;
+	}
+      }
+
+    free_buf(&sig);
+    sig = erl_drv_ose_get_signal(event);
+  }
+}
+
+/**
+ * Handler for 'port_control'
+ **/
+static ErlDrvSSizeT control(ErlDrvData driver_data, unsigned int cmd,
+                            char *buf, ErlDrvSizeT len,
+                            char **rbuf, ErlDrvSizeT rlen)
+{
+  driver_context_t *ctxt = (driver_context_t *)driver_data;
+
+  switch(cmd)
+  {
+    case GET_SPID:
+    {
+      const PROCESS spid = ctxt->spid;
+      put_u32(spid, *rbuf);
+      return sizeof(PROCESS);
+    }
+
+#ifdef HAVE_OSE_SPI_H
+    case GET_NAME:
+    {
+      const PROCESS spid = get_u32(buf);
+      char *name = (char*)get_pid_info(spid,OSE_PI_NAME);
+      int n;
+      if (!name) {
+	*rbuf = NULL;
+	return 0;
+      }
+
+      if (rlen < (n = strlen(name))) {
+	ErlDrvBinary *bin = driver_alloc_binary(n);
+	strncpy(bin->orig_bytes,name,n);
+	*rbuf = (char*)bin;
+      } else
+	strncpy(*rbuf,name,n);
+      free_buf((union SIGNAL**)&name);
+
+      return n;
+    }
+#endif
+    default:
+    {
+      /* Unknown command */
+      return (ErlDrvSSizeT)ERL_DRV_ERROR_GENERAL;
+      break;
+    }
+  }
+}
+
+static void stop_select(ErlDrvEvent event, void *reserved)
+{
+  erl_drv_ose_event_free(event);
+}
+
+/**
+ * Setup the driver entry for the Erlang runtime
+ **/
+ErlDrvEntry ose_signal_driver_entry = {
+  .init                         = drv_init,
+  .start                        = drv_start,
+  .stop                         = drv_stop,
+  .outputv                      = outputv,
+  .ready_input                  = ready_input,
+  .driver_name                  = DRIVER_NAME,
+  .control                      = control,
+  .extended_marker              = ERL_DRV_EXTENDED_MARKER,
+  .major_version                = ERL_DRV_EXTENDED_MAJOR_VERSION,
+  .minor_version                = ERL_DRV_EXTENDED_MINOR_VERSION,
+  .driver_flags                 = ERL_DRV_FLAG_USE_PORT_LOCKING,
+  .stop_select                  = stop_select
+};
+
diff --git a/erts/emulator/drivers/ose/ttsl_drv.c b/erts/emulator/drivers/ose/ttsl_drv.c
new file mode 100644
index 0000000000..8af2ce6af3
--- /dev/null
+++ b/erts/emulator/drivers/ose/ttsl_drv.c
@@ -0,0 +1,68 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 1996-2013. 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%
+ */
+/*
+ * Stub tty driver because group/user depend on this.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "erl_driver.h"
+
+static int ttysl_init(void);
+static ErlDrvData ttysl_start(ErlDrvPort, char*);
+
+/* Define the driver table entry. */
+struct erl_drv_entry ttsl_driver_entry = {
+    ttysl_init,
+    ttysl_start,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    "tty_sl",
+    NULL,
+    NULL,
+    NULL,
+    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,
+    NULL, /* process_exit */
+    NULL
+};
+
+
+static int ttysl_init(void)
+{
+    return 0;
+}
+
+static ErlDrvData ttysl_start(ErlDrvPort port, char* buf)
+{
+    return ERL_DRV_ERROR_GENERAL;
+}
diff --git a/erts/emulator/drivers/unix/unix_efile.c b/erts/emulator/drivers/unix/unix_efile.c
index 8ffc05da99..42f41c5f3d 100644
--- a/erts/emulator/drivers/unix/unix_efile.c
+++ b/erts/emulator/drivers/unix/unix_efile.c
@@ -102,6 +102,11 @@ check_error(int result, Efile_error *errInfo)
 }
 
 int
+efile_init() {
+   return 1;
+}
+
+int
 efile_mkdir(Efile_error* errInfo,	/* Where to return error codes. */
 	    char* name)			/* Name of directory to create. */
 {
@@ -629,7 +634,8 @@ efile_writev(Efile_error* errInfo,   /* Where to return error codes */
 		    do {
 			w = write(fd, iov[cnt].iov_base, iov[cnt].iov_len);
 		    } while (w < 0 && errno == EINTR);
-		    ASSERT(w <= iov[cnt].iov_len);
+		    ASSERT(w <= iov[cnt].iov_len ||
+			   (w == -1 && errno != EINTR));
 		}
 	    if (w < 0) return check_error(-1, errInfo);
 	    /* Move forward to next buffer to write */
diff --git a/erts/emulator/drivers/win32/win_efile.c b/erts/emulator/drivers/win32/win_efile.c
index d693d7d593..480ba23239 100644
--- a/erts/emulator/drivers/win32/win_efile.c
+++ b/erts/emulator/drivers/win32/win_efile.c
@@ -196,6 +196,11 @@ set_error(Efile_error* errInfo)
     return 0;
 }
 
+int
+efile_init() {
+   return 1;
+}
+
 /*
  * A writev with Unix semantics, but with Windows arguments 
  */