Merge branch 'lukas/erts/poll-thread/OTP-14346'

* lukas/erts/poll-thread/OTP-14346: (25 commits)
  erts: Trigger ready events when erts_io_control fails
  erts: enif_select steal test
  kernel: Rewrite gen_udp_SUITE:read_packet tc
  erts: disable kernel-poll on OS X vsn < 16
  erts: Fix msacc testcase with new poll-thread
  erts: Add testcases to test IOp and IOt options
  erts: get_internal_state(check_io_debug) now prints to error_logger
  erts: Remove eager check io
  erts: Move all I/O polling to a seperate thread
  erts: Fix smp_select testcase to use ERL_DRV_USE
  erts: Fix msacc unmanaged state counter
  erts: Optimize port_task quick allocator
  erts: Add ERTS_THR_PREF_QUICK_ALLOC_IMPL
  erts: Update suspend of scheduler to handle multiple pollsets
  erts: Add multiple poll sets
  erts: Some code cleanup for gdb to work better
  erts: temp_alloc can no longer be disabled
  erts: Refactor check_io to use one static struct
  erts: Replace check_io spinlock with lock-less list insertion
  erts: Add number of enif_select's to check_io_debug
  ...

10 files changed, 483 insertions, 482 deletions

diff --git a/erts/emulator/test/driver_SUITE.erl b/erts/emulator/test/driver_SUITE.erl
index 5fca191679..33d0b708cf 100644
--- a/erts/emulator/test/driver_SUITE.erl
+++ b/erts/emulator/test/driver_SUITE.erl
@@ -43,9 +43,9 @@
          outputv_errors/1,
          driver_unloaded/1,
          io_ready_exit/1,
+         use_fallback_pollset/0,
          use_fallback_pollset/1,
          bad_fd_in_pollset/1,
-         driver_event/1,
          fd_change/1,
          steal_control/1,
          otp_6602/1,
@@ -58,11 +58,9 @@
          ioq_exit_ready_output/1,
          ioq_exit_timeout/1,
          ioq_exit_ready_async/1,
-         ioq_exit_event/1,
          ioq_exit_ready_input_async/1,
          ioq_exit_ready_output_async/1,
          ioq_exit_timeout_async/1,
-         ioq_exit_event_async/1,
          zero_extended_marker_garb_drv/1,
          invalid_extended_marker_drv/1,
          larger_major_vsn_drv/1,
@@ -86,6 +84,8 @@
 
 -export([bin_prefix/2]).
 
+-export([get_check_io_total/1]).   % for z_SUITE.erl
+
 -include_lib("common_test/include/ct.hrl").
 
 
@@ -119,17 +119,26 @@
 -define(heap_binary_size, 64).
 
 init_per_testcase(Case, Config) when is_atom(Case), is_list(Config) ->
-    case catch erts_debug:get_internal_state(available_internal_state) of
-        true -> ok;
-        _ -> erts_debug:set_internal_state(available_internal_state, true)
-    end,
+    CIOD = rpc(Config,
+               fun() ->
+                       case catch erts_debug:get_internal_state(available_internal_state) of
+                           true -> ok;
+                           _ -> erts_debug:set_internal_state(available_internal_state, true)
+                       end,
+                       erts_debug:get_internal_state(check_io_debug)
+               end),
     erlang:display({init_per_testcase, Case}),
-    0 = element(1, erts_debug:get_internal_state(check_io_debug)),
+    0 = element(1, CIOD),
     [{testcase, Case}|Config].
 
-end_per_testcase(Case, _Config) ->
+end_per_testcase(Case, Config) ->
     erlang:display({end_per_testcase, Case}),
-    0 = element(1, erts_debug:get_internal_state(check_io_debug)),
+    CIOD = rpc(Config,
+               fun() ->
+                       get_stable_check_io_info(),
+                       erts_debug:get_internal_state(check_io_debug)
+               end),
+    0 = element(1, CIOD),
     ok.
 
 suite() ->
@@ -137,10 +146,13 @@ suite() ->
      {timetrap, {minutes, 1}}].
 
 all() -> %% Keep a_test first and z_test last...
-    [a_test, outputv_errors, outputv_echo, queue_echo, {group, timer},
-     driver_unloaded, io_ready_exit, use_fallback_pollset,
-     bad_fd_in_pollset, driver_event, fd_change,
-     steal_control, otp_6602, driver_system_info_base_ver,
+    [a_test, outputv_errors, outputv_echo, queue_echo,
+     {group, timer},
+     driver_unloaded, io_ready_exit, otp_6602,
+     {group, polling},
+     {group, poll_thread},
+     {group, poll_set},
+     driver_system_info_base_ver,
      driver_system_info_prev_ver,
      driver_system_info_current_ver, driver_monitor,
      {group, ioq_exit}, zero_extended_marker_garb_drv,
@@ -148,7 +160,6 @@ all() -> %% Keep a_test first and z_test last...
      larger_minor_vsn_drv, smaller_major_vsn_drv,
      smaller_minor_vsn_drv, peek_non_existing_queue,
      otp_6879, caller, many_events, missing_callbacks,
-     smp_select, driver_select_use,
      thread_mseg_alloc_cache_clean,
      otp_9302,
      thr_free_drv,
@@ -161,11 +172,18 @@ groups() ->
     [{timer, [],
       [timer_measure, timer_cancel, timer_delay,
        timer_change]},
+     {poll_thread, [], [{group, polling}]},
+     {poll_set, [], [{group, polling}]},
+     {polling, [],
+      [a_test, use_fallback_pollset,
+       bad_fd_in_pollset, fd_change,
+       steal_control, smp_select,
+       driver_select_use, z_test]},
      {ioq_exit, [],
       [ioq_exit_ready_input, ioq_exit_ready_output,
-       ioq_exit_timeout, ioq_exit_ready_async, ioq_exit_event,
+       ioq_exit_timeout, ioq_exit_ready_async,
        ioq_exit_ready_input_async, ioq_exit_ready_output_async,
-       ioq_exit_timeout_async, ioq_exit_event_async]}].
+       ioq_exit_timeout_async]}].
 
 init_per_suite(Config) ->
     Config.
@@ -173,10 +191,28 @@ init_per_suite(Config) ->
 end_per_suite(_Config) ->
     catch erts_debug:set_internal_state(available_internal_state, false).
 
+init_per_group(poll_thread, Config) ->
+    [{node_args, "+IOt 2"} | Config];
+init_per_group(poll_set, Config) ->
+    [{node_args, "+IOt 2 +IOp 2"} | Config];
+init_per_group(polling, Config) ->
+    case proplists:get_value(node_args, Config) of
+        undefined ->
+            Config;
+        Args ->
+            {ok, Node} = start_node(polling, Args),
+            [{node, Node} | Config]
+    end;
 init_per_group(_GroupName, Config) ->
     Config.
 
 end_per_group(_GroupName, Config) ->
+    case proplists:get_value(node, Config) of
+        undefined ->
+            ok;
+        Node ->
+            stop_node(Node)
+    end,
     Config.
 
 %% Test sending bad types to port with an outputv-capable driver.
@@ -778,21 +814,23 @@ io_ready_exit(Config) when is_list(Config) ->
 -define(CHKIO_STOP, 0).
 -define(CHKIO_USE_FALLBACK_POLLSET, 1).
 -define(CHKIO_BAD_FD_IN_POLLSET, 2).
--define(CHKIO_DRIVER_EVENT, 3).
 -define(CHKIO_FD_CHANGE, 4).
 -define(CHKIO_STEAL, 5).
 -define(CHKIO_STEAL_AUX, 6).
 -define(CHKIO_SMP_SELECT, 7).
 -define(CHKIO_DRV_USE, 8).
 
+use_fallback_pollset() ->
+    [{timetrap, {minutes, 2}}].
+
 use_fallback_pollset(Config) when is_list(Config) ->
+    rpc(Config, fun() -> use_fallback_pollset_t(Config) end).
+
+use_fallback_pollset_t(Config) when is_list(Config) ->
     FlbkFun = fun () ->
-                      ChkIoDuring = erlang:system_info(check_io),
-                      case lists:keysearch(fallback_poll_set_size,
-                                           1,
-                                           ChkIoDuring) of
-                          {value,
-                           {fallback_poll_set_size, N}} when N > 0 ->
+                      {Flbk, _} = get_fallback(erlang:system_info(check_io)),
+                      case lists:keysearch(total_poll_set_size, 1, Flbk) of
+                          {value, {total_poll_set_size, N}} when N > 0 ->
                               ok;
                           Error ->
                               ct:fail({failed_to_use_fallback, Error})
@@ -814,6 +852,7 @@ use_fallback_pollset(Config) when is_list(Config) ->
           Skip ->
               {fun () -> ok end, Skip, ok}
       end,
