Merge branch 'master' into sverk/master/halt-INT_MIN

6 files changed, 27 insertions, 2799 deletions

diff --git a/erts/emulator/drivers/common/efile_drv.c b/erts/emulator/drivers/common/efile_drv.c
index 05187341a4..3088dfd572 100644
--- a/erts/emulator/drivers/common/efile_drv.c
+++ b/erts/emulator/drivers/common/efile_drv.c
@@ -101,15 +101,9 @@
 #  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
@@ -882,7 +876,7 @@ static void reply_Uint_posix_error(file_descriptor *desc, Uint num,
     TRACE_C('N');
 
     response[0] = FILE_RESP_NUMERR;
-#if SIZEOF_VOID_P == 4 || HALFWORD_HEAP
+#if SIZEOF_VOID_P == 4
     put_int32(0, response+1);
 #else
     put_int32(num>>32, response+1);
@@ -951,7 +945,7 @@ static int reply_Uint(file_descriptor *desc, Uint result) {
     TRACE_C('R');
 
     tmp[0] = FILE_RESP_NUMBER;
-#if SIZEOF_VOID_P == 4 || HALFWORD_HEAP
+#if SIZEOF_VOID_P == 4
     put_int32(0, tmp+1);
 #else
     put_int32(result>>32, tmp+1);
@@ -1519,10 +1513,10 @@ static void invoke_writev(void *data) {
 		     * with errno.
 		     */
 		    errno = EINVAL; 
-		    if (! (status = 
-			   erts_gzwrite((ErtsGzFile)d->fd,
-					iov[i].iov_base,
-					iov[i].iov_len)) == iov[i].iov_len) {
+		    status = erts_gzwrite((ErtsGzFile)d->fd,
+					  iov[i].iov_base,
+					  iov[i].iov_len) == iov[i].iov_len;
+		    if (! status) {
 			d->errInfo.posix_errno =
 			    d->errInfo.os_errno = errno; /* XXX Correct? */
 			break;
diff --git a/erts/emulator/drivers/common/inet_drv.c b/erts/emulator/drivers/common/inet_drv.c
index 66b0893682..b219669ce5 100644
--- a/erts/emulator/drivers/common/inet_drv.c
+++ b/erts/emulator/drivers/common/inet_drv.c
@@ -94,10 +94,6 @@ typedef unsigned long long llu_t;
 #define INT16_MAX (32767)
 #endif
 
-#ifdef __OSE__
-#include "inet.h"
-#endif
-
 #ifdef __WIN32__
 #define  STRNCASECMP strncasecmp
 
@@ -298,139 +294,7 @@ static unsigned long one_value = 1;
 #define TCP_SHUT_RD    SD_RECEIVE
 #define TCP_SHUT_RDWR  SD_BOTH
 
-#elif defined (__OSE__)
-
-/*
- * Some notes about how inet (currently only tcp) works on OSE.
- * The driver uses OSE signals to communicate with the one_inet
- * process. Because of the difference in how signals and file descriptors
- * work the whole select/deselect mechanic is very different.
- * In ose when a sock_select is done a function is called. That function
- * notes the changes that the driver want to do, but does not act on it.
- * later when the function returns the new desired state is compared
- * to the previous state and the apprioriate actions are taken. The action
- * is usually to either request more data from the stack or stop requesting
- * data.
- *
- * One thing to note is that the driver never does select/deselect. It always
- * listens for the signals. Flow of data is regulated by sending or not sending
- * signals to the ose inet process.
- *
- * The interesting functions to look at are:
- *  * inet_driver_select : called when sock_select is called
- *  * tcp_inet_ose_dispatch_signal : checks state changes and sends new signals
- *  * tcp_inet_drv_output_ose : ready output callback, reads signals and calls
- *                              dispatch_signal
- *  * tcp_inet_drv_input_ose : ready input callback.
- */
-
-#include "efs.h"
-#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"
-#include "ose_spi/socket.sig"
-
-
-static ssize_t writev_fallback(int fd, const struct iovec *iov, int iovcnt, int max_sz);
-
-#define INVALID_SOCKET -1
-#define INVALID_EVENT  -1
-#define SOCKET_ERROR   -1
-
-#define SOCKET int
-#define HANDLE int
-#define FD_READ         ERL_DRV_READ
-#define FD_WRITE        ERL_DRV_WRITE
-#define FD_CLOSE        0
-#define FD_CONNECT      (1<<4)
-#define FD_ACCEPT       (1<<5)
-#define SOCK_FD_ERROR   (1<<6)
-
-#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_fallback((s), (struct iovec*)(vec), (size), (*(np))))
-#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_dup(s)                 dup((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 */
-
-#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)
-
-#define sock_select(d, flags, onoff) do { \
-        ASSERT(!(d)->is_ignored); \
-        (d)->event_mask = (onoff) ? \
-                 ((d)->event_mask | (flags)) : \
-                 ((d)->event_mask & ~(flags)); \
-        DEBUGF(("(%s / %d) sock_select(%ld): flags=%02X, onoff=%d, event_mask=%02lX, s=%d\r\n", \
-		__FILE__, __LINE__, (long) (d)->port, (flags), (onoff), (unsigned long) (d)->event_mask, (d)->s)); \
-        inet_driver_select((d), (flags), (onoff)); \
-   } while(0)
-
-#define TCP_SHUT_WR    SHUT_WR
-#define TCP_SHUT_RD    SHUT_RD
-#define TCP_SHUT_RDWR  SHUT_RDWR
-
-#else /* !__OSE__ && !__WIN32__ */
+#else /* !__WIN32__ */
 
 #include <sys/time.h>
 #ifdef NETDB_H_NEEDS_IN_H
@@ -704,7 +568,7 @@ static int my_strncasecmp(const char *s1, const char *s2, size_t n)
 #define TCP_SHUT_RD    SHUT_RD
 #define TCP_SHUT_RDWR  SHUT_RDWR
 
-#endif /* !__WIN32__ && !__OSE__ */
+#endif /* !__WIN32__ */
 
 #ifdef HAVE_SOCKLEN_T
 #  define SOCKLEN_T socklen_t
@@ -1048,7 +912,7 @@ typedef union {
 #endif
 
 typedef struct _multi_timer_data {
-    ErlDrvNowData when;
+    ErlDrvTime when;
     ErlDrvTermData caller;
     void (*timeout_function)(ErlDrvData drv_data, ErlDrvTermData caller);
     struct _multi_timer_data *next;
@@ -1168,13 +1032,6 @@ typedef struct {
     char *netns;                /* Socket network namespace name
 				   as full file path */
 #endif
-#ifdef __OSE__
-    int select_state;           /* state to keep track of whether we
-				   should trigger another read/write
-				   request at end of ready_input/output */
-    ErlDrvEvent events[6];
-#endif
-
 } inet_descriptor;
 
 
@@ -1190,10 +1047,8 @@ static void tcp_inet_stop(ErlDrvData);
 static void tcp_inet_command(ErlDrvData, char*, ErlDrvSizeT);
 static void tcp_inet_commandv(ErlDrvData, ErlIOVec*);
 static void tcp_inet_flush(ErlDrvData drv_data);
-#ifndef __OSE__
 static void tcp_inet_drv_input(ErlDrvData, ErlDrvEvent);
 static void tcp_inet_drv_output(ErlDrvData data, ErlDrvEvent event);
-#endif
 static ErlDrvData tcp_inet_start(ErlDrvPort, char* command);
 static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData, unsigned int,
 				 char*, ErlDrvSizeT, char**, ErlDrvSizeT);
@@ -1206,71 +1061,6 @@ static void tcp_inet_event(ErlDrvData, ErlDrvEvent);
 static void find_dynamic_functions(void);
 #endif
 
-#ifdef __OSE__
-/* The structure of the signal used for requesting asynchronous 
- * notification from the stack. Under normal circumstances the network stack 
- * shouldn't overwrite the value set in the fd field by the sender 
- * of the request */
-struct OseAsyncSig {
-    struct FmEvent event;
-    int fd;
-};
-
-union SIGNAL {
-    SIGSELECT signo;
-    struct OseAsyncSig async;
-};
-
-static ErlDrvSSizeT tcp_inet_ctl_ose(ErlDrvData e, unsigned int cmd,
-				     char* buf, ErlDrvSizeT len,
-				     char** rbuf, ErlDrvSizeT rsize);
-static void tcp_inet_commandv_ose(ErlDrvData e, ErlIOVec* ev);
-static void tcp_inet_drv_output_ose(ErlDrvData data, ErlDrvEvent event);
-static void tcp_inet_drv_input_ose(ErlDrvData data, ErlDrvEvent event);
-static ErlDrvOseEventId inet_resolve_signal(union SIGNAL *sig);
-
-#ifdef INET_DRV_DEBUG
-
-static char *read_req = "SO_EVENT_READ_REQUEST";
-static char *read_rep = "SO_EVENT_READ_REPLY";
-static char *write_req = "SO_EVENT_WRITE_REQUEST";
-static char *write_rep = "SO_EVENT_WRITE_REPLY";
-static char *eof_req = "SO_EVENT_EOF_REQUEST";
-static char *eof_rep = "SO_EVENT_EOF_REPLY";
-static char *accept_req = "SO_EVENT_ACCEPT_REQUEST";
-static char *accept_rep = "SO_EVENT_ACCEPT_REPLY";
-static char *connect_req = "SO_EVENT_CONNECT_REQUEST";
-static char *connect_rep = "SO_EVENT_CONNECT_REPLY";
-static char *error_req = "SO_EVENT_ERROR_REQUEST";
-static char *error_rep = "SO_EVENT_ERROR_REPLY";
-static char signo_tmp[32];
-
-static char *signo_to_string(SIGSELECT signo) {
-  switch (signo) {
-  case SO_EVENT_READ_REQUEST: { return read_req; }
-  case SO_EVENT_READ_REPLY: { return read_rep; }
-  case SO_EVENT_WRITE_REQUEST: { return write_req; }
-  case SO_EVENT_WRITE_REPLY: { return write_rep; }
-  case SO_EVENT_EOF_REQUEST: { return eof_req; }
-  case SO_EVENT_EOF_REPLY: { return eof_rep; }
-  case SO_EVENT_ACCEPT_REQUEST: { return accept_req; }
-  case SO_EVENT_ACCEPT_REPLY: { return accept_rep; }
-  case SO_EVENT_CONNECT_REQUEST: { return connect_req; }
-  case SO_EVENT_CONNECT_REPLY: { return connect_rep; }
-  case SO_EVENT_ERROR_REQUEST: { return error_req; }
-  case SO_EVENT_ERROR_REPLY: { return error_rep; }
-  }
-
-  snprintf(signo_tmp,32,"0x%x",signo);
-
-  return signo_tmp;
-}
-
-#endif
-
-#endif /* __OSE__ */
-
-
 static struct erl_drv_entry tcp_inet_driver_entry =
 {
     tcp_inet_init,  /* inet_init will add this driver !! */
@@ -1280,9 +1070,6 @@ static struct erl_drv_entry tcp_inet_driver_entry =
 #ifdef __WIN32__
     tcp_inet_event,
     NULL,
-#elif defined(__OSE__)
-    tcp_inet_drv_input_ose, /*ready_input*/
-    tcp_inet_drv_output_ose, /*ready_output*/
 #else
     tcp_inet_drv_input,
     tcp_inet_drv_output,
@@ -1290,17 +1077,9 @@ static struct erl_drv_entry tcp_inet_driver_entry =
     "tcp_inet",
     NULL,
     NULL,
-#ifdef __OSE__
-    tcp_inet_ctl_ose,
-#else
     tcp_inet_ctl,
-#endif
     tcp_inet_timeout,
-#ifdef __OSE__
-    tcp_inet_commandv_ose,
-#else
     tcp_inet_commandv,
-#endif
     NULL,
     tcp_inet_flush,
     NULL,
@@ -1452,14 +1231,6 @@ static int packet_inet_output(udp_descriptor* udesc, HANDLE event);
 /* convert descriptor pointer to inet_descriptor pointer */
 #define INETP(d) (&(d)->inet)
 
-#ifdef __OSE__
-static void inet_driver_select(inet_descriptor* desc,
-			       int flags, int onoff);
-static void tcp_inet_ose_dispatch_signals(tcp_descriptor *desc,
-					  int prev_select_state,
-					  union SIGNAL *sig);
-#endif
-
 static int async_ref = 0;          /* async reference id generator */
 #define NEW_ASYNC_ID() ((async_ref++) & 0xffff)
 
@@ -4355,16 +4126,6 @@ static void desc_close(inet_descriptor* desc)
 	desc->forced_events = 0;
 	desc->send_would_block = 0;
 #endif
-#ifdef __OSE__
-	if (desc->events[0]) {
-	  driver_select(desc->port,desc->events[0],FD_READ|FD_WRITE|ERL_DRV_USE,0);
-	  driver_select(desc->port,desc->events[1],FD_READ|FD_WRITE|ERL_DRV_USE,0);
-	  driver_select(desc->port,desc->events[2],FD_READ|FD_WRITE|ERL_DRV_USE,0);
-	  driver_select(desc->port,desc->events[3],FD_READ|FD_WRITE|ERL_DRV_USE,0);
-	  driver_select(desc->port,desc->events[4],FD_READ|FD_WRITE|ERL_DRV_USE,0);
-	  driver_select(desc->port,desc->events[5],FD_READ|FD_WRITE|ERL_DRV_USE,0);
-	}
-#else
 	/*
 	 * We should close the fd here, but the other driver might still
 	 * be selecting on it.
@@ -4374,7 +4135,6 @@ static void desc_close(inet_descriptor* desc)
 			  ERL_DRV_USE, 0);
 	else
 	  inet_stop_select((ErlDrvEvent)(long)desc->event,NULL);
-#endif
 	desc->event = INVALID_EVENT; /* closed by stop_select callback */
 	desc->s = INVALID_SOCKET;
 	desc->event_mask = 0;
@@ -4416,65 +4176,6 @@ static int erl_inet_close(inet_descriptor* desc)
     return 0;
 }
 
-#ifdef __OSE__
-static void inet_select_init(inet_descriptor* desc)
-{
-    desc->events[0] =
-        erl_drv_ose_event_alloc(SO_EVENT_READ_REPLY,
-                desc->s,
-                inet_resolve_signal,
-                NULL);
-    driver_select(desc->port, desc->events[0],
-            ERL_DRV_READ|ERL_DRV_USE, 1);
-
-    desc->events[1] =
-        erl_drv_ose_event_alloc(SO_EVENT_EOF_REPLY,
-                desc->s,
-                inet_resolve_signal,
-                NULL);
-    driver_select(desc->port, desc->events[1],
-            ERL_DRV_READ|ERL_DRV_USE, 1);
-
-    desc->events[2] =
-        erl_drv_ose_event_alloc(SO_EVENT_ACCEPT_REPLY,
-                desc->s,
-                inet_resolve_signal,
-                NULL);
-    driver_select(desc->port, desc->events[2],
-            ERL_DRV_READ|ERL_DRV_USE, 1);
-
-    /* trigger tcp_inet_input */
-    desc->events[3] =
-        erl_drv_ose_event_alloc(SO_EVENT_WRITE_REPLY,
-                desc->s,
-                inet_resolve_signal,
-                NULL);
-    driver_select(desc->port, desc->events[3],
-            ERL_DRV_WRITE|ERL_DRV_USE, 1);
-
-    desc->events[4] =
-        erl_drv_ose_event_alloc(SO_EVENT_CONNECT_REPLY,
-                desc->s,
-                inet_resolve_signal,
-                NULL);
-    driver_select(desc->port, desc->events[4],
-            ERL_DRV_WRITE|ERL_DRV_USE, 1);
-
-    desc->events[5] =
-        erl_drv_ose_event_alloc(SO_EVENT_ERROR_REPLY,
-                desc->s,
-                inet_resolve_signal,
-                NULL);
-    driver_select(desc->port, desc->events[5],
-            ERL_DRV_WRITE|ERL_DRV_USE, 1);
-
-    /* Issue a select on error event before any other select to be sure we are
-       prepared to receive error notifications from the stack, even in the
-       situations when select isn't issued */
-    sock_select(desc, SOCK_FD_ERROR, 1);
-}
-#endif
-
 static ErlDrvSSizeT inet_ctl_open(inet_descriptor* desc, int domain, int type,
 				  char** rbuf, ErlDrvSizeT rsize)
 {
@@ -4557,9 +4258,6 @@ static ErlDrvSSizeT inet_ctl_open(inet_descriptor* desc, int domain, int type,
 #ifdef __WIN32__
     driver_select(desc->port, desc->event, ERL_DRV_READ, 1);
 #endif
-#ifdef __OSE__
-    inet_select_init(desc);
-#endif
 
     desc->state = INET_STATE_OPEN;
     desc->stype = type;
@@ -4583,13 +4281,7 @@ static ErlDrvSSizeT inet_ctl_fdopen(inet_descriptor* desc, int domain, int type,
         if (name.sa.sa_family != domain)
             return ctl_error(EINVAL, rbuf, rsize);
     }
-#ifdef __OSE__        
-    /* for fdopen duplicating the sd will allow to uniquely identify
-       the signal from OSE with erlang port */
-    desc->s = sock_dup(s);    
-#else
     desc->s = s;
-#endif
 
     if ((desc->event = sock_create_event(desc)) == INVALID_EVENT)
 	return ctl_error(sock_errno(), rbuf, rsize);
@@ -4607,12 +4299,6 @@ static ErlDrvSSizeT inet_ctl_fdopen(inet_descriptor* desc, int domain, int type,
 	sz = sizeof(name);
 	if (!IS_SOCKET_ERROR(sock_peer(s, (struct sockaddr*) &name, &sz))) {
 	    desc->state = INET_STATE_CONNECTED;
-#ifdef __OSE__
-            /* since we are dealing with different descriptors (i.e. inet and
-               socket) the select part should be initialized with the right
-               values */
-            inet_select_init(desc);
-#endif
         }
     }
 
@@ -8414,15 +8100,6 @@ static ErlDrvData inet_start(ErlDrvPort port, int size, int protocol)
 #ifdef HAVE_SETNS
     desc->netns = NULL;
 #endif
-#ifdef __OSE__
-    desc->select_state = 0;
-    desc->events[0] = NULL;
-    desc->events[1] = NULL;
-    desc->events[2] = NULL;
-    desc->events[3] = NULL;
-    desc->events[4] = NULL;
-    desc->events[5] = NULL;
-#endif
 
     return (ErlDrvData)desc;
 }
@@ -9149,10 +8826,6 @@ static tcp_descriptor* tcp_inet_copy(tcp_descriptor* desc,SOCKET s,
     copy_desc->inet.port = port;
     copy_desc->inet.dport = driver_mk_port(port);
 
-#ifdef __OSE__
-    inet_select_init(&copy_desc->inet);
-#endif
-
     *err = 0;
     return copy_desc;
 }
@@ -9214,23 +8887,6 @@ static void tcp_inet_stop(ErlDrvData e)
     inet_stop(INETP(desc));
 }
 
-#ifdef __OSE__
-
-static ErlDrvSSizeT tcp_inet_ctl_ose(ErlDrvData e, unsigned int cmd,
-				     char* buf, ErlDrvSizeT len,
-				     char** rbuf, ErlDrvSizeT rsize) {
-
-  tcp_descriptor* desc = (tcp_descriptor*)e;
-  int prev_select_state = INETP(desc)->select_state;
-
-  ErlDrvSSizeT res = tcp_inet_ctl(e,cmd,buf,len,rbuf,rsize);
-
-  tcp_inet_ose_dispatch_signals((tcp_descriptor*)e,prev_select_state,NULL);
-
-  return res;
-}
-#endif
-
 /* TCP requests from Erlang */
 static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 				 char* buf, ErlDrvSizeT len,
@@ -9672,17 +9328,6 @@ static void tcp_inet_command(ErlDrvData e, char *buf, ErlDrvSizeT len)
     DEBUGF(("tcp_inet_command(%ld) }\r\n", (long)desc->inet.port)); 
 }
 
-#ifdef __OSE__
-
-static void tcp_inet_commandv_ose(ErlDrvData e, ErlIOVec* ev) {
-  int prev_select_state = INETP((tcp_descriptor*)e)->select_state;
-  tcp_inet_commandv(e, ev);
-  tcp_inet_ose_dispatch_signals((tcp_descriptor*)e,prev_select_state,NULL);
-}
-
-#endif
-
-
 static void tcp_inet_commandv(ErlDrvData e, ErlIOVec* ev)
 {
     tcp_descriptor* desc = (tcp_descriptor*)e;
@@ -9755,22 +9400,6 @@ static void inet_stop_select(ErlDrvEvent event, void* _)
 {
 #ifdef __WIN32__
     WSACloseEvent((HANDLE)event);
-#elif defined(__OSE__)
-    ErlDrvOseEventId id;
-    union SIGNAL *sig;
-    erl_drv_ose_event_fetch(event, NULL, &id,NULL);
-    DEBUGF(("inet_stop_select(?#?) {s=%d\n",id));
-    sock_close((int)id);
-    /* On socket close all the signals waiting to be processed as part of the
-       select should be deallocated */
-    while((sig = erl_drv_ose_get_signal(event))) {
-      DEBUGF(("inet_stop_select(?#?): Freeing signal %s\n",
-	      signo_to_string(sig->signo)));
-      free_buf(&sig);
-    }
-    erl_drv_ose_event_free(event);
-    DEBUGF(("inet_stop_select(?#?) }\n"));
-      
 #else
     sock_close((SOCKET)(long)event);
 #endif
@@ -10319,146 +9948,7 @@ static void tcp_inet_event(ErlDrvData e, ErlDrvEvent event)
     return;
 }
 
-#elif defined(__OSE__) /* !__WIN32__ */
-/* The specific resolve signal function. It will return the socket descriptor
-   for which the select was issued */
-static ErlDrvOseEventId inet_resolve_signal(union SIGNAL *sig) {
-  DEBUGF(("%s(?#?): s=%d got signal %s, status = %d, extra = %d, sender = 0x%x\n",
-	  __FUNCTION__,sig->async.fd,signo_to_string(sig->signo),
-	  sig->async.event.status,
-	  sig->async.event.extra,sender(&sig)));
-  if (sig->signo == SO_EVENT_READ_REPLY ||
-      sig->signo == SO_EVENT_ACCEPT_REPLY ||
-      sig->signo == SO_EVENT_EOF_REPLY ||
-      sig->signo == SO_EVENT_WRITE_REPLY ||
-      sig->signo == SO_EVENT_ERROR_REPLY ||
-      sig->signo == SO_EVENT_CONNECT_REPLY ) {
-    return sig->async.fd;
-  }
-
-  return -1;
-}
-
-static void inet_driver_select(inet_descriptor* desc,
-			       int flags, int onoff) {
-    ASSERT(!desc->is_ignored);
-
-    if(onoff) {
-      desc->select_state |= flags;
-    } else {
-      desc->select_state &= ~flags;
-    }
-}
-
-static ssize_t writev_fallback(int fd, const struct iovec *iov, int iovcnt, int max_sz)
-{
-    size_t data_len = 0;
-    size_t sent = 0;
-    ssize_t n;
-    int i;
-
-    for(i = 0; i < iovcnt; i++)
-    {
-        data_len = iov[i].iov_len;
-tryagain:        
-        n = sock_send(fd, iov[i].iov_base, data_len, 0);
-        if (IS_SOCKET_ERROR(n)) {
-            /* If buffer length is greater than the amount stack is able to
-             * send out then try to send at least max_sz (this comes with
-             * SO_EVENT_WRITE_REPLY signal*/
-            if ((errno == EMSGSIZE) && (max_sz > 0) && (data_len > max_sz)) {
-                data_len = max_sz;
-                goto tryagain;
-            }
-            break;
-        }
-        sent += n;
-    }
-    return sent;
-}
-
-#define OSE_EVENT_REQ(TCP_DESC,EVENT) do {				\
-    union SIGNAL *sig = alloc(sizeof(struct OseAsyncSig), EVENT);	\
-    sig->async.fd = INETP(TCP_DESC)->s;					\
-    ose_request_event(INETP(TCP_DESC)->s, &sig, 1);			\
-    DEBUGF(("%s(%ld): s=%d sent %s\r\n",__FUNCTION__,			\
-      INETP(TCP_DESC)->port,INETP(TCP_DESC)->s,signo_to_string(EVENT))); \
-  } while(0)
-
-static void tcp_inet_ose_dispatch_signals(tcp_descriptor *desc,
-					  int prev_select_state,
-					  union SIGNAL *sig) {
-  if (sig) {
-    DEBUGF(("tcp_inet_ose_dispatch_signals(%ld) {s=%d resend\r\n",
-	    (long)INETP(desc)->port,INETP(desc)->s));
-    /* We are reacting to a signal, which means that if
-       the select_state for that signal is still activated
-       we should send a new signal */
-    switch (sig->signo) {
-    case SO_EVENT_READ_REPLY: {
-      if (INETP(desc)->select_state & FD_READ)
-	OSE_EVENT_REQ(desc,SO_EVENT_READ_REQUEST);
-      break;
-    }
-    case SO_EVENT_WRITE_REPLY: {
-      if (INETP(desc)->select_state & FD_WRITE)
-	OSE_EVENT_REQ(desc,SO_EVENT_WRITE_REQUEST);
-      break;
-    }
-    case SO_EVENT_CONNECT_REPLY: {
-      if (INETP(desc)->select_state & FD_CONNECT)
-	OSE_EVENT_REQ(desc,SO_EVENT_CONNECT_REQUEST);
-      break;
-    }
-    case SO_EVENT_ACCEPT_REPLY: {
-      if (INETP(desc)->select_state & FD_ACCEPT)
-	OSE_EVENT_REQ(desc,SO_EVENT_ACCEPT_REQUEST);
-      break;
-    }
-    case SO_EVENT_ERROR_REPLY: {
-      if (INETP(desc)->select_state & SOCK_FD_ERROR)
-	OSE_EVENT_REQ(desc,SO_EVENT_ERROR_REQUEST);
-      break;
-    }
-
-    }
-    DEBUGF(("tcp_inet_ose_dispatch_signals(%ld) }\r\n",
-	    (long)INETP(desc)->port));
-  }
-
-  if (INETP(desc)->select_state != prev_select_state) {
-    /* If the select state has changed we have to issue signals for
-       the state parts that have changed. */
-    int xor_select_state = INETP(desc)->select_state ^ prev_select_state;
-    DEBUGF(("tcp_inet_ose_dispatch_signals(%ld) {s=%d select change\r\n",
-	    (long)INETP(desc)->port,INETP(desc)->s));
-    if ((xor_select_state & FD_READ) &&
-	(INETP(desc)->select_state & FD_READ)) {
-      OSE_EVENT_REQ(desc,SO_EVENT_READ_REQUEST);
-    }
-    if ((xor_select_state & FD_WRITE) &&
-	(INETP(desc)->select_state & FD_WRITE)) {
-      OSE_EVENT_REQ(desc,SO_EVENT_WRITE_REQUEST);
-    }
-    if ((xor_select_state & FD_CONNECT) &&
-	(INETP(desc)->select_state & FD_CONNECT)) {
-      OSE_EVENT_REQ(desc,SO_EVENT_CONNECT_REQUEST);
-    }
-    if ((xor_select_state & FD_ACCEPT) &&
-	(INETP(desc)->select_state & FD_ACCEPT)) {
-      OSE_EVENT_REQ(desc,SO_EVENT_ACCEPT_REQUEST);
-    }
-    if ((xor_select_state & SOCK_FD_ERROR) &&
-	(INETP(desc)->select_state & SOCK_FD_ERROR)) {
-      OSE_EVENT_REQ(desc,SO_EVENT_ERROR_REQUEST);
-    }
-
-    DEBUGF(("tcp_inet_ose_dispatch_signals(%ld) }\r\n",
-	    (long)INETP(desc)->port));
-  }
-}
-
-#endif /* __OSE__ */
+#endif /* __WIN32__ */
 
 
 /* socket has input:
@@ -10945,49 +10435,6 @@ static void tcp_shutdown_async(tcp_descriptor* desc)
 	desc->tcp_add_flags |= TCP_ADDF_SHUTDOWN_WR_DONE;
 }
 
-#ifdef __OSE__
-
-static void tcp_inet_drv_output_ose(ErlDrvData data, ErlDrvEvent event)
-{
-  union SIGNAL *event_sig = erl_drv_ose_get_signal(event);
-
-  while (event_sig) {
-      int prev_select_state = INETP((tcp_descriptor*)data)->select_state;
-      int res = tcp_inet_output((tcp_descriptor*)data, (HANDLE)event_sig);
-      if (res != -1) {
-	tcp_inet_ose_dispatch_signals((tcp_descriptor*)data,
-				      prev_select_state,event_sig);
-	free_buf(&event_sig);
-	event_sig = erl_drv_ose_get_signal(event);
-      } else {
-	/* NOTE: here the event object could have been deallocated!!!!
-	   inet_stop_select is called when doing driver_select(ERL_DRV_USE,0)
-	 */
-	free_buf(&event_sig);
-	return;
-      }
-  }
-}
-
-static void tcp_inet_drv_input_ose(ErlDrvData data, ErlDrvEvent event)
-{
-  union SIGNAL *event_sig = erl_drv_ose_get_signal(event);
-
-  while (event_sig) {
-    int prev_select_state = INETP((tcp_descriptor*)data)->select_state;
-    int res = tcp_inet_input((tcp_descriptor*)data, (HANDLE)event);
-    if (res != -1) {
-      tcp_inet_ose_dispatch_signals((tcp_descriptor*)data, prev_select_state,
-				    event_sig);
-      free_buf(&event_sig);
-      event_sig = erl_drv_ose_get_signal(event);
-    } else {
-      free_buf(&event_sig);
-      return;
-    }
-  }
-}
-#else
 static void tcp_inet_drv_output(ErlDrvData data, ErlDrvEvent event)
 {
     (void)tcp_inet_output((tcp_descriptor*)data, (HANDLE)event);
@@ -10997,7 +10444,6 @@ static void tcp_inet_drv_input(ErlDrvData data, ErlDrvEvent event)
 {
     (void)tcp_inet_input((tcp_descriptor*)data, (HANDLE)event);
 }
-#endif
 
 /* socket ready for ouput:
 ** 1. INET_STATE_CONNECTING => non block connect ?
@@ -11063,13 +10509,6 @@ static int tcp_inet_output(tcp_descriptor* desc, HANDLE event)
 	    ssize_t n;
 	    SysIOVec* iov;
 
-#ifdef __OSE__
-            /* For large size buffers case the amount of data that the stack is
-               able to send out (received in the .extra field) should be passed
-               down to writev_fallback */
-            n = event ? ((union SIGNAL*)event)->async.event.extra : 0;
-#endif
-
 	    if ((iov = driver_peekq(ix, &vsize)) == NULL) {
 		sock_select(INETP(desc), FD_WRITE, 0);
 		send_empty_out_q_msgs(INETP(desc));
@@ -11097,12 +10536,6 @@ static int tcp_inet_output(tcp_descriptor* desc, HANDLE event)
 				    sizes > (max 32 bit signed int) */
 	      size_t howmuch = 0x7FFFFFFF; /* max signed 32 bit */
 	      int x;
-#ifdef __OSE__
-              /* For EWOULDBLOCK sock_sendv returns 0 so we have to be sure it
-                 wasn't the case */
-              if(sock_errno() == ERRNO_BLOCK) 
-                    goto done;
-#endif
 	      for(x = 0; x < vsize && iov[x].iov_len == 0; ++x)
 		;
 	      if (x < vsize) {
@@ -12144,115 +11577,18 @@ make_noninheritable_handle(SOCKET s)
  * Multi-timers
  */
 
-static void absolute_timeout(unsigned millis, ErlDrvNowData *out)
-{
-    unsigned rest;
-    unsigned long millipart;
-    unsigned long secpart;
-    unsigned long megasecpart;
-    unsigned tmo_secs = (millis / 1000U);
-    unsigned tmo_millis = (millis % 1000);
-    driver_get_now(out);
-    rest = (out->microsecs) % 1000;
-    millipart = ((out->microsecs) / 1000UL);
-    if (rest >= 500) {
-	++millipart;
-    }
-    secpart = out->secs;
-    megasecpart = out->megasecs;
-    millipart += tmo_millis;
-    secpart += (millipart / 1000000UL);
-    millipart %= 1000000UL;
-    secpart += tmo_secs;
-    megasecpart += (secpart / 1000000UL);
-    secpart %= 1000000UL;
-    out->megasecs = megasecpart;
-    out->secs = secpart;
-    out->microsecs = (millipart * 1000UL);
-}
-
-static unsigned relative_timeout(ErlDrvNowData *in) 
-{
-    ErlDrvNowData now;
-    unsigned rest;
-    unsigned long millipart, in_millis, in_secs, in_megasecs;
-
-    driver_get_now(&now);
-
-    in_secs = in->secs;
-    in_megasecs = in->megasecs;
-
-    rest = (now.microsecs) % 1000;
-    millipart = ((now.microsecs) / 1000UL);
-    if (rest >= 500) {
-	++millipart;
-    }
-    in_millis = ((in->microsecs) / 1000UL);
-    if ( in_millis < millipart ) {
-	if (in_secs > 0) {
-	    --in_secs;
-	} else {
-	    in_secs = (1000000UL - 1UL);
-	    if (in_megasecs <= now.megasecs) {
-		return 0;
-	    } else {
-		--in_megasecs;
-	    }
-	}
-	in_millis += 1000UL;
-    }
-    in_millis -= millipart;
-    
-    if (in_secs < now.secs) {
-	if (in_megasecs <= now.megasecs) {
-	    return 0;
-	} else {
-	    --in_megasecs;
-	}
-	in_secs += 1000000;
-    }
-    in_secs -= now.secs;
-    if (in_megasecs < now.megasecs) {
-	return 0;
-    } else {
-	in_megasecs -= now.megasecs;
-    }
-    return (unsigned) ((in_megasecs * 1000000000UL) + 
-		       (in_secs * 1000UL) + 
-		       in_millis);
-}
-
-#ifdef DEBUG
-static int nowcmp(ErlDrvNowData *d1, ErlDrvNowData *d2)
-{
-    /* Assume it's not safe to do signed conversion on megasecs... */
-    if (d1->megasecs < d2->megasecs) {
-	return -1;
-    } else if (d1->megasecs > d2->megasecs) {
-	return 1;
-    } else if (d1->secs != d2->secs) {
-	return ((int) d1->secs) - ((int) d2->secs);
-    } 
-    return ((int) d1->microsecs) - ((int) d2->microsecs);
-}
-#endif
-
 static void fire_multi_timers(MultiTimerData **first, ErlDrvPort port,
 			      ErlDrvData data)
 {
-    unsigned next_timeout;
+    ErlDrvTime next_timeout;
     if (!*first) {
 	ASSERT(0);
 	return;
     }
 #ifdef DEBUG
     {
-	ErlDrvNowData chk;
-	driver_get_now(&chk);
-	chk.microsecs /= 10000UL;
-	chk.microsecs *= 10000UL;
-	chk.microsecs += 10000;
-	ASSERT(nowcmp(&chk,&((*first)->when)) >= 0);
+	ErlDrvTime chk = erl_drv_monotonic_time(ERL_DRV_MSEC);
+	ASSERT(chk >= (*first)->when);
     }
 #endif
     do {
@@ -12264,9 +11600,9 @@ static void fire_multi_timers(MultiTimerData **first, ErlDrvPort port,
 	    return;
 	}
 	(*first)->prev = NULL;
-	next_timeout = relative_timeout(&((*first)->when));
-    } while (next_timeout == 0);
-    driver_set_timer(port,next_timeout);
+	next_timeout = (*first)->when - erl_drv_monotonic_time(ERL_DRV_MSEC);
+    } while (next_timeout <= 0);
+    driver_set_timer(port, (unsigned long) next_timeout);
 }
 
 static void clean_multi_timers(MultiTimerData **first, ErlDrvPort port)
@@ -12289,8 +11625,10 @@ static void remove_multi_timer(MultiTimerData **first, ErlDrvPort port, MultiTim
 	driver_cancel_timer(port);
 	*first = p->next;
 	if (*first) {
-	    unsigned ntmo = relative_timeout(&((*first)->when));
-	    driver_set_timer(port,ntmo);
+	    ErlDrvTime ntmo = (*first)->when - erl_drv_monotonic_time(ERL_DRV_MSEC);
+	    if (ntmo < 0)
+		ntmo = 0;
+	    driver_set_timer(port, (unsigned long) ntmo);
 	}
     }
     if (p->next != NULL) {
@@ -12304,26 +11642,14 @@ static MultiTimerData *add_multi_timer(MultiTimerData **first, ErlDrvPort port,
 				       void (*timeout_fun)(ErlDrvData drv_data, 
 							   ErlDrvTermData caller))
 {
-#define eq_mega(a, b) ((a)->when.megasecs == (b)->when.megasecs)
-#define eq_sec(a, b) ((a)->when.secs == (b)->when.secs)
     MultiTimerData *mtd, *p, *s;
     mtd = ALLOC(sizeof(MultiTimerData));
-    absolute_timeout(timeout, &(mtd->when));
+    mtd->when = erl_drv_monotonic_time(ERL_DRV_MSEC) + ((ErlDrvTime) timeout) + 1;
     mtd->timeout_function = timeout_fun;
     mtd->caller = caller;
     mtd->next = mtd->prev = NULL;
     for(p = *first,s = NULL; p != NULL; s = p, p = p->next) {
-	if (p->when.megasecs >= mtd->when.megasecs) {
-	    break;
-	}
-    }
-    for (; p!= NULL && eq_mega(p, mtd); s = p, p = p->next) {
-	if (p->when.secs >= mtd->when.secs) {
-	    break;
-	}
-    }
-    for (; p!= NULL && eq_mega(p, mtd) && eq_sec(p, mtd); s = p, p = p->next) {
-	if (p->when.microsecs >= mtd->when.microsecs) {
+	if (p->when >= mtd->when) {
 	    break;
 	}
     }
@@ -12353,12 +11679,6 @@ static MultiTimerData *add_multi_timer(MultiTimerData **first, ErlDrvPort port,
     }
     return mtd;
 }
-#undef eq_mega
-#undef eq_sec
-	
-
-
-
 
 /*-----------------------------------------------------------------------------
 
diff --git a/erts/emulator/drivers/ose/ose_efile.c b/erts/emulator/drivers/ose/ose_efile.c
deleted file mode 100644
index c8337a95d5..0000000000
--- a/erts/emulator/drivers/ose/ose_efile.c
+++ /dev/null
@@ -1,1125 +0,0 @@
-/*
- * %CopyrightBegin%
- *
- * Copyright Ericsson AB 1997-2012. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions 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
deleted file mode 100644
index 2be9462a47..0000000000
--- a/erts/emulator/drivers/ose/ose_signal_drv.c
+++ /dev/null
@@ -1,897 +0,0 @@
-/*
- * %CopyrightBegin%
- *
- * Copyright Ericsson AB 2013-2013. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions 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
deleted file mode 100644
index f759b47984..0000000000
--- a/erts/emulator/drivers/ose/ttsl_drv.c
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * %CopyrightBegin%
- *
- * Copyright Ericsson AB 1996-2013. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions 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 46eccc6568..00da48b107 100644
--- a/erts/emulator/drivers/unix/unix_efile.c
+++ b/erts/emulator/drivers/unix/unix_efile.c
@@ -39,6 +39,11 @@
 #ifdef HAVE_SYS_UIO_H
 #include <sys/types.h>
 #include <sys/uio.h>
+#if defined(HAVE_SENDFILE) && (defined(__FreeBSD__) || defined(__DragonFly__))
+/* Need to define __BSD_VISIBLE in order to expose prototype of sendfile */
+#define __BSD_VISIBLE 1
+#include <sys/socket.h>
+#endif
 #endif
 #if defined(HAVE_SENDFILE) && (defined(__linux__) || (defined(__sun) && defined(__SVR4)))
 #include <sys/sendfile.h>