Merge branch 'maint'

* maint:
  Fix tracing of processes executing dirty
  Perform check_process_code while process is executing dirty
  Fix purge of code
  Reclaim literal area after purge has completed
  Separate literal area from code

Conflicts:
	erts/emulator/beam/global.h

7 files changed, 95 insertions, 45 deletions

diff --git a/lib/kernel/doc/src/code.xml b/lib/kernel/doc/src/code.xml
index d3611d6a03..21f8a2d54a 100644
--- a/lib/kernel/doc/src/code.xml
+++ b/lib/kernel/doc/src/code.xml
@@ -651,6 +651,11 @@ ok = code:finish_loading(Prepared),
         <p>Purges the code for <c><anno>Module</anno></c>, that is, removes code
           marked as old. If some processes still linger in the old code,
           these processes are killed before the code is removed.</p>
+	<note><p>As of ERTS version 9.0, a process is only considered
+	to be lingering in the code if it has direct references to the code.
+	For more information see documentation of
+	<seealso marker="erts:erlang#check_process_code/3"><c>erlang:check_process_code/3</c></seealso>,
+	which is used in order to determine this.</p></note>
         <p>Returns <c>true</c> if successful and any process is needed to
           be killed, otherwise <c>false</c>.</p>
       </desc>
@@ -661,6 +666,11 @@ ok = code:finish_loading(Prepared),
       <desc>
         <p>Purges the code for <c><anno>Module</anno></c>, that is, removes code
           marked as old, but only if no processes linger in it.</p>
+	<note><p>As of ERTS version 9.0, a process is only considered
+	to be lingering in the code if it has direct references to the code.
+	For more information see documentation of
+	<seealso marker="erts:erlang#check_process_code/3"><c>erlang:check_process_code/3</c></seealso>,
+	which is used in order to determine this.</p></note>
         <p>Returns <c>false</c> if the module cannot be purged because
           of processes lingering in old code, otherwise <c>true</c>.</p>
       </desc>
diff --git a/lib/kernel/test/init_SUITE.erl b/lib/kernel/test/init_SUITE.erl
index 1370e23195..2b59eb2bfe 100644
--- a/lib/kernel/test/init_SUITE.erl
+++ b/lib/kernel/test/init_SUITE.erl
@@ -27,7 +27,8 @@
 -export([get_arguments/1, get_argument/1, boot_var/1, restart/1,
 	 many_restarts/0, many_restarts/1,
 	 get_plain_arguments/1,
-	 reboot/1, stop_status/1, stop/1, get_status/1, script_id/1]).
+	 reboot/1, stop_status/1, stop/1, get_status/1, script_id/1,
+	 find_system_processes/0]).
 -export([boot1/1, boot2/1]).
 
 -export([init_per_testcase/2, end_per_testcase/2]).
@@ -355,12 +356,16 @@ wait_for(N,Node,EHPid) ->
 restart(Config) when is_list(Config) ->
     Args = args(),
 
+    Pa = " -pa " ++ filename:dirname(code:which(?MODULE)),
+
     %% Currently test_server:start_node cannot be used. The restarted
     %% node immediately halts due to the implementation of
     %% test_server:start_node.
-    {ok, Node} = loose_node:start(init_test, Args, ?DEFAULT_TIMEOUT_SEC),
+    {ok, Node} = loose_node:start(init_test, Args ++ Pa, ?DEFAULT_TIMEOUT_SEC),
     %% Ok, the node is up, now the real test test begins.
     erlang:monitor_node(Node, true),
+    SysProcs0 = rpc:call(Node, ?MODULE, find_system_processes, []),
+    [InitPid, PurgerPid, LitCollectorPid, DirtyCodePid] = SysProcs0,
     InitPid = rpc:call(Node, erlang, whereis, [init]),
     PurgerPid = rpc:call(Node, erlang, whereis, [erts_code_purger]),
     Procs = rpc:call(Node, erlang, processes, []),
@@ -375,6 +380,9 @@ restart(Config) when is_list(Config) ->
     end,
     ok = wait_restart(30, Node),
 
+    SysProcs1 = rpc:call(Node, ?MODULE, find_system_processes, []),
+    [InitPid1, PurgerPid1, LitCollectorPid1, DirtyCodePid1] = SysProcs1,
+
     %% Still the same init process!
     InitPid1 = rpc:call(Node, erlang, whereis, [init]),
     InitP = pid_to_list(InitPid),
