From 2e84a2ab5e0f0c82c2d79f69cd2f4bff762762a4 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Thu, 26 Jun 2014 18:50:51 +0200
Subject: erts: Make tty driver non-blocking

Instead of using blocking call to fwrite, the tty driver
now uses non-blocking calls to writev and queues any output
data that cannot be written into the driver queue. Without
this change an stdout write could block an entire scheduler
if for some reason the pseudo tty on the other side does not
consume the output of the Erlang shell.

OTP-12239
---
 erts/emulator/sys/unix/sys.c | 23 ++++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index c3d7440409..ad8b60fe7c 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -34,6 +34,7 @@
 #include <termios.h>
 #include <ctype.h>
 #include <sys/utsname.h>
+#include <sys/select.h>
 
 #ifdef ISC32
 #include <sys/bsdtypes.h>
@@ -2658,18 +2659,30 @@ void sys_preload_end(Preload* p)
     /* Nothing */
 }
 
-/* Read a key from console (?) */
-
+/* Read a key from console, used by break.c
+   Here we assume that all schedulers are stopped so that erl_poll
+   does not interfere with the select below.
+*/
 int sys_get_key(fd)
 int fd;
 {
-    int c;
+    int c, ret;
     unsigned char rbuf[64];
+    fd_set fds;
 
     fflush(stdout);		/* Flush query ??? */
 
-    if ((c = read(fd,rbuf,64)) <= 0) {
-      return c; 
+    FD_ZERO(&fds);
+    FD_SET(fd,&fds);
+
+    ret = select(fd+1, &fds, NULL, NULL, NULL);
+
+    if (ret == 1) {
+        do {
+            c = read(fd,rbuf,64);
+        } while (c < 0 && errno == EAGAIN);
+        if (c <= 0)
+            return c;
     }
 
     return rbuf[0]; 
-- 
cgit v1.2.3


From 5ab275d6554f4db877624a152dda90c0e3c4cddc Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Mon, 30 Jun 2014 17:14:11 +0200
Subject: erts: Make writing to non-tty fds non-blocking

If the fd_driver is given non-tty fds it will now use an async thread
instead of doing a blocking write. An example of a non-tty fd is the
fd used by stderr, but could be anything handed down to the driver.
---
 erts/emulator/sys/unix/sys.c | 230 ++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 215 insertions(+), 15 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index ad8b60fe7c..eed93cb2a0 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -92,8 +92,10 @@ static erts_smp_rwmtx_t environ_rwmtx;
 #  else
 #    define CHLDWTHR 0
 #  endif
+#  define FDBLOCK 1
 #else
 #  define CHLDWTHR 0
+#  define FDBLOCK 0
 #endif
 /*
  * [OTP-3906]
@@ -122,6 +124,15 @@ struct ErtsSysReportExit_ {
 #endif
 };
 
+/* Used by the fd driver iff the fd could not be set to non-blocking */
+typedef struct ErtsSysBlocking_ {
+    ErlDrvPDL pdl;
+    int res;
+    int err;
+    unsigned int pkey;
+} ErtsSysBlocking;
+
+
 /* This data is shared by these drivers - initialized by spawn_init() */
 static struct driver_data {
     ErlDrvPort port_num;
@@ -130,6 +141,8 @@ static struct driver_data {
     int pid;
     int alive;
     int status;
+    int terminating;
+    ErtsSysBlocking *blocking;
 } *driver_data;			/* indexed by fd */
 
 static ErtsSysReportExit *report_exit_list;
@@ -1109,11 +1122,16 @@ void fini_getenv_state(GETENV_STATE *state)
 /* Driver interfaces */
 static ErlDrvData spawn_start(ErlDrvPort, char*, SysDriverOpts*);
 static ErlDrvData fd_start(ErlDrvPort, char*, SysDriverOpts*);
+#if FDBLOCK
+static void fd_async(void *);
+static void fd_ready_async(ErlDrvData drv_data, ErlDrvThreadData thread_data);
+#endif
 static ErlDrvSSizeT fd_control(ErlDrvData, unsigned int, char *, ErlDrvSizeT,
 			       char **, ErlDrvSizeT);
 static ErlDrvData vanilla_start(ErlDrvPort, char*, SysDriverOpts*);
 static int spawn_init(void);
 static void fd_stop(ErlDrvData);
+static void fd_flush(ErlDrvData);
 static void stop(ErlDrvData);
 static void ready_input(ErlDrvData, ErlDrvEvent);
 static void ready_output(ErlDrvData, ErlDrvEvent);
@@ -1158,8 +1176,12 @@ struct erl_drv_entry fd_driver_entry = {
     fd_control,
     NULL,
     outputv,
-    NULL, /* ready_async */
-    NULL, /* flush */
+#if FDBLOCK
+    fd_ready_async, /* ready_async */
+#else
+    NULL,
+#endif
+    fd_flush, /* flush */
     NULL, /* call */
     NULL, /* event */
     ERL_DRV_EXTENDED_MARKER,
@@ -1213,13 +1235,28 @@ static RETSIGTYPE onchld(int signum)
 #endif
 }
 
+static int set_blocking_data(struct driver_data *dd) {
+
+    dd->blocking = erts_alloc(ERTS_ALC_T_SYS_BLOCKING, sizeof(ErtsSysBlocking));
+
+    erts_smp_atomic_add_nob(&sys_misc_mem_sz, sizeof(ErtsSysBlocking));
+
+    dd->blocking->pdl = driver_pdl_create(dd->port_num);
+    dd->blocking->res = 0;
+    dd->blocking->err = 0;
+    dd->blocking->pkey = driver_async_port_key(dd->port_num);
+
+    return 1;
+}
+
 static int set_driver_data(ErlDrvPort port_num,
 			   int ifd,
 			   int ofd,
 			   int packet_bytes,
 			   int read_write,
 			   int exit_status,
-			   int pid)
+			   int pid,
+                           int is_blocking)
 {
     Port *prt;
     ErtsSysReportExit *report_exit;
@@ -1251,8 +1288,13 @@ static int set_driver_data(ErlDrvPort port_num,
 	driver_data[ifd].pid = pid;
 	driver_data[ifd].alive = 1;
 	driver_data[ifd].status = 0;
+        driver_data[ifd].terminating = 0;
+        driver_data[ifd].blocking = NULL;
 	if (read_write & DO_WRITE) {
 	    driver_data[ifd].ofd = ofd;
+            if (is_blocking && FDBLOCK)
+                if (!set_blocking_data(driver_data+ifd))
+                    return -1;
 	    if (ifd != ofd)
 		driver_data[ofd] = driver_data[ifd];  /* structure copy */
 	} else {		/* DO_READ only */
@@ -1268,6 +1310,11 @@ static int set_driver_data(ErlDrvPort port_num,
 	driver_data[ofd].pid = pid;
 	driver_data[ofd].alive = 1;
 	driver_data[ofd].status = 0;
+        driver_data[ofd].terminating = 0;
+        driver_data[ofd].blocking = NULL;
+        if (is_blocking && FDBLOCK)
+            if (!set_blocking_data(driver_data+ofd))
+                return -1;
 	return(ofd);
     }
 }
@@ -1277,6 +1324,7 @@ static int spawn_init()
    int i;
 #if CHLDWTHR
    erts_thr_opts_t thr_opts = ERTS_THR_OPTS_DEFAULT_INITER;
+
    thr_opts.detached = 0;
    thr_opts.suggested_stack_size = 0; /* Smallest possible */
 #endif
@@ -1756,7 +1804,7 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name, SysDriverOpts* op
     }
 
     res = set_driver_data(port_num, ifd[0], ofd[1], opts->packet_bytes,
-			  opts->read_write, opts->exit_status, pid);
+			  opts->read_write, opts->exit_status, pid, 0);
     /* Don't unblock SIGCHLD until now, since the call above must
        first complete putting away the info about our new subprocess. */
     unblock_signals();
@@ -1841,6 +1889,7 @@ static ErlDrvData fd_start(ErlDrvPort port_num, char* name,
 			   SysDriverOpts* opts)
 {
     ErlDrvData res;
+    int non_blocking = 0;
 
     if (((opts->read_write & DO_READ) && opts->ifd >= max_files) ||
 	((opts->read_write & DO_WRITE) && opts->ofd >= max_files))
@@ -1913,6 +1962,20 @@ static ErlDrvData fd_start(ErlDrvPort port_num, char* name,
      * case - it can be called with any old pre-existing file descriptors,
      * the relations between which (if they're even two) we can only guess
      * at - still, we try our best...
+     *
+     * Added note OTP 18: Some systems seem to use stdout/stderr to log data
+     * using unix pipes, so we cannot allow the system to block on a write.
+     * Therefore we use an async thread to write the data to fd's that could
+     * not be set to non-blocking. When no async threads are available we
+     * fall back on the old behaviour.
+     *
+     * Also the guarantee about what is delivered to the OS has changed.
+     * Pre 18 the fd driver did no flushing of data before terminating.
+     * Now it does. This is because we want to be able to guarantee that things
+     * such as escripts and friends really have outputted all data before
+     * terminating. This could potentially block the termination of the system
+     * for a very long time, but if the user wants to terminate fast she should
+     * use erlang:halt with flush=false.
      */
 
     if (opts->read_write & DO_READ) {
@@ -1935,6 +1998,7 @@ static ErlDrvData fd_start(ErlDrvPort port_num, char* name,
 		       imagine a scenario where setting non-blocking mode
 		       here would cause problems - go ahead and do it. */
 
+                    non_blocking = 1;
 		    SET_NONBLOCKING(opts->ofd);
 
 		} else {	/* output fd is a tty, input fd isn't */
@@ -1977,6 +2041,7 @@ static ErlDrvData fd_start(ErlDrvPort port_num, char* name,
 			(nfd = open(tty, O_WRONLY)) != -1) {
 			dup2(nfd, opts->ofd);
 			close(nfd);
+                        non_blocking = 1;
 			SET_NONBLOCKING(opts->ofd);
 		    }
 		}
@@ -1985,8 +2050,9 @@ static ErlDrvData fd_start(ErlDrvPort port_num, char* name,
     }
     CHLD_STAT_LOCK;
     res = (ErlDrvData)(long)set_driver_data(port_num, opts->ifd, opts->ofd,
-				      opts->packet_bytes,
-				      opts->read_write, 0, -1);
+                                            opts->packet_bytes,
+                                            opts->read_write, 0, -1,
+                                            !non_blocking);
     CHLD_STAT_UNLOCK;
     return res;
 }
@@ -2012,14 +2078,30 @@ static void nbio_stop_fd(ErlDrvPort prt, int fd)
     SET_BLOCKING(fd);
 }
 
-static void fd_stop(ErlDrvData fd)  /* Does not close the fds */
+static void fd_stop(ErlDrvData ev)  /* Does not close the fds */
 {
     int ofd;
+    int fd = (int)(long)ev;
+    ErlDrvPort prt = driver_data[fd].port_num;
     
-    nbio_stop_fd(driver_data[(int)(long)fd].port_num, (int)(long)fd);
-    ofd = driver_data[(int)(long)fd].ofd;
-    if (ofd != (int)(long)fd && ofd != -1) 
-	nbio_stop_fd(driver_data[(int)(long)fd].port_num, (int)(long)ofd);
+#if FDBLOCK
+    if (driver_data[fd].blocking) {
+        erts_free(ERTS_ALC_T_SYS_BLOCKING,driver_data[fd].blocking);
+        driver_data[fd].blocking = NULL;
+        erts_smp_atomic_add_nob(&sys_misc_mem_sz, -1*sizeof(ErtsSysBlocking));
+    }
+#endif
+
+    nbio_stop_fd(prt, fd);
+    ofd = driver_data[fd].ofd;
+    if (ofd != fd && ofd != -1)
+	nbio_stop_fd(prt, ofd);
+}
+
+static void fd_flush(ErlDrvData fd)
+{
+    if (!driver_data[(int)(long)fd].terminating)
+        driver_data[(int)(long)fd].terminating = 1;
 }
 
 static ErlDrvData vanilla_start(ErlDrvPort port_num, char* name,
@@ -2042,8 +2124,8 @@ static ErlDrvData vanilla_start(ErlDrvPort port_num, char* name,
 
     CHLD_STAT_LOCK;
     res = (ErlDrvData)(long)set_driver_data(port_num, fd, fd,
-				      opts->packet_bytes,
-				      opts->read_write, 0, -1);
+                                            opts->packet_bytes,
+                                            opts->read_write, 0, -1, 0);
     CHLD_STAT_UNLOCK;
     return res;
 }
@@ -2080,6 +2162,7 @@ static void stop(ErlDrvData fd)
     }
 }
 
+/* used by fd_driver */
 static void outputv(ErlDrvData e, ErlIOVec* ev)
 {
     int fd = (int)(long)e;
@@ -2105,12 +2188,21 @@ static void outputv(ErlDrvData e, ErlIOVec* ev)
     ev->iov[0].iov_base = lbp;
     ev->iov[0].iov_len = pb;
     ev->size += pb;
+
+    if (driver_data[fd].blocking && FDBLOCK)
+        driver_pdl_lock(driver_data[fd].blocking->pdl);
+
     if ((sz = driver_sizeq(ix)) > 0) {
 	driver_enqv(ix, ev, 0);
+
+        if (driver_data[fd].blocking && FDBLOCK)
+            driver_pdl_unlock(driver_data[fd].blocking->pdl);
+
 	if (sz + ev->size >= (1 << 13))
 	    set_busy_port(ix, 1);
     }
-    else {
+    else if (!driver_data[fd].blocking || !FDBLOCK) {
+        /* We try to write directly if the fd in non-blocking */
 	int vsize = ev->vsize > MAX_VSIZE ? MAX_VSIZE : ev->vsize;
 
 	n = writev(ofd, (const void *) (ev->iov), vsize);
@@ -2126,10 +2218,22 @@ static void outputv(ErlDrvData e, ErlIOVec* ev)
 	driver_enqv(ix, ev, n);  /* n is the skip value */
 	driver_select(ix, ofd, ERL_DRV_WRITE|ERL_DRV_USE, 1);
     }
+#if FDBLOCK
+    else {
+        if (ev->size != 0) {
+            driver_enqv(ix, ev, 0);
+            driver_pdl_unlock(driver_data[fd].blocking->pdl);
+            driver_async(ix, &driver_data[fd].blocking->pkey,
+                         fd_async, driver_data+fd, NULL);
+        } else {
+            driver_pdl_unlock(driver_data[fd].blocking->pdl);
+        }
+    }
+#endif
     /* return 0;*/
 }
 
-
+/* Used by spawn_driver and vanilla driver */
 static void output(ErlDrvData e, char* buf, ErlDrvSizeT len)
 {
     int fd = (int)(long)e;
@@ -2192,6 +2296,23 @@ static int port_inp_failure(ErlDrvPort port_num, int ready_fd, int res)
     ASSERT(res <= 0);
     (void) driver_select(port_num, ready_fd, ERL_DRV_READ|ERL_DRV_WRITE, 0); 
     clear_fd_data(ready_fd);
+
+    if (driver_data[ready_fd].blocking && FDBLOCK) {
+        driver_pdl_lock(driver_data[ready_fd].blocking->pdl);
+        if (driver_sizeq(driver_data[ready_fd].port_num) > 0) {
+            driver_pdl_unlock(driver_data[ready_fd].blocking->pdl);
+            /* We have stuff in the output queue, so we just
+               set the state to terminating and wait for fd_async_ready
+               to terminate the port */
+            if (res == 0)
+                driver_data[ready_fd].terminating = 2;
+            else
+                driver_data[ready_fd].terminating = -err;
+            return 0;
+        }
+        driver_pdl_unlock(driver_data[ready_fd].blocking->pdl);
+    }
+
     if (res == 0) {
 	if (driver_data[ready_fd].report_exit) {
 	    CHLD_STAT_LOCK;
@@ -2242,6 +2363,7 @@ static void ready_input(ErlDrvData e, ErlDrvEvent ready_fd)
     port_num = driver_data[fd].port_num;
     packet_bytes = driver_data[fd].packet_bytes;
 
+
     if (packet_bytes == 0) {
 	byte *read_buf = (byte *) erts_alloc(ERTS_ALC_T_SYS_READ_BUF,
 					     ERTS_SYS_READ_BUF_SZ);
@@ -2365,6 +2487,8 @@ static void ready_output(ErlDrvData e, ErlDrvEvent ready_fd)
 
     if ((iv = (struct iovec*) driver_peekq(ix, &vsize)) == NULL) {
 	driver_select(ix, ready_fd, ERL_DRV_WRITE, 0);
+        if (driver_data[fd].terminating)
+            driver_failure_atom(driver_data[fd].port_num,"normal");
 	return; /* 0; */
     }
     vsize = vsize > MAX_VSIZE ? MAX_VSIZE : vsize;
@@ -2390,6 +2514,82 @@ static void stop_select(ErlDrvEvent fd, void* _)
     close((int)fd);
 }
 
+#if FDBLOCK
+
+static void
+fd_async(void *async_data)
+{
+    int res;
+    struct driver_data *dd = (struct driver_data*)async_data;
+    SysIOVec      *iov0;
+    SysIOVec      *iov;
+    int            iovlen;
+    int            iovcnt;
+    int            p;
+    /* much of this code is stolen from efile_drv:invoke_writev */
+    driver_pdl_lock(dd->blocking->pdl);
+    iov0 = driver_peekq(dd->port_num, &iovlen);
+    /* Calculate iovcnt */
+    for (p = 0, iovcnt = 0; iovcnt < iovlen;
+         p += iov0[iovcnt++].iov_len)
+        ;
+    iov = erts_alloc_fnf(ERTS_ALC_T_SYS_WRITE_BUF,
+                         sizeof(SysIOVec)*iovcnt);
+    if (!iov) {
+        res = -1;
+        errno = ENOMEM;
+        erts_free(ERTS_ALC_T_SYS_WRITE_BUF, iov);
+        driver_pdl_unlock(dd->blocking->pdl);
+    } else {
+        memcpy(iov,iov0,iovcnt*sizeof(SysIOVec));
+        driver_pdl_unlock(dd->blocking->pdl);
+
+        res = writev(dd->ofd, iov, iovlen);
+
+        erts_free(ERTS_ALC_T_SYS_WRITE_BUF, iov);
+    }
+    dd->blocking->res = res;
+    dd->blocking->err = errno;
+}
+
+void fd_ready_async(ErlDrvData drv_data,
+                    ErlDrvThreadData thread_data) {
+    struct driver_data *dd = (struct driver_data *)thread_data;
+    ErlDrvPort port_num = dd->port_num;
+
+    ASSERT(dd->blocking);
+    ASSERT(dd == (driver_data + (int)(long)drv_data));
+
+    if (dd->blocking->res > 0) {
+        driver_pdl_lock(dd->blocking->pdl);
+        if (driver_deq(port_num, dd->blocking->res) == 0) {
+            driver_pdl_unlock(dd->blocking->pdl);
+            set_busy_port(port_num, 0);
+            if (dd->terminating) {
+                /* The port is has been ordered to terminate
+                   from either fd_flush or port_inp_failure */
+                if (dd->terminating == 1)
+                    driver_failure_atom(port_num, "normal");
+                else if (dd->terminating == 2)
+                    driver_failure_eof(port_num);
+                else if (dd->terminating < 0)
+                    driver_failure_posix(port_num, -dd->terminating);
+                return; /* -1; */
+            }
+        } else {
+            driver_pdl_unlock(dd->blocking->pdl);
+            /* still data left to write in queue */
+            driver_async(port_num, &dd->blocking->pkey, fd_async, dd, NULL);
+            return /* 0; */;
+        }
+    } else if (dd->blocking->res < 0) {
+        driver_failure_posix(port_num, dd->blocking->err);
+        return; /* -1; */
+    }
+    return; /* 0; */
+}
+
+#endif
 
 void erts_do_break_handling(void)
 {
-- 
cgit v1.2.3


From fb064173870a75d80402c3ad1e48dbaf59f086fb Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Wed, 10 Dec 2014 10:36:51 +0100
Subject: erts: Make sure IOV_MAX is enforced for writev

---
 erts/emulator/sys/unix/sys.c | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index eed93cb2a0..c51954be38 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -86,6 +86,14 @@ static erts_smp_rwmtx_t environ_rwmtx;
 #define DISABLE_VFORK 0
 #endif
 
+#if defined IOV_MAX
+#define MAXIOV IOV_MAX
+#elif defined UIO_MAXIOV
+#define MAXIOV UIO_MAXIOV
+#else
+#define MAXIOV 16
+#endif
+
 #ifdef USE_THREADS
 #  ifdef ENABLE_CHILD_WAITER_THREAD
 #    define CHLDWTHR ENABLE_CHILD_WAITER_THREAD
@@ -2524,32 +2532,28 @@ fd_async(void *async_data)
     SysIOVec      *iov0;
     SysIOVec      *iov;
     int            iovlen;
-    int            iovcnt;
-    int            p;
+    int            err;
     /* much of this code is stolen from efile_drv:invoke_writev */
     driver_pdl_lock(dd->blocking->pdl);
     iov0 = driver_peekq(dd->port_num, &iovlen);
-    /* Calculate iovcnt */
-    for (p = 0, iovcnt = 0; iovcnt < iovlen;
-         p += iov0[iovcnt++].iov_len)
-        ;
+    iovlen = iovlen < MAXIOV ? iovlen : MAXIOV;
     iov = erts_alloc_fnf(ERTS_ALC_T_SYS_WRITE_BUF,
-                         sizeof(SysIOVec)*iovcnt);
+                         sizeof(SysIOVec)*iovlen);
     if (!iov) {
         res = -1;
-        errno = ENOMEM;
-        erts_free(ERTS_ALC_T_SYS_WRITE_BUF, iov);
+        err = ENOMEM;
         driver_pdl_unlock(dd->blocking->pdl);
     } else {
-        memcpy(iov,iov0,iovcnt*sizeof(SysIOVec));
+        memcpy(iov,iov0,iovlen*sizeof(SysIOVec));
         driver_pdl_unlock(dd->blocking->pdl);
 
         res = writev(dd->ofd, iov, iovlen);
+        err = errno;
 
         erts_free(ERTS_ALC_T_SYS_WRITE_BUF, iov);
     }
     dd->blocking->res = res;
-    dd->blocking->err = errno;
+    dd->blocking->err = err;
 }
 
 void fd_ready_async(ErlDrvData drv_data,
-- 
cgit v1.2.3


From f03bce6a77ff5c7885a3b200fe879210299194bb Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Thu, 4 Dec 2014 11:00:22 +0100
Subject: erts: Add support for thread names

---
 erts/emulator/sys/unix/sys.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 5de0c281c4..3320d3e314 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -1327,6 +1327,7 @@ static int spawn_init()
 
    thr_opts.detached = 0;
    thr_opts.suggested_stack_size = 0; /* Smallest possible */
+   thr_opts.name = "child_waiter";
 #endif
 
    sys_sigset(SIGPIPE, SIG_IGN); /* Ignore - we'll handle the write failure */
@@ -3230,6 +3231,7 @@ init_smp_sig_notify(void)
 {
     erts_smp_thr_opts_t thr_opts = ERTS_SMP_THR_OPTS_DEFAULT_INITER;
     thr_opts.detached = 1;
+    thr_opts.name = "sys_sig_dispatcher";
 
     if (pipe(sig_notify_fds) < 0) {
 	erl_exit(ERTS_ABORT_EXIT,
-- 
cgit v1.2.3


From d6d1ef4787951070dd152daf44eff2003b7f2ed2 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Tue, 9 Dec 2014 08:47:49 +0100
Subject: erts: Remove usage of QUANTIFY signal

---
 erts/emulator/sys/unix/sys.c | 25 -------------------------
 1 file changed, 25 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 3320d3e314..81ed5626c2 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -894,21 +894,6 @@ static RETSIGTYPE user_signal1(int signum)
 #endif
 }
 
-#ifdef QUANTIFY
-#if (defined(SIG_SIGSET) || defined(SIG_SIGNAL))
-static RETSIGTYPE user_signal2(void)
-#else
-static RETSIGTYPE user_signal2(int signum)
-#endif
-{
-#ifdef ERTS_SMP
-   smp_sig_notify('2');
-#else
-   quantify_save_data();
-#endif
-}
-#endif
-
 #endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
 
 static void
@@ -960,9 +945,6 @@ void init_break_handler(void)
    sys_sigset(SIGINT, request_break);
 #ifndef ETHR_UNUSABLE_SIGUSRX
    sys_sigset(SIGUSR1, user_signal1);
-#ifdef QUANTIFY
-   sys_sigset(SIGUSR2, user_signal2);
-#endif
 #endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
    sys_sigset(SIGQUIT, do_quit);
 }
@@ -3207,13 +3189,6 @@ signal_dispatcher_thread_func(void *unused)
 	    case '1': /* SIGUSR1 */
 		sigusr1_exit();
 		break;
-#ifdef QUANTIFY
-	    case '2': /* SIGUSR2 */
-		quantify_save_data(); /* Might take a substantial amount of
-					 time, but this is a test/debug
-					 build */
-		break;
-#endif
 	    default:
 		erl_exit(ERTS_ABORT_EXIT,
 			 "signal-dispatcher thread received unknown "
-- 
cgit v1.2.3


From b8a2313263d0f120dacbe82ced5c99545bbd15a3 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Thu, 4 Dec 2014 11:04:23 +0100
Subject: erts: Introduce thread suspend functions

These functions allow any thread to suspend any other thread
immediately and then resume all threads. This is useful when
doing a crash dump in order to get a more accurate picture
of what state the system is in.
---
 erts/emulator/sys/unix/sys.c | 69 +++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 65 insertions(+), 4 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 81ed5626c2..841f0c7575 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -216,6 +216,9 @@ static erts_smp_atomic_t sys_misc_mem_sz;
 #if defined(ERTS_SMP)
 static void smp_sig_notify(char c);
 static int sig_notify_fds[2] = {-1, -1};
+
+static int sig_suspend_fds[2] = {-1, -1};
+#define ERTS_SYS_SUSPEND_SIGNAL SIGUSR2
 #elif defined(USE_THREADS)
 static int async_fd[2];
 #endif
@@ -789,6 +792,9 @@ prepare_crash_dump(int secs)
 	/* We don't want to close the signal notification pipe... */
 	if (i == sig_notify_fds[0] || i == sig_notify_fds[1])
 	    continue;
+	/* We don't want to close the signal syspend pipe... */
+	if (i == sig_suspend_fds[0] || i == sig_suspend_fds[1])
+	    continue;
 #elif defined(USE_THREADS)
 	/* We don't want to close the async notification pipe... */
 	if (i == async_fd[0] || i == async_fd[1])
@@ -877,9 +883,23 @@ sigusr1_exit(void)
 
 #ifdef ETHR_UNUSABLE_SIGUSRX
 #warning "Unusable SIGUSR1 & SIGUSR2. Disabling use of these signals"
-#endif
 
-#ifndef ETHR_UNUSABLE_SIGUSRX
+#else
+
+#ifdef ERTS_SMP
+void
+sys_thr_suspend(erts_tid_t tid) {
+    erts_thr_kill(tid, ERTS_SYS_SUSPEND_SIGNAL);
+}
+
+void
+sys_thr_resume(erts_tid_t tid) {
+    int i = 0, res;
+    do {
+        res = write(sig_suspend_fds[1],&i,sizeof(i));
+    } while (res < 0 && errno == EAGAIN);
+}
+#endif
 
 #if (defined(SIG_SIGSET) || defined(SIG_SIGNAL))
 static RETSIGTYPE user_signal1(void)
@@ -894,6 +914,21 @@ static RETSIGTYPE user_signal1(int signum)
 #endif
 }
 
+#ifdef ERTS_SMP
+#if (defined(SIG_SIGSET) || defined(SIG_SIGNAL))
+static RETSIGTYPE suspend_signal(void)
+#else
+static RETSIGTYPE suspend_signal(int signum)
+#endif
+{
+   int res;
+   int buf[1];
+   do {
+     res = read(sig_suspend_fds[0], buf, sizeof(int));
+   } while (res < 0 && errno == EINTR);
+}
+#endif /* #ifdef ERTS_SMP */
+
 #endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
 
 static void
@@ -944,7 +979,10 @@ void init_break_handler(void)
 {
    sys_sigset(SIGINT, request_break);
 #ifndef ETHR_UNUSABLE_SIGUSRX
-   sys_sigset(SIGUSR1, user_signal1);
+   sys_signal(SIGUSR1, user_signal1);
+#ifdef ERTS_SMP
+   sys_signal(ERTS_SYS_SUSPEND_SIGNAL, suspend_signal);
+#endif /* #ifdef ERTS_SMP */
 #endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
    sys_sigset(SIGQUIT, do_quit);
 }
@@ -963,8 +1001,13 @@ static void block_signals(void)
    sys_sigblock(SIGINT);
 #ifndef ETHR_UNUSABLE_SIGUSRX
    sys_sigblock(SIGUSR1);
+#endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
+#endif /* #ifndef ERTS_SMP */
+
+#if defined(ERTS_SMP) && !defined(ETHR_UNUSABLE_SIGUSRX)
+   sys_sigblock(ERTS_SYS_SUSPEND_SIGNAL);
 #endif
-#endif
+
 }
 
 static void unblock_signals(void)
@@ -978,8 +1021,14 @@ static void unblock_signals(void)
 #ifndef ETHR_UNUSABLE_SIGUSRX
    sys_sigrelease(SIGUSR1);
 #endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
+#endif /* #ifndef ERTS_SMP */
+
+#if defined(ERTS_SMP) && !defined(ETHR_UNUSABLE_SIGUSRX)
+   sys_sigrelease(ERTS_SYS_SUSPEND_SIGNAL);
 #endif
+
 }
+
 /************************** Time stuff **************************/
 #ifdef HAVE_GETHRTIME
 #ifdef GETHRTIME_WITH_CLOCK_GETTIME
@@ -3221,6 +3270,17 @@ init_smp_sig_notify(void)
 			NULL,
 			&thr_opts);
 }
+
+static void
+init_smp_sig_suspend(void) {
+  if (pipe(sig_suspend_fds) < 0) {
+    erl_exit(ERTS_ABORT_EXIT,
+	     "Failed to create sig_suspend pipe: %s (%d)\n",
+	     erl_errno_id(errno),
+	     errno);
+  }
+}
+
 #ifdef __DARWIN__
 
 int erts_darwin_main_thread_pipe[2];
@@ -3371,6 +3431,7 @@ erl_sys_args(int* argc, char** argv)
 
 #ifdef ERTS_SMP
     init_smp_sig_notify();
+    init_smp_sig_suspend();
 #endif
 
     /* Handled arguments have been marked with NULL. Slide arguments
-- 
cgit v1.2.3


From e2a600341324d2ce3689119f8fd61b248702d79f Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Fri, 5 Dec 2014 10:14:51 +0100
Subject: erts: Rename sys_sigset to sys_signal

Also removed old legacy fallback that is no longer used
---
 erts/emulator/sys/unix/sys.c | 65 ++++++--------------------------------------
 1 file changed, 8 insertions(+), 57 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 841f0c7575..74d67cbd57 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -649,39 +649,7 @@ erl_sys_init(void)
 
 /* signal handling */
 
-#ifdef SIG_SIGSET		/* Old SysV */
-RETSIGTYPE (*sys_sigset(sig, func))()
-int sig;
-RETSIGTYPE (*func)();
-{
-    return(sigset(sig, func));
-}
-void sys_sigblock(int sig)
-{
-    sighold(sig);
-}
-void sys_sigrelease(int sig)
-{
-    sigrelse(sig);
-}
-#else /* !SIG_SIGSET */
-#ifdef SIG_SIGNAL		/* Old BSD */
-RETSIGTYPE (*sys_sigset(sig, func))(int, int)
-int sig;
-RETSIGTYPE (*func)();
-{
-    return(signal(sig, func));
-}
-sys_sigblock(int sig)
-{
-    sigblock(sig);
-}
-sys_sigrelease(int sig)
-{
-    sigsetmask(sigblock(0) & ~sigmask(sig));
-}
-#else /* !SIG_SIGNAL */	/* The True Way - POSIX!:-) */
-RETSIGTYPE (*sys_sigset(int sig, RETSIGTYPE (*func)(int)))(int)
+SIGFUNC sys_signal(int sig, SIGFUNC func)
 {
     struct sigaction act, oact;
 
@@ -714,23 +682,6 @@ void sys_sigrelease(int sig)
     sigaddset(&mask, sig);
     sigprocmask(SIG_UNBLOCK, &mask, (sigset_t *)NULL);
 }
-#endif /* !SIG_SIGNAL */
-#endif /* !SIG_SIGSET */
-
-#if (0) /* not used? -- gordon */
-static void (*break_func)();
-static RETSIGTYPE break_handler(int sig)
-{
-#ifdef QNX
-    /* Turn off SIGCHLD during break processing */
-    sys_sigblock(SIGCHLD);
-#endif
-    (*break_func)();
-#ifdef QNX
-    sys_sigrelease(SIGCHLD);
-#endif
-}
-#endif /* 0 */
 
 static ERTS_INLINE int
 prepare_crash_dump(int secs)
@@ -952,9 +903,9 @@ static RETSIGTYPE do_quit(int signum)
 
 /* Disable break */
 void erts_set_ignore_break(void) {
-    sys_sigset(SIGINT,  SIG_IGN);
-    sys_sigset(SIGQUIT, SIG_IGN);
-    sys_sigset(SIGTSTP, SIG_IGN);
+    sys_signal(SIGINT,  SIG_IGN);
+    sys_signal(SIGQUIT, SIG_IGN);
+    sys_signal(SIGTSTP, SIG_IGN);
 }
 
 /* Don't use ctrl-c for break handler but let it be 
@@ -977,14 +928,14 @@ void erts_replace_intr(void) {
 
 void init_break_handler(void)
 {
-   sys_sigset(SIGINT, request_break);
+   sys_signal(SIGINT, request_break);
 #ifndef ETHR_UNUSABLE_SIGUSRX
    sys_signal(SIGUSR1, user_signal1);
 #ifdef ERTS_SMP
    sys_signal(ERTS_SYS_SUSPEND_SIGNAL, suspend_signal);
 #endif /* #ifdef ERTS_SMP */
 #endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
-   sys_sigset(SIGQUIT, do_quit);
+   sys_signal(SIGQUIT, do_quit);
 }
 
 int sys_max_files(void)
@@ -1361,7 +1312,7 @@ static int spawn_init()
    thr_opts.name = "child_waiter";
 #endif
 
-   sys_sigset(SIGPIPE, SIG_IGN); /* Ignore - we'll handle the write failure */
+   sys_signal(SIGPIPE, SIG_IGN); /* Ignore - we'll handle the write failure */
    driver_data = (struct driver_data *)
        erts_alloc(ERTS_ALC_T_DRV_TAB, max_files * sizeof(struct driver_data));
    erts_smp_atomic_add_nob(&sys_misc_mem_sz,
@@ -1374,7 +1325,7 @@ static int spawn_init()
    sys_sigblock(SIGCHLD);
 #endif
 
-   sys_sigset(SIGCHLD, onchld); /* Reap children */
+   sys_signal(SIGCHLD, onchld); /* Reap children */
 
 #if CHLDWTHR
    erts_thr_create(&child_waiter_tid, child_waiter, NULL, &thr_opts);
-- 
cgit v1.2.3


From ffd0153e6dffcc29cf79d0191860047dba0438bb Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Thu, 4 Dec 2014 11:09:06 +0100
Subject: erts: Improve crash dumps

This commit improves crash dumps in several ways:
  *  Suspends schedulers to get a current snapshot
  *  Dumps information about scheduler
  *  Dumps stack trace of current running process
     (including Garbing processes)
---
 erts/emulator/sys/unix/sys.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 74d67cbd57..57f9fbef53 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -223,6 +223,8 @@ static int sig_suspend_fds[2] = {-1, -1};
 static int async_fd[2];
 #endif
 
+jmp_buf erts_sys_sigsegv_jmp;
+
 #if CHLDWTHR || defined(ERTS_SMP)
 erts_mtx_t chld_stat_mtx;
 #endif
@@ -683,6 +685,35 @@ void sys_sigrelease(int sig)
     sigprocmask(SIG_UNBLOCK, &mask, (sigset_t *)NULL);
 }
 
+void erts_sys_sigsegv_handler(int signo) {
+    if (signo == SIGSEGV) {
+        longjmp(erts_sys_sigsegv_jmp, 1);
+    }
+}
+
+/*
+ * Function returns 1 if we can read from all values in between
+ * start and stop.
+ */
+int
+erts_sys_is_area_readable(char *start, char *stop) {
+    int fds[2];
+    if (!pipe(fds)) {
+        /* We let write try to figure out if the pointers are readable */
+        int res = write(fds[1], start, (char*)stop - (char*)start);
+        if (res == -1) {
+            close(fds[0]);
+            close(fds[1]);
+            return 0;
+        }
+        close(fds[0]);
+        close(fds[1]);
+        return 1;
+    }
+    return 0;
+
+}
+
 static ERTS_INLINE int
 prepare_crash_dump(int secs)
 {
-- 
cgit v1.2.3


From bd4b900c09308a6c3ab41e3a2070cb90410ee01d Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Fri, 12 Dec 2014 15:13:31 +0100
Subject: erts: Make main thread safe from pipe closed event

---
 erts/emulator/sys/unix/sys.c | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 57f9fbef53..e1a932fdda 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -3290,9 +3290,11 @@ erts_sys_main_thread(void)
 #endif
 
     smp_sig_notify(0); /* Notify initialized */
-    while (1) {
-	/* Wait for a signal to arrive... */
+
+    /* Wait for a signal to arrive... */
+
 #ifdef __DARWIN__
+    while (1) {
 	/*
 	 * The wx driver needs to be able to steal the main thread for Cocoa to
 	 * work properly.
@@ -3307,12 +3309,24 @@ erts_sys_main_thread(void)
 	    void* (*func)(void*);
 	    void* arg;
 	    void *resp;
-	    read(erts_darwin_main_thread_pipe[0],&func,sizeof(void* (*)(void*)));
-	    read(erts_darwin_main_thread_pipe[0],&arg, sizeof(void*));
+            res = read(erts_darwin_main_thread_pipe[0],&func,sizeof(void* (*)(void*)));
+            if (res != sizeof(void* (*)(void*)))
+                break;
+            res = read(erts_darwin_main_thread_pipe[0],&arg,sizeof(void*));
+            if (res != sizeof(void*))
+                break;
 	    resp = (*func)(arg);
 	    write(erts_darwin_main_thread_result_pipe[1],&resp,sizeof(void *));
 	}
-#else
+
+        if (res == -1 && errno != EINTR)
+            break;
+    }
+    /* Something broke with the main thread pipe, so we ignore it for now.
+       Most probably erts has closed this pipe and is about to exit. */
+#endif /* #ifdef __DARWIN__ */
+
+    while (1) {
 #ifdef DEBUG
 	int res =
 #else
@@ -3321,7 +3335,6 @@ erts_sys_main_thread(void)
 	    select(0, NULL, NULL, NULL, NULL);
 	ASSERT(res < 0);
 	ASSERT(errno == EINTR);
-#endif
     }
 }
 
-- 
cgit v1.2.3


From aaa0536429ac827f3651bccd938f7d891f448b42 Mon Sep 17 00:00:00 2001
From: Henrik Nord <henrik@erlang.org>
Date: Wed, 4 Feb 2015 12:13:26 +0100
Subject: fix faulty merge

---
 erts/emulator/sys/unix/sys.c | 28 ----------------------------
 1 file changed, 28 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 69be052381..0d9c743c0c 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -778,36 +778,8 @@ prepare_crash_dump(int secs)
 			 heart_port->common.id, list, NULL);
     }
 
-<<<<<<< HEAD
-    /* Make sure we unregister at epmd (unknown fd) and get at least
-       one free filedescriptor (for erl_crash.dump) */
-
-    max = max_files;
-    if (max < 1024)
-	max = 1024;
-    for (i = 3; i < max; i++) {
-#if defined(ERTS_SMP)
-	/* We don't want to close the signal notification pipe... */
-	if (i == sig_notify_fds[0] || i == sig_notify_fds[1])
-	    continue;
-	/* We don't want to close the signal syspend pipe... */
-	if (i == sig_suspend_fds[0] || i == sig_suspend_fds[1])
-	    continue;
-#elif defined(USE_THREADS)
-	/* We don't want to close the async notification pipe... */
-	if (i == async_fd[0] || i == async_fd[1])
-	    continue;
-#endif
-	/* We don't want to close our heart yet ... */
-	if (i == heart_fd[0] || i == heart_fd[1])
-	    continue;
-
-	close(i);
-    }
-=======
     /* Make sure we have a fd for our crashdump file. */
     close(crashdump_companion_cube_fd);
->>>>>>> maint
 
     envsz = sizeof(env);
     i = erts_sys_getenv__("ERL_CRASH_DUMP_NICE", env, &envsz);
-- 
cgit v1.2.3


From 6487aac5977cf470bc6a2cd0964da2850ee38717 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Thu, 30 Oct 2014 23:57:01 +0100
Subject: Introduce a new time API

The old time API is based on erlang:now/0. The major issue with
erlang:now/0 is that it was intended to be used for so many
unrelated things. This tied these unrelated operations together
and unnecessarily caused performance, scalability as well as
accuracy, and precision issues for operations that do not need
to have such issues. The new API spreads different functionality
over multiple functions in order to improve on this.

The new API consists of a number of new BIFs:
- erlang:convert_time_unit/3
- erlang:monotonic_time/0
- erlang:monotonic_time/1
- erlang:system_time/0
- erlang:system_time/1
- erlang:time_offset/0
- erlang:time_offset/1
- erlang:timestamp/0
- erlang:unique_integer/0
- erlang:unique_integer/1
- os:system_time/0
- os:system_time/1

and a number of extensions of existing BIFs:
- erlang:monitor(time_offset, clock_service)
- erlang:system_flag(time_offset, finalize)
- erlang:system_info(os_monotonic_time_source)
- erlang:system_info(time_offset)
- erlang:system_info(time_warp_mode)
- erlang:system_info(time_correction)
- erlang:system_info(start_time)

See the "Time and Time Correction in Erlang" chapter of the
ERTS User's Guide for more information.
---
 erts/emulator/sys/unix/sys.c | 24 +++---------------------
 1 file changed, 3 insertions(+), 21 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 0d677d5f34..70f549a37a 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -280,7 +280,7 @@ struct {
     int (*event)(ErlDrvPort, ErlDrvEvent, ErlDrvEventData);
     void (*check_io_as_interrupt)(void);
     void (*check_io_interrupt)(int);
-    void (*check_io_interrupt_tmd)(int, erts_short_time_t);
+    void (*check_io_interrupt_tmd)(int, ErtsMonotonicTime);
     void (*check_io)(int);
     Uint (*size)(void);
     Eterm (*info)(void *);
@@ -386,9 +386,9 @@ erts_sys_schedule_interrupt(int set)
 
 #ifdef ERTS_SMP
 void
-erts_sys_schedule_interrupt_timed(int set, erts_short_time_t msec)
+erts_sys_schedule_interrupt_timed(int set, ErtsMonotonicTime timeout_time)
 {
-    ERTS_CHK_IO_INTR_TMD(set, msec);
+    ERTS_CHK_IO_INTR_TMD(set, timeout_time);
 }
 #endif
 
@@ -984,24 +984,6 @@ static void unblock_signals(void)
 #endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
 #endif
 }
-/************************** Time stuff **************************/
-#ifdef HAVE_GETHRTIME
-#ifdef GETHRTIME_WITH_CLOCK_GETTIME
-
-SysHrTime sys_gethrtime(void)
-{
-    struct timespec ts;
-    long long result;
-    if (clock_gettime(CLOCK_MONOTONIC,&ts) != 0) {
-	erl_exit(1,"Fatal, could not get clock_monotonic value!, "
-		 "errno = %d\n", errno);
-    }
-    result = ((long long) ts.tv_sec) * 1000000000LL + 
-	((long long) ts.tv_nsec);
-    return (SysHrTime) result;
-}
-#endif
-#endif
 
 /************************** OS info *******************************/
 
-- 
cgit v1.2.3


From 50713b7d6179477d6018e6a9ca5610617e3de1fe Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Sat, 21 Mar 2015 11:59:34 +0100
Subject: Unbreak lcnt

---
 erts/emulator/sys/unix/sys.c | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 70f549a37a..58b01c094e 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -504,11 +504,14 @@ thr_create_prepare_child(void *vtcdp)
 void
 erts_sys_pre_init(void)
 {
+#ifdef USE_THREADS
+    erts_thr_init_data_t eid = ERTS_THR_INIT_DATA_DEF_INITER;
+#endif
+
     erts_printf_add_cr_to_stdout = 1;
     erts_printf_add_cr_to_stderr = 1;
+
 #ifdef USE_THREADS
-    {
-    erts_thr_init_data_t eid = ERTS_THR_INIT_DATA_DEF_INITER;
 
     eid.thread_create_child_func = thr_create_prepare_child;
     /* Before creation in parent */
@@ -525,6 +528,12 @@ erts_sys_pre_init(void)
 
     erts_thr_init(&eid);
 
+#endif /* USE_THREADS */
+
+    erts_init_sys_time_sup();
+
+#ifdef USE_THREADS
+
     report_exit_list = NULL;
 
 #ifdef ERTS_ENABLE_LOCK_COUNT
@@ -541,7 +550,7 @@ erts_sys_pre_init(void)
     erts_cnd_init(&chld_stat_cnd);
     children_alive = 0;
 #endif
-    }
+
 #ifdef ERTS_SMP
     erts_smp_atomic32_init_nob(&erts_break_requested, 0);
     erts_smp_atomic32_init_nob(&erts_got_sigusr1, 0);
@@ -554,7 +563,9 @@ erts_sys_pre_init(void)
 #if !CHLDWTHR && !defined(ERTS_SMP)
     children_died = 0;
 #endif
+
 #endif /* USE_THREADS */
+
     erts_smp_atomic_init_nob(&sys_misc_mem_sz, 0);
 
     {
-- 
cgit v1.2.3


From e52829ceb614b36c31a650dea455a463fc490698 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Mon, 23 Mar 2015 16:39:56 +0100
Subject: erts_sys_hrtime() for lcnt

---
 erts/emulator/sys/unix/sys.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 58b01c094e..3647ea6a88 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -528,18 +528,18 @@ erts_sys_pre_init(void)
 
     erts_thr_init(&eid);
 
-#endif /* USE_THREADS */
-
-    erts_init_sys_time_sup();
-
-#ifdef USE_THREADS
-
     report_exit_list = NULL;
 
 #ifdef ERTS_ENABLE_LOCK_COUNT
     erts_lcnt_init();
 #endif
 
+#endif /* USE_THREADS */
+
+    erts_init_sys_time_sup();
+
+#ifdef USE_THREADS
+
 #if CHLDWTHR || defined(ERTS_SMP)
     erts_mtx_init(&chld_stat_mtx, "child_status");
 #endif
-- 
cgit v1.2.3


From 738c34d4bb8f1a3811acd00af8c6c12107f8315b Mon Sep 17 00:00:00 2001
From: Bruce Yinhe <bruce@erlang.org>
Date: Thu, 18 Jun 2015 11:31:02 +0200
Subject: Change license text to APLv2

---
 erts/emulator/sys/unix/sys.c | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 7d52650a70..b036b20b7b 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -3,16 +3,17 @@
  *
  * Copyright Ericsson AB 1996-2014. All Rights Reserved.
  *
- * The contents of this file are subject to the Erlang Public License,
- * Version 1.1, (the "License"); you may not use this file except in
- * compliance with the License. You should have received a copy of the
- * Erlang Public License along with this software. If not, it can be
- * retrieved online at http://www.erlang.org/.
+ * 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
  *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
- * the License for the specific language governing rights and limitations
- * under the License.
+ *     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%
  */
-- 
cgit v1.2.3


From ba8740af39b7d4c612b2ee55e3bad6fbdcaf1418 Mon Sep 17 00:00:00 2001
From: Steve Vinoski <vinoski@ieee.org>
Date: Mon, 10 Aug 2015 08:34:28 -0400
Subject: Handle ERRNO_BLOCK in fd_driver async functions

Several users on erlang-questions have reported problems with recent
releases where output to standard_error causes standard_error_sup to
die from receiving an unexpected eagain error. In the fd_driver,
change the fd_async() function to handle EINTR, and change
fd_ready_async() to handle ERRNO_BLOCK. Add a new test to
standard_error_SUITE to generate output to standard_error and ensure
that standard_error_sup does not die. Thanks to Kota Uenishi for
contributing the test case.
---
 erts/emulator/sys/unix/sys.c | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

(limited to 'erts/emulator/sys/unix/sys.c')

diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index b036b20b7b..8d7da3e47e 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -2527,7 +2527,7 @@ fd_async(void *async_data)
     SysIOVec      *iov0;
     SysIOVec      *iov;
     int            iovlen;
-    int            err;
+    int            err = 0;
     /* much of this code is stolen from efile_drv:invoke_writev */
     driver_pdl_lock(dd->blocking->pdl);
     iov0 = driver_peekq(dd->port_num, &iovlen);
@@ -2542,8 +2542,11 @@ fd_async(void *async_data)
         memcpy(iov,iov0,iovlen*sizeof(SysIOVec));
         driver_pdl_unlock(dd->blocking->pdl);
 
-        res = writev(dd->ofd, iov, iovlen);
-        err = errno;
+        do {
+            res = writev(dd->ofd, iov, iovlen);
+        } while (res < 0 && errno == EINTR);
+        if (res < 0)
+            err = errno;
 
         erts_free(ERTS_ALC_T_SYS_WRITE_BUF, iov);
     }
@@ -2582,7 +2585,12 @@ void fd_ready_async(ErlDrvData drv_data,
             return /* 0; */;
         }
     } else if (dd->blocking->res < 0) {
-        driver_failure_posix(port_num, dd->blocking->err);
+        if (dd->blocking->err == ERRNO_BLOCK) {
+            set_busy_port(port_num, 1);
+            /* still data left to write in queue */
+            driver_async(port_num, &dd->blocking->pkey, fd_async, dd, NULL);
+        } else
+            driver_failure_posix(port_num, dd->blocking->err);
         return; /* -1; */
     }
     return; /* 0; */
-- 
cgit v1.2.3