+    io:format("Node = ~p~n",[node()]),
     case chkio_test_fini(chkio_test(Handel,
                                     ?CHKIO_USE_FALLBACK_POLLSET,
                                     fun () ->
@@ -825,27 +864,31 @@ use_fallback_pollset(Config) when is_list(Config) ->
     end.
 
 bad_fd_in_pollset(Config) when is_list(Config) ->
-    chkio_test_fini(chkio_test(chkio_test_init(Config),
-                               ?CHKIO_BAD_FD_IN_POLLSET,
-                               fun () -> sleep(1000) end)).
-
-driver_event(Config) when is_list(Config) ->
-    chkio_test_fini(chkio_test(chkio_test_init(Config),
-                               ?CHKIO_DRIVER_EVENT,
-                               fun () -> sleep(1000) end)).
+    rpc(Config,
+        fun() ->
+                chkio_test_fini(chkio_test(chkio_test_init(Config),
+                                           ?CHKIO_BAD_FD_IN_POLLSET,
+                                           fun () -> sleep(1000) end))
+        end).
 
 fd_change(Config) when is_list(Config) ->
-    chkio_test_fini(chkio_test(chkio_test_init(Config),
-                               ?CHKIO_FD_CHANGE,
-                               fun () -> sleep(1000) end)).
+    rpc(Config,
+        fun() ->
+                chkio_test_fini(chkio_test(chkio_test_init(Config),
+                                           ?CHKIO_FD_CHANGE,
+                                           fun () -> sleep(1000) end))
+        end).
 
 steal_control(Config) when is_list(Config) ->
-    chkio_test_fini(case chkio_test_init(Config) of
-                        {erts_poll_info, _} = Hndl ->
-                            steal_control_test(Hndl);
-                        Skip ->
-                            Skip
-                    end).
+    rpc(Config,
+        fun() ->
+                chkio_test_fini(case chkio_test_init(Config) of
+                                    {erts_poll_info, _} = Hndl ->
+                                        steal_control_test(Hndl);
+                                    Skip ->
+                                        Skip
+                                end)
+        end).
 
 steal_control_test(Hndl = {erts_poll_info, Before}) ->
     Port = open_chkio_port(),
@@ -887,7 +930,7 @@ chkio_test_init(Config) when is_list(Config) ->
     ChkIo = get_stable_check_io_info(),
     case catch lists:keysearch(name, 1, ChkIo) of
         {value, {name, erts_poll}} ->
-            io:format("Before test: ~p~n", [ChkIo]),
+            ct:log("Before test: ~p~n", [ChkIo]),
             Path = proplists:get_value(data_dir, Config),
             erl_ddll:start(),
             ok = load_driver(Path, 'chkio_drv'),
@@ -948,8 +991,9 @@ chkio_test({erts_poll_info, Before},
         "ok" ->
             chk_chkio_port(Port),
             Fun(),
-            During = erlang:system_info(check_io),
+            During = get_check_io_total(erlang:system_info(check_io)),
             erlang:display(During),
+
             0 = element(1, erts_debug:get_internal_state(check_io_debug)),
             io:format("During test: ~p~n", [During]),
             chk_chkio_port(Port),
@@ -1001,22 +1045,83 @@ verify_chkio_state(Before, After) ->
     ok.
 
 get_stable_check_io_info() ->
-    ChkIo = erlang:system_info(check_io),
-    PendUpdNo = case lists:keysearch(pending_updates, 1, ChkIo) of
-                    {value, {pending_updates, PendNo}} ->
-                        PendNo;
-                    false ->
-                        0
-                end,
-    {value, {active_fds, ActFds}} = lists:keysearch(active_fds, 1, ChkIo),
+    get_stable_check_io_info(10).
+get_stable_check_io_info(0) ->
+    get_check_io_total(erlang:system_info(check_io));
+get_stable_check_io_info(N) ->
+    ChkIo = get_check_io_total(erlang:system_info(check_io)),
+    PendUpdNo = proplists:get_value(pending_updates, ChkIo, 0),
+    ActFds = proplists:get_value(active_fds, ChkIo),
     case {PendUpdNo, ActFds} of
         {0, 0} ->
             ChkIo;
         _ ->
-            receive after 10 -> ok end,
-            get_stable_check_io_info()
+            receive after 100 -> ok end,
+            get_stable_check_io_info(N-1)
     end.
 
+%% Merge return from erlang:system_info(check_io)
+%% as if it was one big pollset.
+get_check_io_total(ChkIo) ->
+    ct:log("ChkIo = ~p~n",[ChkIo]),
+    {Fallback, Rest} = get_fallback(ChkIo),
+    add_fallback_infos(Fallback,
+      lists:foldl(fun(Pollset, Acc) ->
+                          lists:zipwith(fun(A, B) ->
+                                                add_pollset_infos(A,B)
+                                        end,
+                                        Pollset, Acc)
+                  end,
+                  hd(Rest), tl(Rest))).
+
+add_pollset_infos({Tag, A}=TA , {Tag, B}=TB) ->
+    case tag_type(Tag) of
+        sum ->
+            {Tag, A + B};
+        const ->
+            case A of
+                B -> TA;
+                _ ->
+                    ct:fail("Unexpected diff in pollsets ~p != ~p",
+                            [TA,TB])
+            end
+    end.
+
+get_fallback([MaybeFallback | ChkIo] = AllChkIo) ->
+    case proplists:get_value(fallback, MaybeFallback) of
+        true ->
+            {MaybeFallback, ChkIo};
+        false ->
+            {undefined, AllChkIo}
+    end.
+
+add_fallback_infos(undefined, Acc) ->
+    Acc;
+add_fallback_infos(Flbk, Acc) ->
+    lists:zipwith(fun({Tag, A}=TA, {Tag, B}=TB) ->
+                          case tag_type(Tag) of
+                              sum -> {Tag, A + B};
+                              const when Tag =:= fallback -> TA;
+                              const -> TB
+                          end
+                  end,
+                  Flbk, Acc).
+
+tag_type(name) -> const;
+tag_type(primary) -> const;
+tag_type(fallback) -> const;
+tag_type(kernel_poll) -> const;
+tag_type(memory_size) -> sum;
+tag_type(total_poll_set_size) -> sum;
+tag_type(lazy_updates) -> const;
+tag_type(pending_updates) -> sum;
+tag_type(batch_updates) -> const;
+tag_type(concurrent_updates) -> const;
+tag_type(max_fds) -> const;
+tag_type(active_fds) -> sum;
+tag_type(poll_threads) -> sum.
+
+
 %% Missed port lock when stealing control of fd from a
 %% driver that didn't use the same lock. The lock checker
 %% used to trigger on this and dump core.
@@ -1336,11 +1441,9 @@ driver_monitor(Config) when is_list(Config) ->
 -define(IOQ_EXIT_READY_OUTPUT, 2).
 -define(IOQ_EXIT_TIMEOUT, 3).
 -define(IOQ_EXIT_READY_ASYNC, 4).
--define(IOQ_EXIT_EVENT, 5).
 -define(IOQ_EXIT_READY_INPUT_ASYNC, 6).
 -define(IOQ_EXIT_READY_OUTPUT_ASYNC, 7).
 -define(IOQ_EXIT_TIMEOUT_ASYNC, 8).
--define(IOQ_EXIT_EVENT_ASYNC, 9).
 
 ioq_exit_test(Config, TestNo) ->
     Drv = ioq_exit_drv,
@@ -1393,9 +1496,6 @@ ioq_exit_timeout(Config) when is_list(Config) ->
 ioq_exit_ready_async(Config) when is_list(Config) ->
     ioq_exit_test(Config, ?IOQ_EXIT_READY_ASYNC).
 
-ioq_exit_event(Config) when is_list(Config) ->
-    ioq_exit_test(Config, ?IOQ_EXIT_EVENT).
-
 ioq_exit_ready_input_async(Config) when is_list(Config) ->
     ioq_exit_test(Config, ?IOQ_EXIT_READY_INPUT_ASYNC).
 
@@ -1405,9 +1505,6 @@ ioq_exit_ready_output_async(Config) when is_list(Config) ->
 ioq_exit_timeout_async(Config) when is_list(Config) ->
     ioq_exit_test(Config, ?IOQ_EXIT_TIMEOUT_ASYNC).
 
-ioq_exit_event_async(Config) when is_list(Config) ->
-    ioq_exit_test(Config, ?IOQ_EXIT_EVENT_ASYNC).
-
 
 vsn_mismatch_test(Config, LoadResult) ->
     Path = proplists:get_value(data_dir, Config),
@@ -1641,7 +1738,7 @@ missing_callbacks(Config) when is_list(Config) ->
 smp_select(Config) when is_list(Config) -> 
     case os:type() of
         {win32,_} -> {skipped, "Test not implemented for this OS"};
-        _ -> smp_select0(Config)
+        _ -> rpc(Config, fun() -> smp_select0(Config) end)
     end.
 
 smp_select0(Config) ->
@@ -1697,7 +1794,7 @@ smp_select_wait(Pids, TimeoutMsg) ->
 driver_select_use(Config) when is_list(Config) -> 
     case os:type() of
         {win32,_} -> {skipped, "Test not implemented for this OS"};
-        _ -> driver_select_use0(Config)
+        _ -> rpc(Config, fun() -> driver_select_use0(Config) end)
     end.
 
 driver_select_use0(Config) ->
@@ -2264,10 +2361,10 @@ count_proc_sched(Ps, PNs) ->
     end.
 
 a_test(Config) when is_list(Config) ->
-    check_io_debug().
+    rpc(Config, fun check_io_debug/0).
 
 z_test(Config) when is_list(Config) ->
-    check_io_debug().
+    rpc(Config, fun check_io_debug/0).
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% 		Utilities
@@ -2275,8 +2372,8 @@ z_test(Config) when is_list(Config) ->
 
 check_io_debug() ->
     get_stable_check_io_info(),
-    {NoErrorFds, NoUsedFds, NoDrvSelStructs, NoDrvEvStructs} = CheckIoDebug
-    = erts_debug:get_internal_state(check_io_debug),
+    {NoErrorFds, NoUsedFds, NoDrvSelStructs, NoEnifSelStructs}
+        = CheckIoDebug = erts_debug:get_internal_state(check_io_debug),
     HasGetHost = has_gethost(),
     ct:log("check_io_debug: ~p~n"
            "HasGetHost: ~p",[CheckIoDebug, HasGetHost]),
@@ -2289,7 +2386,7 @@ check_io_debug() ->
             %% one extra used fd that is not selected on
             ok
     end,
-    0 = NoDrvEvStructs,
+    0 = NoEnifSelStructs,
     ok.
 
 has_gethost() ->
@@ -2459,15 +2556,19 @@ sleep(Ms) when is_integer(Ms), Ms >= 0 ->
 
 
 start_node(Config) when is_list(Config) ->
+    start_node(proplists:get_value(testcase, Config));
+start_node(Name) ->
+    start_node(Name, "").
+start_node(NodeName, Args) ->
     Pa = filename:dirname(code:which(?MODULE)),
     Name = list_to_atom(atom_to_list(?MODULE)
                         ++ "-"
-                        ++ atom_to_list(proplists:get_value(testcase, Config))
+                        ++ atom_to_list(NodeName)
                         ++ "-"
                         ++ integer_to_list(erlang:system_time(second))
                         ++ "-"
                         ++ integer_to_list(erlang:unique_integer([positive]))),
-    test_server:start_node(Name, slave, [{args, "-pa "++Pa}]).
+    test_server:start_node(Name, slave, [{args, Args ++ " -pa "++Pa}]).
 
 stop_node(Node) ->
     test_server:stop_node(Node).
@@ -2500,3 +2601,35 @@ driver_alloc_size() ->
                       Sz0+Sz
               end, 0, CS)
     end.
+
+rpc(Config, Fun) ->
+    case proplists:get_value(node, Config) of
+        undefined ->
+            Fun();
+        Node ->
+            Self = self(),
+            Ref = make_ref(),
+            Pid = spawn(Node,
+                        fun() ->
+                                Result
+                                    = try Fun() of
+                                          Res -> Res
+                                      catch E:R ->
+                                              {'EXIT',E,R,erlang:get_stacktrace()}
+                                      end,
+                                Self ! {Ref, Result}
+                        end),
+            MRef = monitor(process, Pid),
+            receive
+                {'DOWN', MRef, _Type, _Object, Info} ->
+                    erlang:error({died, Pid, Info});
+                {Ref, {'EXIT',E,R,ST}} ->
+                    erlang:demonitor(MRef, [flush]),
+                    erlang:raise(E,R,ST);
+                {Ref, Ret} ->
+                    erlang:demonitor(MRef, [flush]),
+                    Ret;
+                Other ->
+                    ct:fail(Other)
+            end
+    end.
diff --git a/erts/emulator/test/driver_SUITE_data/chkio_drv.c b/erts/emulator/test/driver_SUITE_data/chkio_drv.c
index 8e5e81665c..d548c4b1dc 100644
--- a/erts/emulator/test/driver_SUITE_data/chkio_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/chkio_drv.c
@@ -42,7 +42,6 @@
 #define CHKIO_STOP				0
 #define CHKIO_USE_FALLBACK_POLLSET		1
 #define CHKIO_BAD_FD_IN_POLLSET			2
-#define CHKIO_DRIVER_EVENT			3
 #define CHKIO_FD_CHANGE				4
 #define CHKIO_STEAL				5
 #define CHKIO_STEAL_AUX				6
@@ -67,15 +66,6 @@ typedef struct {
 } ChkioFallbackData;
 
 typedef struct {
-    int in_fd;
-    struct erl_drv_event_data in_data;
-    int in_ok;
-    int out_fd;
-    struct erl_drv_event_data out_data;
-    int out_ok;
-} ChkioDriverEvent;
-
-typedef struct {
     int fds[2];
     int same_fd;
 } ChkioFdChange;
@@ -86,14 +76,10 @@ typedef struct {
 
 typedef struct {
     int driver_select_fds[2];
-    int driver_event_fds[2];
-    struct erl_drv_event_data event_data[2];
 } ChkioSteal;
 
 typedef struct {
     int driver_select_fds[2];
-    int driver_event_fds[2];
-    struct erl_drv_event_data event_data[2];
 } ChkioStealAux;
 
 
@@ -141,7 +127,6 @@ static ErlDrvData chkio_drv_start(ErlDrvPort, char *);
 static void chkio_drv_stop(ErlDrvData);
 static void chkio_drv_ready_input(ErlDrvData, ErlDrvEvent);
 static void chkio_drv_ready_output(ErlDrvData, ErlDrvEvent);
-static void chkio_drv_ready_event(ErlDrvData, ErlDrvEvent, ErlDrvEventData);
 static ErlDrvSSizeT chkio_drv_control(ErlDrvData, unsigned int,
 				      char *, ErlDrvSizeT, char **, ErlDrvSizeT);
 static void chkio_drv_timeout(ErlDrvData);
@@ -164,7 +149,7 @@ static ErlDrvEntry chkio_drv_entry = {
     NULL, /* ready_async */
     NULL, /* flush */
     NULL, /* call */
-    chkio_drv_ready_event,
+    NULL, /* unused_event_callback */
 
     ERL_DRV_EXTENDED_MARKER,
     ERL_DRV_EXTENDED_MAJOR_VERSION,
@@ -243,25 +228,6 @@ stop_use_fallback_pollset(ChkioDrvData *cddp)
 }
 
 static void
-stop_driver_event(ChkioDrvData *cddp)
-{
-    if (cddp->test_data) {
-	ChkioDriverEvent *cdep = cddp->test_data;
-	cddp->test_data = NULL;
-
-	if (cdep->in_fd >= 0) {
-	    driver_event(cddp->port, (ErlDrvEvent) (ErlDrvSInt) cdep->in_fd, NULL);
-	    close(cdep->in_fd);
-	}
-	if (cdep->out_fd >= 0) {
-	    driver_event(cddp->port, (ErlDrvEvent) (ErlDrvSInt) cdep->out_fd, NULL);
-	    close(cdep->out_fd);
-	}
-	driver_free(cdep);	    
-    }
-}
-
-static void
 stop_fd_change(ChkioDrvData *cddp)
 {
     if (cddp->test_data) {
@@ -305,14 +271,6 @@ stop_steal(ChkioDrvData *cddp)
 			  (ErlDrvEvent) (ErlDrvSInt) csp->driver_select_fds[1],
 			  DO_WRITE,
 			  0);
-	if (csp->driver_event_fds[0] >= 0)
-	    driver_event(cddp->port,
-			 (ErlDrvEvent) (ErlDrvSInt) csp->driver_event_fds[0],
-			 NULL);
-	if (csp->driver_event_fds[1] >= 0)
-	    driver_event(cddp->port,
-			 (ErlDrvEvent) (ErlDrvSInt) csp->driver_event_fds[1],
-			 NULL);
 	driver_free(csp);
     }
 }
@@ -327,10 +285,6 @@ stop_steal_aux(ChkioDrvData *cddp)
 	    close(csap->driver_select_fds[0]);
 	if (csap->driver_select_fds[1] >= 0)
 	    close(csap->driver_select_fds[1]);
-	if (csap->driver_event_fds[0] >= 0)
-	    close(csap->driver_event_fds[0]);
-	if (csap->driver_event_fds[1] >= 0)
-	    close(csap->driver_event_fds[1]);
 	driver_free(csap);
     }
 }