@@ -385,8 +393,24 @@ restart(Config) when is_list(Config) ->
     PurgerP = pid_to_list(PurgerPid),
     PurgerP = pid_to_list(PurgerPid1),
 
+    %% and same literal area collector process!
+    case LitCollectorPid of
+	undefined -> undefined = LitCollectorPid1;
+	_ ->
+	    LitCollectorP = pid_to_list(LitCollectorPid),
+	    LitCollectorP = pid_to_list(LitCollectorPid1)
+    end,
+
+    %% and same dirty process code checker process!
+    case DirtyCodePid of
+	undefined -> undefined = DirtyCodePid1;
+	_ ->
+	    DirtyCodeP = pid_to_list(DirtyCodePid),
+	    DirtyCodeP = pid_to_list(DirtyCodePid1)
+    end,
+
     NewProcs0 = rpc:call(Node, erlang, processes, []),
-    NewProcs = NewProcs0 -- [InitPid1, PurgerPid1],
+    NewProcs = NewProcs0 -- SysProcs1,
     case check_processes(NewProcs, MaxPid) of
 	true ->
 	    ok;
@@ -406,6 +430,37 @@ restart(Config) when is_list(Config) ->
     loose_node:stop(Node),
     ok.
 
+-record(sys_procs, {init,
+		    code_purger,
+		    literal_collector,
+		    dirty_proc_checker}).
+
+find_system_processes() ->
+    find_system_procs(processes(), #sys_procs{}).
+
+find_system_procs([], SysProcs) ->
+    [SysProcs#sys_procs.init,
+     SysProcs#sys_procs.code_purger,
+     SysProcs#sys_procs.literal_collector,
+     SysProcs#sys_procs.dirty_proc_checker];
+find_system_procs([P|Ps], SysProcs) ->
+    case process_info(P, initial_call) of
+	{initial_call,{otp_ring0,start,2}} ->
+	    undefined = SysProcs#sys_procs.init,
+	    find_system_procs(Ps, SysProcs#sys_procs{init = P});
+	{initial_call,{erts_code_purger,start,0}} ->
+	    undefined = SysProcs#sys_procs.code_purger,
+	    find_system_procs(Ps, SysProcs#sys_procs{code_purger = P});
+	{initial_call,{erts_literal_area_collector,start,0}} ->
+	    undefined = SysProcs#sys_procs.literal_collector,
+	    find_system_procs(Ps, SysProcs#sys_procs{literal_collector = P});
+	{initial_call,{erts_dirty_process_code_checker,start,0}} ->
+	    undefined = SysProcs#sys_procs.dirty_proc_checker,
+	    find_system_procs(Ps, SysProcs#sys_procs{dirty_proc_checker = P});
+	_ ->
+	    find_system_procs(Ps, SysProcs)
+    end.
+
 wait_restart(0, _Node) ->
     ct:fail(not_restarted);
 wait_restart(N, Node) ->
diff --git a/lib/sasl/src/sasl.app.src b/lib/sasl/src/sasl.app.src
index 4ee8a7d6c8..633cdfa070 100644
--- a/lib/sasl/src/sasl.app.src
+++ b/lib/sasl/src/sasl.app.src
@@ -46,5 +46,5 @@
            {errlog_type, all}]},
     {mod, {sasl, []}},
     {runtime_dependencies, ["tools-2.6.14","stdlib-3.0","kernel-5.0",
-			    "erts-8.0"]}]}.
+			    "erts-8.1"]}]}.
 
diff --git a/lib/sasl/src/systools_make.erl b/lib/sasl/src/systools_make.erl
index 352e4984df..efe6cc9eb4 100644
--- a/lib/sasl/src/systools_make.erl
+++ b/lib/sasl/src/systools_make.erl
@@ -1491,8 +1491,9 @@ mandatory_modules() ->
 preloaded() ->
     %% Sorted
     [erl_prim_loader,erl_tracer,erlang,
-     erts_code_purger,
-     erts_internal,init,otp_ring0,prim_eval,prim_file,
+     erts_code_purger,erts_dirty_process_code_checker,
+     erts_internal,erts_literal_area_collector,
+     init,otp_ring0,prim_eval,prim_file,
      prim_inet,prim_zip,zlib].
 
 %%______________________________________________________________________
