Merge branch 'maint'

Author: lucioleKi

erts/emulator/beam/erl_driver.h

@@ -173,19 +173,22 @@ typedef enum {
 /*
  * Exception code from open_port/2 will be {'EXIT',{einval,Where}}.
  */
-#define ERL_DRV_ERROR_GENERAL ((ErlDrvData) -1)
+#define ERL_DRV_ERROR_GENERAL_INT_ -1
+#define ERL_DRV_ERROR_GENERAL ((ErlDrvData) ERL_DRV_ERROR_GENERAL_INT_)
 
 /*
  * Exception code from open_port/2 will be {'EXIT',{Errno,Where}},
  * where Errno is a textual representation of the errno variable
  * (e.g. eacces if errno is EACCES).
  */
-#define ERL_DRV_ERROR_ERRNO ((ErlDrvData) -2)
+#define ERL_DRV_ERROR_ERRNO_INT_ -2
+#define ERL_DRV_ERROR_ERRNO ((ErlDrvData) ERL_DRV_ERROR_ERRNO_INT_)
 
 /*
  * Exception code from open_port/2 will be {'EXIT',{badarg,Where}}.
  */
-#define ERL_DRV_ERROR_BADARG ((ErlDrvData) -3)
+#define ERL_DRV_ERROR_BADARG_INT_ -3
+#define ERL_DRV_ERROR_BADARG ((ErlDrvData) ERL_DRV_ERROR_BADARG_INT_)
 
 typedef struct erl_io_vec {
     int vsize;			/* length of vectors */

erts/emulator/beam/erl_process.c

@@ -3267,7 +3267,7 @@ aux_thread(void *vix)
                     if (flgs & ERTS_SSI_FLG_SLEEPING) {
                         ASSERT(flgs & ERTS_SSI_FLG_POLL_SLEEPING);
                         ASSERT(flgs & ERTS_SSI_FLG_WAITING);
-                        erts_check_io(ssi->psi, ERTS_POLL_INF_TIMEOUT, 0);
+                        erts_check_io(ssi->psi, ERTS_POLL_INF_TIMEOUT, false);
                     }
                 }
             }
@@ -3369,7 +3369,7 @@ poll_thread(void *vbpt)
 
     while (1) {
         erts_check_io_interrupt(psi, 0);
-        erts_check_io(psi, ERTS_POLL_INF_TIMEOUT, !0);
+        erts_check_io(psi, ERTS_POLL_INF_TIMEOUT, true);
     }
     return NULL;
 }
@@ -3564,7 +3564,7 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
                     if (flgs & ERTS_SSI_FLG_SLEEPING) {
                         ASSERT(flgs & ERTS_SSI_FLG_POLL_SLEEPING);
                         ASSERT(flgs & ERTS_SSI_FLG_WAITING);
-                        erts_check_io(ssi->psi, timeout_time, 0);
+                        erts_check_io(ssi->psi, timeout_time, false);
                         current_time = erts_get_monotonic_time(esdp);
                     }
                 }
@@ -9957,7 +9957,7 @@ Process *erts_schedule(ErtsSchedulerData *esdp, Process *p, int calls)
 
             ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_CHECK_IO);
 
-	    erts_check_io(esdp->ssi->psi, ERTS_POLL_NO_TIMEOUT, 0);
+            erts_check_io(esdp->ssi->psi, ERTS_POLL_NO_TIMEOUT, false);
 	    ERTS_MSACC_POP_STATE_M();
 
 	    current_time = erts_get_monotonic_time(esdp);

erts/emulator/beam/io.c