@@ -354,10 +308,13 @@ static void free_smp_select(ChkioSmpSelect* pip, ErlDrvPort port)
 	abort();
     }
     case Selected:
-	driver_select(port, (ErlDrvEvent)(ErlDrvSInt)pip->read_fd, DO_READ, 0);
-	/*fall through*/ 
     case Opened:
-	close(pip->read_fd);
+        TRACEF(("%T: Close pipe [%d->%d]\n", driver_mk_port(port), pip->write_fd,
+                pip->read_fd));
+        if (pip->wasSelected)
+            driver_select(port, (ErlDrvEvent)(ErlDrvSInt)pip->read_fd, DO_READ|ERL_DRV_USE, 0);
+        else
+            close(pip->read_fd);
 	close(pip->write_fd);
 	pip->state = Closed;
 	break;
@@ -445,9 +402,6 @@ chkio_drv_stop(ErlDrvData drv_data) {
     case CHKIO_BAD_FD_IN_POLLSET:
 	stop_bad_fd_in_pollset(cddp);
 	break;
-    case CHKIO_DRIVER_EVENT:
-	stop_driver_event(cddp);
-	break;
     case CHKIO_FD_CHANGE:
 	stop_fd_change(cddp);
 	break;
@@ -557,6 +511,9 @@ chkio_drv_ready_input(ErlDrvData drv_data, ErlDrvEvent event)
 	    driver_failure_atom(cddp->port, "input_fd_not_found");
 	break;
     }
