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

2 files changed, 135 insertions, 18 deletions

diff --git a/erts/emulator/drivers/unix/ttsl_drv.c b/erts/emulator/drivers/unix/ttsl_drv.c
index 491e0a090e..73ce27c6ec 100644
--- a/erts/emulator/drivers/unix/ttsl_drv.c
+++ b/erts/emulator/drivers/unix/ttsl_drv.c
@@ -32,6 +32,10 @@ static ErlDrvData ttysl_start(ErlDrvPort, char*);
 
 #ifdef HAVE_TERMCAP  /* else make an empty driver that can not be opened */
 
+#ifndef WANT_NONBLOCKING
+#define WANT_NONBLOCKING
+#endif
+
 #include "sys.h"
 #include <ctype.h>
 #include <stdlib.h>
@@ -39,6 +43,7 @@ static ErlDrvData ttysl_start(ErlDrvPort, char*);
 #include <string.h>
 #include <signal.h>
 #include <fcntl.h>
+#include <limits.h>
 #include <locale.h>
 #include <unistd.h>
 #include <termios.h>
@@ -57,6 +62,14 @@ static ErlDrvData ttysl_start(ErlDrvPort, char*);
 #include <langinfo.h>
 #endif
 
+#if defined IOV_MAX
+#define MAXIOV IOV_MAX
+#elif defined UIO_MAXIOV
+#define MAXIOV UIO_MAXIOV
+#else
+#define MAXIOV 16
+#endif
+
 #define TRUE 1
 #define FALSE 0
 
@@ -85,7 +98,9 @@ static volatile int cols_needs_update = FALSE;
 #define CTRL_OP_GET_UNICODE_STATE 101
 #define CTRL_OP_SET_UNICODE_STATE 102
 
-
+/* We use 1024 as the buf size as that was the default buf size of FILE streams
+   on all platforms that I checked. */
+#define TTY_BUFFSIZE 1024
 
 static int lbuf_size = BUFSIZ;
 static Uint32 *lbuf;		/* The current line buffer */
@@ -113,13 +128,18 @@ static int lpos;                /* The current "cursor position" in the line buf
 /* Main interface functions. */
 static void ttysl_stop(ErlDrvData);
 static void ttysl_from_erlang(ErlDrvData, char*, ErlDrvSizeT);
+static void ttysl_to_tty(ErlDrvData, ErlDrvEvent);
+static void ttysl_flush_tty(ErlDrvData);
 static void ttysl_from_tty(ErlDrvData, ErlDrvEvent);
 static void ttysl_stop_select(ErlDrvEvent, void*);
 static Sint16 get_sint16(char*);
 
 static ErlDrvPort ttysl_port;
 static int ttysl_fd;
-static FILE *ttysl_out;
+static int ttysl_terminate = 0;
+static ErlDrvBinary *putcbuf;
+static int putcpos;
+static int putclen;
 
 /* Functions that work on the line buffer. */
 static int start_lbuf(void);
@@ -201,22 +221,22 @@ struct erl_drv_entry ttsl_driver_entry = {
     IF_IMPL(ttysl_stop),
     IF_IMPL(ttysl_from_erlang),
     IF_IMPL(ttysl_from_tty),
-    NULL,
-    "tty_sl",
-    NULL,
-    NULL,
+    IF_IMPL(ttysl_to_tty),
+    "tty_sl", /* driver_name */
+    NULL, /* finish */
+    NULL, /* handle */
     IF_IMPL(ttysl_control),
     NULL, /* timeout */
     NULL, /* outputv */
     NULL, /* ready_async */
-    NULL, /* flush */
+    IF_IMPL(ttysl_flush_tty),
     NULL, /* call */
     NULL, /* event */
     ERL_DRV_EXTENDED_MARKER,
     ERL_DRV_EXTENDED_MAJOR_VERSION,
     ERL_DRV_EXTENDED_MINOR_VERSION,
     0, /* ERL_DRV_FLAGs */
-    NULL,
+    NULL, /* handle2 */
     NULL, /* process_exit */
     IF_IMPL(ttysl_stop_select)
 };
@@ -296,8 +316,7 @@ static ErlDrvData ttysl_start(ErlDrvPort port, char* buf)
 	return ERL_DRV_ERROR_GENERAL;
     }
 