@@ -2932,16 +2932,16 @@ erl_drv_init_ack(ErlDrvPort ix, ErlDrvData res) {
 
     if (port->async_open_port) {
         switch(err_type) {
-        case -3:
+        case ERL_DRV_ERROR_BADARG_INT_:
             resp = am_badarg;
             break;
-        case -2: {
+        case ERL_DRV_ERROR_ERRNO_INT_: {
             char *str = erl_errno_id(errno);
             resp = erts_atom_put((byte *) str, sys_strlen(str),
                                  ERTS_ATOM_ENC_LATIN1, 1);
             break;
         }
-        case -1:
+        case ERL_DRV_ERROR_GENERAL_INT_:
             resp = am_einval;
             break;
         default:
@@ -2951,7 +2951,9 @@ erl_drv_init_ack(ErlDrvPort ix, ErlDrvData res) {
 
         init_ack_send_reply(port, resp);
 
-        if (err_type == -1 || err_type == -2 || err_type == -3)
+        if (res == ERL_DRV_ERROR_BADARG ||
+            res == ERL_DRV_ERROR_ERRNO ||
+            res == ERL_DRV_ERROR_GENERAL)
             driver_failure_term(ix, am_normal, 0);
         port->drv_data = err_type;
     }

erts/emulator/sys/common/erl_check_io.c

@@ -95,7 +95,7 @@ typedef enum {
     ERTS_EV_FLAG_IN_SCHEDULER  = ERTS_EV_FLAG_CLEAR,
     ERTS_EV_FLAG_NIF_SELECT    = ERTS_EV_FLAG_CLEAR,
 #endif
-#ifdef ERTS_POLL_USE_FALLBACK
+#ifdef ERTS_POLL_USE_FALLBACK /* This has to be an ifdef */
     ERTS_EV_FLAG_FALLBACK      = 0x10,  /* Set when kernel poll rejected fd
                                            and it was put in the nkp version */
 #else
@@ -1930,10 +1930,13 @@ erts_create_pollset_thread(int id, ErtsThrPrgrData *tpd) {
 }
 
 void
-erts_check_io(ErtsPollThread *psi, ErtsMonotonicTime timeout_time, int poll_only_thread)
+erts_check_io(ErtsPollThread *psi, ErtsMonotonicTime timeout_time, bool needs_thread_progress)
 {
     int pollres_len;
     int poll_ret, i;
+#if ERTS_POLL_USE_SCHEDULER_POLLING
+    bool is_scheduler_poll = psi->ps == get_scheduler_pollset();
+#endif
     ERTS_MSACC_PUSH_AND_SET_STATE(ERTS_MSACC_STATE_CHECK_IO);
 
  restart:
@@ -1944,7 +1947,7 @@ erts_check_io(ErtsPollThread *psi, ErtsMonotonicTime timeout_time, int poll_only
 
     pollres_len = psi->pollres_len;
 
-    if (poll_only_thread)
+    if (needs_thread_progress)
         erts_thr_progress_active(psi->tpd, 0);
 
 #if ERTS_POLL_USE_FALLBACK
@@ -1958,7 +1961,7 @@ erts_check_io(ErtsPollThread *psi, ErtsMonotonicTime timeout_time, int poll_only
         poll_ret = erts_poll_wait(psi->ps, psi->pollres, &pollres_len, psi->tpd, timeout_time);
     }
 
-    if (poll_only_thread)
+    if (needs_thread_progress)
         erts_thr_progress_active(psi->tpd, 1);
 
 #ifdef ERTS_ENABLE_LOCK_CHECK
@@ -1982,9 +1985,6 @@ erts_check_io(ErtsPollThread *psi, ErtsMonotonicTime timeout_time, int poll_only
 			  erl_errno_id(poll_ret), poll_ret);
 	    erts_send_error_to_logger_nogl(dsbufp);
 	}
-        // if (is_normal_sched) {
-        //     erts_fprintf(stderr, "%d: woke up\r\n", esdp->no);
-        // }
         ERTS_MSACC_POP_STATE();
 	return;
     }
@@ -2028,13 +2028,18 @@ erts_check_io(ErtsPollThread *psi, ErtsMonotonicTime timeout_time, int poll_only
 
 #if ERTS_POLL_USE_SCHEDULER_POLLING
             if (state->flags & ERTS_EV_FLAG_SCHEDULER) {
-                /* In the poll thread, this fd would have been disabled due to ONESHOT,
-                   but in the scheduler pollset it needs to be disabled manually. */
-                int wake_poller = 0;
-                erts_poll_control(get_scheduler_pollset(), fd, ERTS_POLL_OP_DEL, 0, &wake_poller);
-                state->flags &= ~(ERTS_EV_FLAG_SCHEDULER|ERTS_EV_FLAG_IN_SCHEDULER);
-                state->count = 0;
-                state->last_select_pid = NIL;
+                if (is_scheduler_poll) {
+                    /* If we triggered in a scheduler pollset,
+                       then we should just remove it from the
+                       scheduler pollset. */
+                    int wake_poller = 0;
+                    erts_poll_control(psi->ps, fd, ERTS_POLL_OP_DEL, 0, &wake_poller);
+                    state->flags &= ~(ERTS_EV_FLAG_SCHEDULER|ERTS_EV_FLAG_IN_SCHEDULER);
+                    state->count = 0;
+                    state->last_select_pid = NIL;
+                } else {
+                    state->active_events = revents & ERTS_POLL_EV_IN;
+                }
             }
 #endif
         } else {
@@ -2045,7 +2050,7 @@ erts_check_io(ErtsPollThread *psi, ErtsMonotonicTime timeout_time, int poll_only
             revents &= state->active_events | ERTS_POLL_EV_NVAL;
 
 #if ERTS_POLL_USE_SCHEDULER_POLLING
-            if (psi->ps == get_scheduler_pollset()) {
+            if (is_scheduler_poll) {
                 if (!(state->events & ERTS_POLL_EV_IN) && state->flags & ERTS_EV_FLAG_SCHEDULER) {
                     /* If we triggered in a scheduler pollset and EV_IN is not set,
                        then we should just remove it from the scheduler pollset.
@@ -2176,7 +2181,7 @@ erts_check_io(ErtsPollThread *psi, ErtsMonotonicTime timeout_time, int poll_only
 
         case ERTS_EV_TYPE_STOP_NIF: {
 #if ERTS_POLL_USE_SCHEDULER_POLLING
-            if (psi->ps == get_scheduler_pollset())
+            if (is_scheduler_poll)
                 break;
 #endif
 #if ERTS_POLL_USE_FALLBACK
@@ -2189,7 +2194,7 @@ erts_check_io(ErtsPollThread *psi, ErtsMonotonicTime timeout_time, int poll_only
 
         case ERTS_EV_TYPE_STOP_USE: {
 #if ERTS_POLL_USE_SCHEDULER_POLLING
-            if (psi->ps == get_scheduler_pollset())
+            if (is_scheduler_poll)
                 break;
 #endif
 #if ERTS_POLL_USE_FALLBACK

erts/emulator/sys/common/erl_check_io.h

@@ -87,11 +87,11 @@ int erts_check_io_max_files(void);
  *
  * @param pt the poll thread structure to use.
  * @param timeout_time timeout
- * @param poll_only_thread non zero when poll is the only thing the
- *                         calling thread does
+ * @param needs_thread_progress true when the calling thread needs to have its
+ *              thread progress managed, false otherwise.
  */
 void erts_check_io(struct erts_poll_thread *pt, ErtsMonotonicTime timeout_time,
-                   int poll_only_thread);
+                   bool needs_thread_progress);
 /**
  * Initialize the check io framework. This function will parse the arguments
  * and delete any entries that it is interested in.

erts/emulator/sys/unix/sys_drivers.c

@@ -743,12 +743,15 @@ static ErlDrvSSizeT spawn_control(ErlDrvData e, unsigned int cmd, char *buf,
     dd->status = proto->u.sigchld.error_number;
     dd->alive = -1;
 
-    if (dd->ifd)
-        driver_select(dd->port_num, abs(dd->ifd->fd), ERL_DRV_READ | ERL_DRV_USE, 1);
-
     if (dd->ofd)
         driver_select(dd->port_num, abs(dd->ofd->fd), ERL_DRV_WRITE | ERL_DRV_USE, 1);
 
+    /* We call ready_input directly as not all OSs trigger an input event on an
+       fd that already triggered EOF. For example ONESHOT poll on Linux and FreeBSD will not. */
+    if (dd->ifd) {
+        ready_input(e, abs(dd->ifd->fd));
+    }
+
     return 0;
 }
 
@@ -1230,9 +1233,9 @@ static int port_inp_failure(ErtsSysDriverData *dd, int res)
         if (dd->alive == 1) {
             /*
              * We have eof and want to report exit status, but the process
-             * hasn't exited yet. When it does ready_input will
-             * driver_select() this fd which will make sure that we get
-             * back here with dd->alive == -1 and dd->status set.
+             * hasn't exited yet. When it does spawn_control will call ready_input
+             * which will make sure that we get back here with dd->alive == -1 and
+             * dd->status set.
              */
             return 0;
         }
@@ -1284,7 +1287,6 @@ static void ready_input(ErlDrvData e, ErlDrvEvent ready_fd)
                 return;
             /* hmm, child setup seems to have closed the pipe too early...
                we close the port as there is not much else we can do */
-            driver_select(port_num, ready_fd, ERL_DRV_READ, 0);
             if (res == 0)
                 errno = EPIPE;
             port_inp_failure(dd, -1);