diff --git a/lib/tools/test/cover_SUITE.erl b/lib/tools/test/cover_SUITE.erl
index b4c9264b30..90e113c178 100644
--- a/lib/tools/test/cover_SUITE.erl
+++ b/lib/tools/test/cover_SUITE.erl
@@ -1001,41 +1001,40 @@ otp_6115(Config) when is_list(Config) ->
     %% Cover compile f1, but not f2
     {ok, f1} = cover:compile(f1),
 
+    %% This test used to ensure that a process containing a
+    %% fun refering to cover compiled code was killed.
+    %% check_process_code may however ignore funs as of ERTS
+    %% version 8.1. The test has therefore been rewritten to
+    %% check that a process with a direct reference (in this
+    %% case a return address) to the code is killed.
+    %% 
     %% If f1 is cover compiled, a process P is started with a
-    %% reference to the fun created in start_fail/0, and cover:stop() is
-    %% called, then P should be killed.
-    %% This is because (the fun held by P) references the cover
+    %% direct reference to the f1, and cover:stop() is called,
+    %% then P should be killed.
+    %% This is because of the return address to the cover
     %% compiled code which should be *unloaded* when cover:stop() is
     %% called -- running cover compiled code when there is no cover
     %% server and thus no ets tables to bump counters in, makes no
     %% sense.
-    Pid1 = f1:start_a(),
-    Pid2 = f1:start_b(),
+    Pid = spawn(fun () -> f1:non_tail_call_f2_wait() end),
 
     %% Now stop cover
     cover:stop(),
 
     %% Ensure that f1 is loaded (and not cover compiled), and that
-    %% both Pid1 and Pid2 are dead.
+    %% both Pid is dead.
     case code:which(f1) of
         Beam when is_list(Beam) ->
             ok;
         Other ->
             ct:fail({"f1 is not reloaded", Other})
     end,
-    case process_info(Pid1) of
+    case process_info(Pid) of
         undefined ->
             ok;
-        _PI1 ->
-            RefToOldP1 = erlang:check_process_code(Pid1, f1),
-            ct:fail({"Pid1 still alive", RefToOldP1})
-    end,
-    case process_info(Pid2) of
-        undefined ->
-            ok;
-        _PI2 ->
-            RefToOldP2 = erlang:check_process_code(Pid1, f2),
-            ct:fail({"Pid2 still alive", RefToOldP2})
+        _PI ->
+            RefToOldP = erlang:check_process_code(Pid, f1),
+            ct:fail({"Pid still alive", RefToOldP})
     end,
 
     file:set_cwd(CWD),
diff --git a/lib/tools/test/cover_SUITE_data/otp_6115/f1.erl b/lib/tools/test/cover_SUITE_data/otp_6115/f1.erl
index 5399b33f19..fc4a62e70e 100644
--- a/lib/tools/test/cover_SUITE_data/otp_6115/f1.erl
+++ b/lib/tools/test/cover_SUITE_data/otp_6115/f1.erl
@@ -1,13 +1,6 @@
 -module(f1).
--export([start_a/0, start_b/0]).
+-export([non_tail_call_f2_wait/0]).
 
-start_a() ->
-    f2:start(fun() -> 
-		     ok
-	     end).
-
-start_b() ->
-    f2:start(fun fun1/0).
-
-fun1() ->
-    ok.
+non_tail_call_f2_wait() ->
+    f2:wait(),
+    im_back.
diff --git a/lib/tools/test/cover_SUITE_data/otp_6115/f2.erl b/lib/tools/test/cover_SUITE_data/otp_6115/f2.erl
index 72a6a64c4d..4bc88035c7 100644
--- a/lib/tools/test/cover_SUITE_data/otp_6115/f2.erl
+++ b/lib/tools/test/cover_SUITE_data/otp_6115/f2.erl
@@ -1,13 +1,5 @@
 -module(f2).
--export([start/1]).
+-export([wait/0]).
 
-start(Fun) ->
-    spawn(fun() ->
-		  wait(Fun)
-	  end).
-
-wait(Fun) ->
-    receive
-	go ->
-	    Fun()
-    end.
+wait() ->
+    receive after infinity -> ok end.