-    /* Open the terminal and set the terminal */
-    ttysl_out = fdopen(ttysl_fd, "w");
+    SET_NONBLOCKING(ttysl_fd);
 
 #ifdef PRIMITIVE_UTF8_CHECK
     setlocale(LC_CTYPE, "");  /* Set international environment, 
@@ -400,12 +419,14 @@ static void ttysl_stop(ErlDrvData ttysl_data)
 	stop_lbuf();
 	stop_termcap();
 	tty_reset(ttysl_fd);
-	driver_select(ttysl_port, (ErlDrvEvent)(UWord)ttysl_fd, ERL_DRV_READ|ERL_DRV_USE, 0);
+	driver_select(ttysl_port, (ErlDrvEvent)(UWord)ttysl_fd,
+                      ERL_DRV_WRITE|ERL_DRV_READ|ERL_DRV_USE, 0);
 	sys_sigset(SIGCONT, SIG_DFL);
 	sys_sigset(SIGWINCH, SIG_DFL);
     }
     ttysl_port = (ErlDrvPort)-1;
     ttysl_fd = -1;
+    ttysl_terminate = 0;
     /* return TRUE; */
 }
 
@@ -650,6 +671,14 @@ static int check_buf_size(byte *s, int n)
 
 static void ttysl_from_erlang(ErlDrvData ttysl_data, char* buf, ErlDrvSizeT count)
 {
+    ErlDrvSizeT sz;
+
+    sz = driver_sizeq(ttysl_port);
+
+    putclen = count > TTY_BUFFSIZE ? TTY_BUFFSIZE : count;
+    putcbuf = driver_alloc_binary(putclen);
+    putcpos = 0;
+
     if (lpos > MAXSIZE) 
 	put_chars((byte*)"\n", 1);
 
@@ -678,10 +707,78 @@ static void ttysl_from_erlang(ErlDrvData ttysl_data, char* buf, ErlDrvSizeT coun
 	/* Unknown op, just ignore. */
 	break;
     }
-    fflush(ttysl_out);
+
+    driver_enq_bin(ttysl_port,putcbuf,0,putcpos);
+
+    if (sz == 0) {
+        for (;;) {
+            int written, qlen;
+            SysIOVec *iov;
+
+            iov = driver_peekq(ttysl_port,&qlen);
+            if (iov)
+                written = writev(ttysl_fd, iov, qlen > MAXIOV ? MAXIOV : qlen);
+            else
+                written = 0;
+            if (written < 0) {
+                if (errno == EAGAIN) {
+                    driver_select(ttysl_port,(ErlDrvEvent)(long)ttysl_fd,
+                                  ERL_DRV_USE|ERL_DRV_WRITE,1);
+                    break;
+                } else {
+                    /* we ignore all other errors */
+                    break;
+                }
+            } else {
+                if (driver_deq(ttysl_port, written) == 0)
+                    break;
+            }
+        }
+    }
+
     return; /* TRUE; */
 }
 
+static void ttysl_to_tty(ErlDrvData ttysl_data, ErlDrvEvent fd) {
+    for (;;) {
+        int written, qlen;
+        SysIOVec *iov;
+        ErlDrvSizeT sz;
+
+        iov = driver_peekq(ttysl_port,&qlen);
+        if (iov)
+            written = writev(ttysl_fd, iov, qlen > MAXIOV ? MAXIOV : qlen);
+        else
+            written = 0;
+        if (written < 0) {
+            if (errno == EAGAIN) {
+                break;
+            } else {
+                /* we ignore all other errors */
+            }
+        } else {
+            sz = driver_deq(ttysl_port, written);
+            if (sz == 0) {
+                driver_select(ttysl_port,(ErlDrvEvent)(long)ttysl_fd,
+                              ERL_DRV_WRITE,0);
+                if (ttysl_terminate)
+                    /* flush has been called, which means we should terminate
+                       when queue is empty. This will not send any exit
+                       message */
+                    driver_failure_atom(ttysl_port, "normal");
+                break;
+            }
+        }
+    }
+
+    return;
+}
+
+static void ttysl_flush_tty(ErlDrvData ttysl_data) {
+    ttysl_terminate = 1;
+    return;
+}
+
 static void ttysl_from_tty(ErlDrvData ttysl_data, ErlDrvEvent fd)
 {
     byte b[1024];
@@ -1070,7 +1167,14 @@ static int write_buf(Uint32 *s, int n)
 /* The basic procedure for outputting one character. */
 static int outc(int c)
 {
-    return (int)putc(c, ttysl_out);
+    putcbuf->orig_bytes[putcpos++] = c;
+    if (putcpos == putclen) {
+        driver_enq_bin(ttysl_port,putcbuf,0,putclen);
+        putcpos = 0;
+        putclen = TTY_BUFFSIZE;
+        putcbuf = driver_alloc_binary(BUFSIZ);
+    }
+    return 1;
 }
 
 static int move_cursor(int from, int to)
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];