+    case CHKIO_FD_CHANGE:
+        /* This may be triggered when an fd is closed while being selected on. */
+        break;
     case CHKIO_STEAL:
 	break;
     case CHKIO_STEAL_AUX:
@@ -621,55 +578,6 @@ chkio_drv_ready_input(ErlDrvData drv_data, ErlDrvEvent event)
 }
 
 static void
-chkio_drv_ready_event(ErlDrvData drv_data,
-		      ErlDrvEvent event,
-		      ErlDrvEventData event_data)
-{
-#ifdef UNIX
-    ChkioDrvData *cddp = (ChkioDrvData *) drv_data;
-    switch (cddp->test) {
-    case CHKIO_DRIVER_EVENT: {
-#ifdef HAVE_POLL_H
-	ChkioDriverEvent *cdep = cddp->test_data;
-	int fd = (int) (ErlDrvSInt) event;
-	if (fd == cdep->in_fd) {
-	    if (event_data->events == POLLIN
-		&& event_data->revents == POLLIN) {
-		cdep->in_ok++;
-	    }
-	    else {
-		driver_failure_atom(cddp->port, "invalid_input_fd_events");
-	    }
-	    break;
-	}
-	if (fd == cdep->out_fd) {
-	    if (event_data->events == POLLOUT
-		&& event_data->revents == POLLOUT) {
-		cdep->out_ok++;
-	    }
-	    else {
-		driver_failure_atom(cddp->port, "invalid_output_fd_events");
-	    }
-	    break;
-	}
-#endif
-    }
-    case CHKIO_STEAL:
-#ifdef HAVE_POLL_H
-	break;
-#endif
-    case CHKIO_STEAL_AUX:
-#ifdef HAVE_POLL_H
-	break;
-#endif
-    default:
-	driver_failure_atom(cddp->port, "unexpected_ready_event");
-	break;
-    }
-#endif /* UNIX */
-}
-
-static void
 chkio_drv_timeout(ErlDrvData drv_data)
 {
 #ifdef UNIX
@@ -779,25 +687,6 @@ chkio_drv_control(ErlDrvData drv_data,
 	    res_len = -1;
 	    stop_bad_fd_in_pollset(cddp);
 	    break;
-	case CHKIO_DRIVER_EVENT: {
-	    ChkioDriverEvent *cdep = cddp->test_data;
-	    if (!cdep->in_ok || !cdep->out_ok) {
-		if (!cdep->in_ok)
-		    driver_failure_atom(cddp->port, "got_no_input_events");
-		if (!cdep->out_ok)
-		    driver_failure_atom(cddp->port, "got_no_output_events");
-	    }
-	    else {
-		char *c = driver_alloc(sizeof(char)*2*30);
-		if (!c)
-		    driver_failure_posix(cddp->port, ENOMEM);
-		*rbuf = c;
-		res_len = sprintf(c, "in=%d\nout=%d\n",
-				  cdep->in_ok, cdep->out_ok);
-	    }
-	    stop_driver_event(cddp);
-	    break;
-	}
 	case CHKIO_FD_CHANGE: {
 	    ChkioFdChange *cfcp = cddp->test_data;
 	    if (!cfcp->same_fd)
@@ -937,69 +826,6 @@ chkio_drv_control(ErlDrvData drv_data,
 	res_len = -1;
 	break;
     }
-    case CHKIO_DRIVER_EVENT: {
-#ifndef HAVE_POLL_H
-	res_str = "skip: Need the poll.h header for this test, but it doesn't exist";
-	res_len = -1;
-#else /* HAVE_POLL_H */
-	int in_fd = open("/dev/zero", O_RDONLY);
-	int out_fd = open("/dev/null", O_WRONLY);
-
-	if (in_fd < 0 || out_fd < 0) {
-	    if (in_fd >= 0)
-		close(in_fd);
-	    if (out_fd >= 0)
-		close(out_fd);
-	    driver_failure_posix(cddp->port, errno);
-	}
-	else {
-	    ChkioDriverEvent *cdep = driver_alloc(sizeof(ChkioDriverEvent));
-	    if (!cdep)
-		driver_failure_posix(cddp->port, ENOMEM);
-	    else {
-		int res;
-		cddp->test_data = cdep;
-
-		cdep->in_fd = in_fd;
-		cdep->in_data.events = POLLIN;
-		cdep->in_data.revents = 0;
-		cdep->in_ok = 0;
-
-		res = driver_event(cddp->port,
-				   (ErlDrvEvent) (ErlDrvSInt) in_fd,
-				   &cdep->in_data);
-		if (res < 0) {
-		    res_str = "skip: driver_event() not supported";
-		    res_len = -1;
-		    close(in_fd);
-		    close(out_fd);
-		    cdep->in_fd = -1;
-		    cdep->out_fd = -1;
-		}
-		else {
-		    res_str = "ok";
-		    res_len = -1;
-
-		    cdep->out_fd = out_fd;
-		    cdep->out_data.events = POLLOUT;
-		    cdep->out_data.revents = 0;
-		    cdep->out_ok = 0;
-
-		    res = driver_event(cddp->port,
-				       (ErlDrvEvent) (ErlDrvSInt) out_fd,
-				       &cdep->out_data);
-		    if (res < 0) {
-			close(out_fd);
-			cdep->out_fd = -1;
-			driver_failure_atom(cddp->port, "driver_event_failed");
-		    }
-		}
-
-	    }
-	}
-#endif /* HAVE_POLL_H */
-	break;
-    }
     case CHKIO_FD_CHANGE: {
 	ChkioFdChange *cfcp = driver_alloc(sizeof(ChkioFdChange));
 	if (!cfcp)
@@ -1028,58 +854,19 @@ chkio_drv_control(ErlDrvData drv_data,
 	    res_len = -1;
 	}
 	else {
-	    int driver_event_fds[2];
 	    int driver_select_fds[2];
 	    cddp->test_data = csp; 
 	    memcpy(c, buf, len);
 	    c[len] = '\0';
 	    if (sscanf(c,
-		       "fds:%d:%d:%d:%d",
+		       "fds:%d:%d",
 		       &driver_select_fds[0],
-		       &driver_select_fds[1],
-		       &driver_event_fds[0],
-		       &driver_event_fds[1]) != 4)
-		driver_failure_atom(cddp->port, "bad_input");
+		       &driver_select_fds[1]) != 2)
+                driver_failure_atom(cddp->port, "bad_input");
 	    else {
 		int res = 0;
-		if (driver_event_fds[0] < 0) { /* Have no working driver_event() ... */
-		    csp->driver_select_fds[0] = driver_select_fds[0]; /* In */
-		    csp->driver_select_fds[1] = driver_select_fds[1]; /* Out */
-		    csp->driver_event_fds[0] = -1;
-		    csp->driver_event_fds[1] = -1;
-		}
-		else { /* Have working driver_event() ... */
-#ifndef HAVE_POLL_H
-		    driver_failure_atom(cddp->port, "unexpected_result");
-		    res = -1;
-#else
-		    csp->driver_select_fds[0] = driver_select_fds[0]; /* In */
-		    csp->driver_event_fds[1] = driver_select_fds[1]; /* Out */
-		    csp->driver_event_fds[0] = driver_event_fds[0]; /* In */
-		    csp->driver_select_fds[1] = driver_event_fds[1]; /* Out */
-
-		    /* Steal with driver_event() */
-
-		    csp->event_data[0].events = POLLIN;
-		    csp->event_data[0].revents = 0;
-		    res = driver_event(cddp->port,
-				       (ErlDrvEvent) (ErlDrvSInt) csp->driver_event_fds[0],
-				       &csp->event_data[0]);
-		    if (res < 0)
-			driver_failure_atom(cddp->port,
-					    "driver_event_failed_to_steal");
-		    if (res >= 0) {
-			csp->event_data[1].events = POLLOUT;
-			csp->event_data[1].revents = 0;
-			res = driver_event(cddp->port,
-					   (ErlDrvEvent) (ErlDrvSInt) csp->driver_event_fds[1],
-					   &csp->event_data[1]);
-			if (res < 0)
-			    driver_failure_atom(cddp->port,
-						"driver_event_failed_to_steal");
-		    }
-#endif
-		}
+                csp->driver_select_fds[0] = driver_select_fds[0]; /* In */
+                csp->driver_select_fds[1] = driver_select_fds[1]; /* Out */
 
 		/* Steal with driver_select() */
 		if (res >= 0) {
@@ -1109,37 +896,17 @@ chkio_drv_control(ErlDrvData drv_data,
 	break;
     }
     case CHKIO_STEAL_AUX: {
-	int read_fds[2];
-	int write_fds[2];
+	int read_fd;
+	int write_fd;
 
-	read_fds[0] = open("/dev/zero", O_RDONLY);
-	write_fds[0] = open("/dev/null", O_WRONLY);
-
-#ifdef HAVE_POLL_H
-	read_fds[1] = open("/dev/zero", O_RDONLY);
-	write_fds[1] = open("/dev/null", O_WRONLY);
-#else
-	read_fds[1] = -1;
-	write_fds[1] = -1;
-#endif
+	read_fd = open("/dev/zero", O_RDONLY);
+	write_fd = open("/dev/null", O_WRONLY);
 	
-	if (read_fds[0] < 0
-	    || write_fds[0] < 0
-#ifdef HAVE_POLL_H
-	    || read_fds[1] < 0 
-	    || write_fds[1] < 0
-#endif
-	    ) {
-	    if (read_fds[0] < 0)
-		close(read_fds[0]);
-	    if (write_fds[0] < 0)
-		close(write_fds[0]);
-#ifdef HAVE_POLL_H
-	    if (read_fds[1] < 0)
-		close(read_fds[1]);
-	    if (write_fds[1] < 0)
-		close(write_fds[1]);
-#endif
+	if (read_fd < 0 || write_fd < 0) {
+	    if (read_fd < 0)
+		close(read_fd);
+	    if (write_fd < 0)
+		close(write_fd);
 	    driver_failure_posix(cddp->port, errno);
 	}
 	else {
@@ -1153,11 +920,8 @@ chkio_drv_control(ErlDrvData drv_data,
 		int res;
 		cddp->test_data = csap;
 
-		csap->driver_select_fds[0] = read_fds[0];
-		csap->driver_select_fds[1] = write_fds[0];
-
-		csap->driver_event_fds[0] = read_fds[1];
-		csap->driver_event_fds[1] = write_fds[1];
+		csap->driver_select_fds[0] = read_fd;
+		csap->driver_select_fds[1] = write_fd;
 
 		res = driver_select(cddp->port,
 				    (ErlDrvEvent) (ErlDrvSInt) csap->driver_select_fds[0],
@@ -1173,32 +937,6 @@ chkio_drv_control(ErlDrvData drv_data,
 		    if (res < 0)
 			driver_failure_atom(cddp->port, "driver_select_failed");
 		}
-#ifdef HAVE_POLL_H
-		if (res >= 0) {
-		    csap->event_data[0].events = POLLIN;
-		    csap->event_data[0].revents = 0;
-		    res = driver_event(cddp->port,
-				       (ErlDrvEvent) (ErlDrvSInt) csap->driver_event_fds[0],
-				       &csap->event_data[0]);
-		    if (res < 0) {
-			close(csap->driver_event_fds[0]);
-			csap->driver_event_fds[0] = -1;
-			close(csap->driver_event_fds[1]);
-			csap->driver_event_fds[1] = -1;
-			res = 0;
-		    }
-		    else {
-			csap->event_data[1].events = POLLOUT;
-			csap->event_data[1].revents = 0;
-			res = driver_event(cddp->port,
-					   (ErlDrvEvent) (ErlDrvSInt) csap->driver_event_fds[1],
-					   &csap->event_data[1]);
-			if (res < 0)
-			    driver_failure_atom(cddp->port,
-						"driver_event_failed");
-		    }
-		}
-#endif
 		if (res < 0) {
 		    res_str = "error";
 		    res_len = -1;
@@ -1213,11 +951,9 @@ chkio_drv_control(ErlDrvData drv_data,
 		    else {
 			*rbuf = c;
 			res_len = sprintf(c,
-					  "fds:%d:%d:%d:%d",
+					  "fds:%d:%d",
 					  csap->driver_select_fds[0],
-					  csap->driver_select_fds[1],
-					  csap->driver_event_fds[0],
-					  csap->driver_event_fds[1]);
+					  csap->driver_select_fds[1]);
 		    }
 		}
 	    }
@@ -1257,7 +993,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		}
 		TRACEF(("%T: Created pipe [%d->%d]\n", cddp->id, fds[1], fds[0]));
 		pip->read_fd = fds[0];
-		pip->write_fd = fds[1];	       
+		pip->write_fd = fds[1];
 		pip->state = Opened;
 		pip->wasSelected = 0;
 		pip->next_write = pip->next_read = rand_r(&pip->rand_state) % 1024;
@@ -1267,7 +1003,8 @@ chkio_drv_control(ErlDrvData drv_data,
 	    }/*fall through*/
 	    case Opened: {
 		if (op & 1) {
-		    TRACEF(("%T: Write %d to opened pipe [%d->%d]\n", cddp->id, pip->next_write, pip->write_fd, pip->read_fd));
+		    TRACEF(("%T: Write %d to opened pipe [%d->%d]\n", cddp->id,
+                            pip->next_write, pip->write_fd, pip->read_fd));
 		    if (write(pip->write_fd, &pip->next_write, sizeof(int)) != sizeof(int)) {
 			fprintf(stderr, "Failed to write to pipe fd=%d, errno=%d\n", pip->write_fd, errno);
 			abort();
@@ -1276,8 +1013,12 @@ chkio_drv_control(ErlDrvData drv_data,
 		}
 		op >>= 1;
 		if (pip->wasSelected && (op & 1)) {
-		    TRACEF(("%T: Close pipe [%d->%d]\n", cddp->id, pip->write_fd, pip->read_fd));
-		    if (close(pip->read_fd) || close(pip->write_fd)) {
+		    TRACEF(("%T: Close pipe [%d->%d]\n", cddp->id, pip->write_fd,
+                            pip->read_fd));
+                    drv_use_singleton.fd_stop_select = -2; /* disable stop_select asserts */
+		    if (driver_select(cddp->port, (ErlDrvEvent)(ErlDrvSInt)pip->read_fd,
+                                      DO_READ|ERL_DRV_USE, 0)
+                        || close(pip->write_fd)) {
 			fprintf(stderr, "Failed to close pipe, errno=%d\n", errno);
 			abort();
 		    }
@@ -1285,8 +1026,10 @@ chkio_drv_control(ErlDrvData drv_data,
 		    break;
 		}
 		else {
-		    TRACEF(("%T: Select on pipe [%d->%d]\n", cddp->id, pip->write_fd, pip->read_fd));
-		    if (driver_select(cddp->port, (ErlDrvEvent)(ErlDrvSInt)pip->read_fd, DO_READ, 1)) {
+		    TRACEF(("%T: Select on pipe [%d->%d]\n", cddp->id,
+                            pip->write_fd, pip->read_fd));
+		    if (driver_select(cddp->port, (ErlDrvEvent)(ErlDrvSInt)pip->read_fd,
+                                      DO_READ|ERL_DRV_USE, 1)) {
 			fprintf(stderr, "driver_select failed for fd=%d\n", pip->read_fd);
 			abort();
 		    }
@@ -1294,13 +1037,13 @@ chkio_drv_control(ErlDrvData drv_data,
 		    pip->wasSelected = 1;
 		    op >>= 1;
 		    if (pip->next_write != pip->next_read) { /* pipe not empty */
-			if (op & 1) {  
+			if (op & 1) {
 			    pip->state = Waiting; /* Wait for reader */
 			    break;
 			}
 			op >>= 1;
 		    }
-		}  
+		}
 	    }/*fall through*/
 	    case Selected:
 		if (op & 1) {
@@ -1329,7 +1072,7 @@ chkio_drv_control(ErlDrvData drv_data,
 			fprintf(stderr, "Failed to write to pipe fd=%d, errno=%d\n", pip->write_fd, errno);
 			abort();
 		    }
-		    pip->next_write++;		    
+		    pip->next_write++;
 		}
 		break;
 	    case Waiting:
@@ -1583,7 +1326,12 @@ static void chkio_drv_stop_select(ErlDrvEvent e, void* null)
     if (!(drv_use_singleton.fd_stop_select < 0)) {
 	assert_print("fd_stop_select<0", __LINE__); abort(); 
     }
-    drv_use_singleton.fd_stop_select = (int)(long)e;
+    /* fd_stop_select counting is disabled if this is set to -2 */
+    if (drv_use_singleton.fd_stop_select == -2) {
+        TRACEF(("closing %d\n", (int)(long)e));
+        close((int)(long)e);
+    } else
+        drv_use_singleton.fd_stop_select = (int)(long)e;
     /* Can't call chkio_drv_use directly here. That could even be recursive.
      * Next timeout will detect it instead.
      */
diff --git a/erts/emulator/test/driver_SUITE_data/ioq_exit_drv.c b/erts/emulator/test/driver_SUITE_data/ioq_exit_drv.c
index d87c2bec93..fa58e9d5ec 100644
--- a/erts/emulator/test/driver_SUITE_data/ioq_exit_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/ioq_exit_drv.c
@@ -25,8 +25,7 @@
  *		- ready_input(),
  *		- ready_output(),
  *		- timeout(),
- *		- driver_async() -> read_async(), and
- *		- event()
+ *		- driver_async() -> read_async()
  */
 
 #ifndef UNIX
@@ -65,11 +64,9 @@ typedef enum {
     IOQ_EXIT_READY_OUTPUT = 2,
     IOQ_EXIT_TIMEOUT = 3,
     IOQ_EXIT_READY_ASYNC = 4,
-    IOQ_EXIT_EVENT = 5,
     IOQ_EXIT_READY_INPUT_ASYNC = 6,
     IOQ_EXIT_READY_OUTPUT_ASYNC = 7,
     IOQ_EXIT_TIMEOUT_ASYNC = 8,
-    IOQ_EXIT_EVENT_ASYNC = 9
 } IOQExitTest;
 
 typedef struct {
@@ -80,9 +77,6 @@ typedef struct {
     int outstanding_async_task;
     long async_task;
     ErlDrvPDL pdl;
-#ifdef HAVE_POLL_H
-    struct erl_drv_event_data event_data;
-#endif
 } IOQExitDrvData;
 
 #define EV2FD(EV) ((int) ((long) (EV)))
@@ -97,8 +91,6 @@ static ErlDrvSSizeT control(ErlDrvData, unsigned int,
 static void timeout(ErlDrvData drv_data);
 static void ready_async(ErlDrvData drv_data, ErlDrvThreadData thread_data);
 static void flush(ErlDrvData drv_data);
-static void event(ErlDrvData drv_data, ErlDrvEvent event,
-		  ErlDrvEventData event_data);
 static void async_invoke(void*);
 static void do_driver_async(IOQExitDrvData *);
 
@@ -118,7 +110,7 @@ static ErlDrvEntry ioq_exit_drv_entry = {
     ready_async,
     flush,
     NULL /* call */,
-    event,
+    NULL /* unused_event_callback*/,
     ERL_DRV_EXTENDED_MARKER,
     ERL_DRV_EXTENDED_MAJOR_VERSION,
     ERL_DRV_EXTENDED_MINOR_VERSION,
@@ -149,10 +141,6 @@ start(ErlDrvPort port, char *command)
     ddp->outstanding_async_task = 0;
     ddp->async_task = -1;
     ddp->pdl = driver_pdl_create(port);
-#ifdef HAVE_POLL_H
-    ddp->event_data.events = (short) 0;
-    ddp->event_data.revents = (short) 0;
-#endif
 
     return (ErlDrvData) ddp;
 }
@@ -192,27 +180,6 @@ static ErlDrvSSizeT control(ErlDrvData drv_data,
 #else
 	goto done;
 #endif
-    case IOQ_EXIT_EVENT:
-    case IOQ_EXIT_EVENT_ASYNC:
-#ifdef UNIX
-#ifdef HAVE_POLL_H
-	ddp->ofd = open("/dev/null", O_WRONLY);
-	if (ddp->ofd < 0) {
-	    driver_failure_posix(ddp->port, errno);
-	    return 0;
-	}
-	else if (driver_event(ddp->port, FD2EV(ddp->ofd), NULL) != 0) {
-	    res_str = "skip: driver_event() not supported";
-	    goto done;
-	}
-#else
-	res_str = "skip: No poll.h found which is needed for this test";
-	goto done;
-#endif
-	break;
-#else /* UNIX */
-	goto done;
-#endif
     case IOQ_EXIT_TIMEOUT:
     case IOQ_EXIT_TIMEOUT_ASYNC:
 	break;
@@ -266,13 +233,6 @@ static void stop(ErlDrvData drv_data)
 		close(ddp->ofd);
 	    }
 	    break;
-	case IOQ_EXIT_EVENT:
-	case IOQ_EXIT_EVENT_ASYNC:
-	    if (ddp->ofd >= 0) {
-		driver_event(ddp->port, FD2EV(ddp->ofd), NULL);
-		close(ddp->ofd);
-	    }
-	    break;
 #endif
 	case IOQ_EXIT_TIMEOUT:
 	case IOQ_EXIT_TIMEOUT_ASYNC:
@@ -302,13 +262,6 @@ static void flush(ErlDrvData drv_data)
     case IOQ_EXIT_READY_OUTPUT_ASYNC:
 	driver_select(ddp->port, FD2EV(ddp->ofd), DO_WRITE, 1);
 	break;
-    case IOQ_EXIT_EVENT:
-    case IOQ_EXIT_EVENT_ASYNC:
-#ifdef HAVE_POLL_H
-	ddp->event_data.events |= POLLOUT;
-	driver_event(ddp->port, FD2EV(ddp->ofd), &ddp->event_data);
-#endif
-	break;
 #endif
     case IOQ_EXIT_TIMEOUT:
     case IOQ_EXIT_TIMEOUT_ASYNC:
@@ -395,30 +348,6 @@ static void ready_async(ErlDrvData drv_data, ErlDrvThreadData thread_data)
     }
 }
 
-static void event(ErlDrvData drv_data,
-		  ErlDrvEvent event,
-		  ErlDrvEventData event_data)
-{
-    IOQExitDrvData *ddp = (IOQExitDrvData *) drv_data;
-
-    PRINTF(("event(%p, %d, %p) called\r\n", drv_data, EV2FD(event), event_data));
-
-#if defined(UNIX) && defined(HAVE_POLL_H)
-    if (ddp->ofd == EV2FD(event)) {
-	driver_event(ddp->port, FD2EV(ddp->ofd), NULL);
-	close(ddp->ofd);
-	ddp->ofd = -1;
-	if (ddp->test == IOQ_EXIT_EVENT_ASYNC)
-	    do_driver_async(ddp);
-	else {
-	    driver_pdl_lock(ddp->pdl);
-	    driver_deq(ddp->port, 1);
-	    driver_pdl_unlock(ddp->pdl);
-	}
-    }
-#endif
-}
-
 static void async_invoke(void *arg)
 {
     PRINTF(("async_invoke(%p) called\r\n", arg));
diff --git a/erts/emulator/test/driver_SUITE_data/missing_callback_drv.c b/erts/emulator/test/driver_SUITE_data/missing_callback_drv.c
index e7480d2e00..14838f0377 100644
--- a/erts/emulator/test/driver_SUITE_data/missing_callback_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/missing_callback_drv.c
@@ -41,10 +41,6 @@
 typedef struct {
     int ofd;
     int ifd;
-    int efd;
-#ifdef HAVE_POLL_H
-    struct erl_drv_event_data edata;
-#endif
 } mcd_data_t;
 
 static ErlDrvData start(ErlDrvPort port, char *command);
@@ -90,7 +86,6 @@ start(ErlDrvPort port, char *command)
 
     mcd->ofd = -1;
     mcd->ifd = -1;
-    mcd->efd = -1;
 
 #ifdef UNIX
 
@@ -105,15 +100,6 @@ start(ErlDrvPort port, char *command)
 	goto error;
     if (driver_select(port, (ErlDrvEvent) (long) mcd->ifd, DO_READ, 1) != 0)
 	goto error;
-
-#ifdef HAVE_POLL_H
-    mcd->efd = open("/dev/null", O_WRONLY);
-    if (mcd->efd < 0)
-	goto error;
-    mcd->edata.events = POLLOUT;
-    mcd->edata.revents = 0;
-    driver_event(port, (ErlDrvEvent) (long) mcd->efd, &mcd->edata);
-#endif
 #endif
 
     driver_set_timer(port, 0);
@@ -135,10 +121,6 @@ stop(ErlDrvData data)
 	    close(mcd->ofd);
 	if (mcd->ifd >= 0)
 	    close(mcd->ifd);
-#ifdef HAVE_POLL_H
-	if (mcd->efd >= 0)
-	    close(mcd->efd);
-#endif
 #endif
 	driver_free(mcd);
     }
diff --git a/erts/emulator/test/lttng_SUITE.erl b/erts/emulator/test/lttng_SUITE.erl
index a012fa1da2..19c3844c40 100644
--- a/erts/emulator/test/lttng_SUITE.erl
+++ b/erts/emulator/test/lttng_SUITE.erl
@@ -81,7 +81,6 @@ end_per_testcase(Case, _Config) ->
 
 %% Not tested yet
 %%   org_erlang_otp:driver_process_exit
-%%   org_erlang_otp:driver_event
 
 %% tracepoints
 %%
@@ -100,7 +99,6 @@ end_per_testcase(Case, _Config) ->
 %%   org_erlang_otp:driver_flush
 %%   org_erlang_otp:driver_stop_select
 %%   org_erlang_otp:driver_timeout
-%%   org_erlang_otp:driver_event
 %%   org_erlang_otp:driver_ready_output
 %%   org_erlang_otp:driver_ready_input
 %%   org_erlang_otp:driver_output
@@ -431,7 +429,6 @@ txt() ->
       "%%   org_erlang_otp:driver_flush\n"
       "%%   org_erlang_otp:driver_stop_select\n"
       "%%   org_erlang_otp:driver_timeout\n"
-      "%%   org_erlang_otp:driver_event\n"
       "%%   org_erlang_otp:driver_ready_output\n"
       "%%   org_erlang_otp:driver_ready_input\n"
       "%%   org_erlang_otp:driver_output\n"
diff --git a/erts/emulator/test/nif_SUITE.erl b/erts/emulator/test/nif_SUITE.erl
index 223bd7d586..bec2291867 100644
--- a/erts/emulator/test/nif_SUITE.erl
+++ b/erts/emulator/test/nif_SUITE.erl
@@ -25,13 +25,14 @@
 %%-define(CHECK(Exp,Got), Exp = Got).
 
 -include_lib("common_test/include/ct.hrl").
+-include_lib("stdlib/include/assert.hrl").
 
 -export([all/0, suite/0, groups/0,
          init_per_group/2, end_per_group/2,
 	 init_per_testcase/2, end_per_testcase/2,
          basic/1, reload_error/1, upgrade/1, heap_frag/1,
          t_on_load/1,
-         select/1,
+         select/1, select_steal/1,
          monitor_process_a/1,
          monitor_process_b/1,
          monitor_process_c/1,
@@ -42,9 +43,9 @@
 	 types/1, many_args/1, binaries/1, get_string/1, get_atom/1,
 	 maps/1,
 	 api_macros/1,
-	 from_array/1, iolist_as_binary/1, resource/1, resource_binary/1, 
+	 from_array/1, iolist_as_binary/1, resource/1, resource_binary/1,
 	 resource_takeover/1,
-	 threading/1, send/1, send2/1, send3/1, send_threaded/1, neg/1, 
+	 threading/1, send/1, send2/1, send3/1, send_threaded/1, neg/1,
 	 is_checks/1,
 	 get_length/1, make_atom/1, make_string/1, reverse_list_test/1,
 	 otp_9828/1,
@@ -79,7 +80,7 @@ all() ->
     [{group, G} || G <- api_groups()]
         ++
     [reload_error, heap_frag, types, many_args,
-     select,
+     select, select_steal,
      {group, monitor},
      monitor_frenzy,
      hipe,
@@ -144,7 +145,8 @@ init_per_testcase(nif_whereis_threaded, Config) ->
         true -> Config;
         false -> {skip, "No thread support"}
     end;
-init_per_testcase(select, Config) ->
+init_per_testcase(Select, Config) when Select =:= select;
+                                       Select =:= select_steal ->
     case os:type() of
         {win32,_} ->
             {skip, "Test not yet implemented for windows"};
@@ -152,6 +154,9 @@ init_per_testcase(select, Config) ->
             Config
     end;
 init_per_testcase(_Case, Config) ->
+    %% Clear any resource dtor data before test starts in case another tc
+    %% left it in a bad state
+    catch last_resource_dtor_call(),
     Config.
 
 end_per_testcase(t_on_load, _Config) ->
@@ -590,7 +595,71 @@ select_3(_Config) ->
     {_,_,2} = last_resource_dtor_call(),
     ok.
 
-check_stop_ret(?ERL_NIF_SELECT_STOP_CALLED) -> ok;    
+%% @doc The stealing child process for the select_steal test. Duplicates given
+%% W/RFds and runs select on them to steal
+select_steal_child_process(Parent, RFd) ->
+    %% Duplicate the resource with the same FD
+    {R2Fd, _R2Ptr} = dupe_resource_nif(RFd),
+    Ref2 = make_ref(),
+
+    %% Try to select from the child pid (steal from parent)
+    ?assertEqual(0, select_nif(R2Fd, ?ERL_NIF_SELECT_READ, R2Fd, null, Ref2)),
+    ?assertEqual([], flush(0)),
+    ?assertEqual(eagain, read_nif(R2Fd, 1)),
+
+    %% Check that now events arrive to this temporary process
+    Parent ! {self(), stage1}, % signal parent to send the <<"stolen1">>
+
+    %% Receive <<"stolen1">> via enif_select
+    ?assertEqual(0, select_nif(R2Fd, ?ERL_NIF_SELECT_READ, R2Fd, null, Ref2)),
+    ?assertMatch([{select, R2Fd, Ref2, ready_input}], flush()),
+    ?assertEqual(<<"stolen1">>, read_nif(R2Fd, 7)),
+
+    clear_select_nif(R2Fd),
+
+    % do not do this here - stop_selecting(R2Fd, R2Rsrc, Ref2),
+    Parent ! {self(), done}.
+
+%% @doc Similar to select/1 test, make a double ended pipe. Then try to steal
+%% the socket, see what happens.
+select_steal(Config) when is_list(Config) ->
+    ensure_lib_loaded(Config),
+
+    Ref = make_ref(),
+    {{RFd, RPtr}, {WFd, WPtr}} = pipe_nif(),
+
+    %% Bind the socket to current pid in enif_select
+    ?assertEqual(0, select_nif(RFd, ?ERL_NIF_SELECT_READ, RFd, null, Ref)),
+    ?assertEqual([], flush(0)),
+
+    %% Spawn a process and do some stealing
+    Parent = self(),
+    Pid = spawn_link(fun() -> select_steal_child_process(Parent, RFd) end),
+
+    %% Signal from the child to send the first message
+    {Pid, stage1} = receive_any(),
+    ?assertEqual(ok, write_nif(WFd, <<"stolen1">>)),
+
+    ?assertMatch([{Pid, done}], flush(1)),  % synchronize with the child
+
+    %% Try to select from the parent pid (steal back)
+    ?assertEqual(0, select_nif(RFd, ?ERL_NIF_SELECT_READ, RFd, Pid, Ref)),
+
+    %% Ensure that no data is hanging and close.
+    %% Rfd is stolen at this point.
+    check_stop_ret(select_nif(WFd, ?ERL_NIF_SELECT_STOP, WFd, null, Ref)),
+    ?assertMatch([{fd_resource_stop, WPtr, _}], flush()),
+    {1, {WPtr, 1}} = last_fd_stop_call(),
+
+    check_stop_ret(select_nif(RFd, ?ERL_NIF_SELECT_STOP, RFd, null, Ref)),
+    ?assertMatch([{fd_resource_stop, RPtr, _}], flush()),
+    {1, {RPtr, 1}} = last_fd_stop_call(),
+
+    ?assert(is_closed_nif(WFd)),
+
+    ok.
+
+check_stop_ret(?ERL_NIF_SELECT_STOP_CALLED) -> ok;
 check_stop_ret(?ERL_NIF_SELECT_STOP_SCHEDULED) -> ok.
 
 write_full(W, C) ->
@@ -3193,10 +3262,12 @@ binary_to_term_nif(_, _, _) -> ?nif_stub.
 port_command_nif(_, _) -> ?nif_stub.
 format_term_nif(_,_) -> ?nif_stub.
 select_nif(_,_,_,_,_) -> ?nif_stub.
+dupe_resource_nif(_) -> ?nif_stub.
 pipe_nif() -> ?nif_stub.
 write_nif(_,_) -> ?nif_stub.
 read_nif(_,_) -> ?nif_stub.
 is_closed_nif(_) -> ?nif_stub.
+clear_select_nif(_) -> ?nif_stub.
 last_fd_stop_call() -> ?nif_stub.
 alloc_monitor_resource_nif() -> ?nif_stub.
 monitor_process_nif(_,_,_,_) -> ?nif_stub.
diff --git a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
index b47d013bd2..79560a38aa 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
+++ b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
@@ -2448,6 +2448,13 @@ static int get_fd(ErlNifEnv* env, ERL_NIF_TERM term, struct fd_resource** rsrc)
     return 1;
 }
 
+/* Returns: badarg
+ *    Or an enif_select result, which is a combination of bits:
+ *    ERL_NIF_SELECT_STOP_CALLED = 1
+ *    ERL_NIF_SELECT_STOP_SCHEDULED = 2
+ *    ERL_NIF_SELECT_INVALID_EVENT = 4
+ *    ERL_NIF_SELECT_FAILED = 8
+ */
 static ERL_NIF_TERM select_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     struct fd_resource* fdr;
@@ -2479,6 +2486,9 @@ static ERL_NIF_TERM select_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv
 }
 
 #ifndef __WIN32__
+/*
+ * Create a read-write pipe with two fds (to read and to write)
+ */
 static ERL_NIF_TERM pipe_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     struct fd_resource* read_rsrc;
@@ -2514,6 +2524,30 @@ static ERL_NIF_TERM pipe_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]
                enif_make_tuple2(env, write_fd, make_pointer(env, write_rsrc)));
 }
 
+/*
+ * Create (dupe) of a resource with the same fd, to test stealing
+ */
+static ERL_NIF_TERM dupe_resource_nif(ErlNifEnv* env, int argc,
+                                      const ERL_NIF_TERM argv[]) {
+    struct fd_resource* orig_rsrc;
+
+    if (!get_fd(env, argv[0], &orig_rsrc)) {
+        return enif_make_badarg(env);
+    } else {
+        struct fd_resource* new_rsrc;
+        ERL_NIF_TERM new_fd;
+
+        new_rsrc = enif_alloc_resource(fd_resource_type,
+                                       sizeof(struct fd_resource));
+        new_rsrc->fd = orig_rsrc->fd;
+        new_rsrc->was_selected = 0;
+        new_fd = enif_make_resource(env, new_rsrc);
+        enif_release_resource(new_rsrc);
+
+        return enif_make_tuple2(env, new_fd, make_pointer(env, new_rsrc));
+    }
+}
+
 static ERL_NIF_TERM write_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     struct fd_resource* fdr;
@@ -2589,6 +2623,20 @@ static ERL_NIF_TERM is_closed_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM a
 
     return fdr->fd < 0 ? atom_true : atom_false;
 }
+
+static ERL_NIF_TERM clear_select_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    struct fd_resource* fdr = NULL;
+
+    if (!get_fd(env, argv[0], &fdr))
+        return enif_make_badarg(env);
+
+    fdr->fd = -1;
+    fdr->was_selected = 0;
+
+    return atom_ok;
+}
+
 #endif /* !__WIN32__ */
 
 
@@ -3476,8 +3524,10 @@ static ErlNifFunc nif_funcs[] =
 #ifndef __WIN32__
     {"pipe_nif", 0, pipe_nif},
     {"write_nif", 2, write_nif},
+    {"dupe_resource_nif", 1, dupe_resource_nif},
     {"read_nif", 2, read_nif},
     {"is_closed_nif", 1, is_closed_nif},
+    {"clear_select_nif", 1, clear_select_nif},
 #endif
     {"last_fd_stop_call", 0, last_fd_stop_call},
     {"alloc_monitor_resource_nif", 0, alloc_monitor_resource_nif},
diff --git a/erts/emulator/test/scheduler_SUITE.erl b/erts/emulator/test/scheduler_SUITE.erl
index 12e26671c2..7afb82a1b8 100644
--- a/erts/emulator/test/scheduler_SUITE.erl
+++ b/erts/emulator/test/scheduler_SUITE.erl
@@ -57,6 +57,7 @@
 	 scheduler_suspend_basic/1,
 	 scheduler_suspend/1,
 	 dirty_scheduler_threads/1,
+         poll_threads/1,
 	 reader_groups/1]).
 
 suite() ->
@@ -72,6 +73,7 @@ all() ->
      {group, scheduler_bind}, scheduler_threads,
      scheduler_suspend_basic, scheduler_suspend,
      dirty_scheduler_threads,
+     poll_threads,
      reader_groups].
 
 groups() -> 
@@ -1446,6 +1448,79 @@ sst5_loop(N) ->
     erlang:system_flag(multi_scheduling, unblock_normal),
     sst5_loop(N-1).
 
+poll_threads(Config) when is_list(Config) ->
+    {Conc, PollType, KP} = get_ioconfig(Config),
+    {Sched, SchedOnln, _} = get_sstate(Config, ""),
+
+    [1, 1] = get_ionum(Config,"+IOt 2 +IOp 2"),
+    [1, 1, 1, 1, 1] = get_ionum(Config,"+IOt 5 +IOp 5"),
+
+    [1, 1] = get_ionum(Config, "+S 2 +IOPt 100 +IOPp 100"),
+
+    if
+        Conc ->
+            [5] = get_ionum(Config,"+IOt 5 +IOp 1"),
+            [3, 2] = get_ionum(Config,"+IOt 5 +IOp 2"),
+            [2, 2, 2, 2, 2] = get_ionum(Config,"+IOt 10 +IOPp 50"),
+
+            [2] = get_ionum(Config, "+S 2 +IOPt 100"),
+            [4] = get_ionum(Config, "+S 4 +IOPt 100"),
+            [4] = get_ionum(Config, "+S 4:2 +IOPt 100"),
+            [4, 4] = get_ionum(Config, "+S 8 +IOPt 100 +IOPp 25"),
+
+            fail = get_ionum(Config, "+IOt 1 +IOp 2"),
+
+            ok;
+        not Conc ->
+            [1, 1, 1, 1, 1] = get_ionum(Config,"+IOt 5 +IOp 1"),
+            [1, 1, 1, 1, 1] = get_ionum(Config,"+IOt 5 +IOp 2"),
+            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] = get_ionum(Config,"+IOt 10 +IOPp 50"),
+
+            [1, 1] = get_ionum(Config, "+S 2 +IOPt 100"),
+            [1, 1, 1, 1] = get_ionum(Config, "+S 4 +IOPt 100"),
+            [1, 1, 1, 1] = get_ionum(Config, "+S 4:2 +IOPt 100"),
+            [1, 1, 1, 1, 1, 1, 1, 1] = get_ionum(Config, "+S 8 +IOPt 100 +IOPp 25"),
+
+            [1] = get_ionum(Config, "+IOt 1 +IOp 2"),
+
+            ok
+    end,
+
+    fail = get_ionum(Config, "+IOt 1 +IOPp 101"),
+    fail = get_ionum(Config, "+IOt 0"),
+    fail = get_ionum(Config, "+IOPt 101"),
+
+    ok.
+
+get_ioconfig(Config) ->
+    [PS | _] = get_iostate(Config, ""),
+    {proplists:get_value(concurrent_updates, PS),
+     proplists:get_value(primary, PS),
+     proplists:get_value(kernel_poll, PS)}.
+
+get_ionum(Config, Cmd) ->
+    case get_iostate(Config, Cmd) of
+        fail -> fail;
+        PSs ->
+            lists:reverse(
+              lists:sort(
+                [proplists:get_value(poll_threads, PS) || PS <- PSs]))
+    end.
+
+get_iostate(Config, Cmd)->
+    case start_node(Config, Cmd) of
+        {ok, Node} ->
+            [IOStates] = mcall(Node,[fun () ->
+                                             erlang:system_info(check_io)
+                                     end]),
+            IO = [IOState || IOState <- IOStates,
+                             proplists:get_value(fallback, IOState) == false],
+            stop_node(Node),
+            IO;
+        {error,timeout} ->
+            fail
+    end.
+
 reader_groups(Config) when is_list(Config) ->
     %% White box testing. These results are correct, but other results
     %% could be too...
@@ -1770,18 +1845,24 @@ mcall(Node, Funs) ->
     Parent = self(),
     Refs = lists:map(fun (Fun) ->
                              Ref = make_ref(),
-                             spawn_link(Node,
-                                        fun () ->
-                                                Res = Fun(),
-                                                unlink(Parent),
-                                                Parent ! {Ref, Res}
-                                        end),
-                             Ref
+                             Pid = spawn(Node,
+                                         fun () ->
+                                                 Res = Fun(),
+                                                 unlink(Parent),
+                                                 Parent ! {Ref, Res}
+                                         end),
+                             MRef = erlang:monitor(process, Pid),
+                             {Ref, MRef}
                      end, Funs),
-    lists:map(fun (Ref) ->
+    lists:map(fun ({Ref, MRef}) ->
                       receive
                           {Ref, Res} ->
-                              Res
+                              receive
+                                  {'DOWN',MRef,_,_,_} ->
+                                      Res
+                              end;
+                          {'DOWN',MRef,_,_,Reason} ->
+                              Reason
                       end
               end, Refs).
 
diff --git a/erts/emulator/test/statistics_SUITE.erl b/erts/emulator/test/statistics_SUITE.erl
index 7a396d273c..029a6de897 100644
--- a/erts/emulator/test/statistics_SUITE.erl
+++ b/erts/emulator/test/statistics_SUITE.erl
@@ -674,6 +674,16 @@ msacc_test(TmpFile) ->
     ets:insert(Tid, {1, hello}),
     ets:delete(Tid),
 
+    %% Check some IO
+    {ok, L} = gen_tcp:listen(0, [{active, true},{reuseaddr,true}]),
+    {ok, Port} = inet:port(L),
+    Pid = spawn(fun() ->
+                        {ok, S} = gen_tcp:accept(L),
+                        (fun F() -> receive M -> F() end end)()
+                end),
+    {ok, C} = gen_tcp:connect("localhost", Port, []),
+    [begin gen_tcp:send(C,"hello"),timer:sleep(1) end || _ <- lists:seq(1,100)],
+
     %% Collect some garbage
     [erlang:garbage_collect() || _ <- lists:seq(1,100)],
 
diff --git a/erts/emulator/test/z_SUITE.erl b/erts/emulator/test/z_SUITE.erl
index feea7432a9..ac3df8bfbf 100644
--- a/erts/emulator/test/z_SUITE.erl
+++ b/erts/emulator/test/z_SUITE.erl
@@ -330,7 +330,7 @@ display_check_io(ChkIo) ->
     ok.
 
 get_check_io_info() ->
-    ChkIo = erlang:system_info(check_io),
+    ChkIo = driver_SUITE:get_check_io_total(erlang:system_info(check_io)),
     PendUpdNo = case lists:keysearch(pending_updates, 1, ChkIo) of
 		    {value, {pending_updates, PendNo}} ->
 			PendNo;