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

12 files changed, 356 insertions, 42 deletions

diff --git a/erts/preloaded/ebin/erts_code_purger.beam b/erts/preloaded/ebin/erts_code_purger.beam
index a0da864824..a1eb126098 100644
--- a/erts/preloaded/ebin/erts_code_purger.beam
+++ b/erts/preloaded/ebin/erts_code_purger.beam
diff --git a/erts/preloaded/ebin/erts_dirty_process_code_checker.beam b/erts/preloaded/ebin/erts_dirty_process_code_checker.beam
new file mode 100644
index 0000000000..a7ac116c05
--- /dev/null
+++ b/erts/preloaded/ebin/erts_dirty_process_code_checker.beam
diff --git a/erts/preloaded/ebin/erts_internal.beam b/erts/preloaded/ebin/erts_internal.beam
index d897c8e92f..22817be8f4 100644
--- a/erts/preloaded/ebin/erts_internal.beam
+++ b/erts/preloaded/ebin/erts_internal.beam
diff --git a/erts/preloaded/ebin/erts_literal_area_collector.beam b/erts/preloaded/ebin/erts_literal_area_collector.beam
new file mode 100644
index 0000000000..71f3c2ec8c
--- /dev/null
+++ b/erts/preloaded/ebin/erts_literal_area_collector.beam
diff --git a/erts/preloaded/ebin/init.beam b/erts/preloaded/ebin/init.beam
index f0344fd6ba..849273f746 100644
--- a/erts/preloaded/ebin/init.beam
+++ b/erts/preloaded/ebin/init.beam
diff --git a/erts/preloaded/src/Makefile b/erts/preloaded/src/Makefile
index 4a447d3a09..2ab9edaf5e 100644
--- a/erts/preloaded/src/Makefile
+++ b/erts/preloaded/src/Makefile
@@ -44,7 +44,9 @@ PRE_LOADED_ERL_MODULES = \
 	erts_code_purger \
 	erlang \
 	erts_internal \
-	erl_tracer
+	erl_tracer \
+	erts_literal_area_collector \
+	erts_dirty_process_code_checker
 
 PRE_LOADED_BEAM_MODULES = \
 	prim_eval
diff --git a/erts/preloaded/src/erts.app.src b/erts/preloaded/src/erts.app.src
index e18da28905..7ab06164b4 100644
--- a/erts/preloaded/src/erts.app.src
+++ b/erts/preloaded/src/erts.app.src
@@ -37,7 +37,7 @@
 	{registered, []},
 	{applications, []},
 	{env, []},
-	{runtime_dependencies, ["stdlib-3.0", "kernel-5.0", "sasl-3.0"]}
+	{runtime_dependencies, ["stdlib-3.0", "kernel-5.0", "sasl-3.0.1"]}
     ]}.
 
 %% vim: ft=erlang
diff --git a/erts/preloaded/src/erts_code_purger.erl b/erts/preloaded/src/erts_code_purger.erl
index d1e64342e0..ee4fcedd2d 100644
--- a/erts/preloaded/src/erts_code_purger.erl
+++ b/erts/preloaded/src/erts_code_purger.erl
@@ -22,7 +22,7 @@
 %% Purpose : Implement system process erts_code_purger
 %%           to handle code module purging.
 
--export([start/0, purge/1, soft_purge/1]).
+-export([start/0, purge/1, soft_purge/1, pending_purge_lambda/3]).
 
 -spec start() -> term().
 start() ->
@@ -40,10 +40,43 @@ loop() ->
 	    Res = do_soft_purge(Mod),
 	    From ! {reply, soft_purge, Res, Ref};
 
+	{test_purge, Mod, From, Type, Ref} when is_atom(Mod), is_pid(From) ->
+	     do_test_purge(Mod, From, Type, Ref);
+
 	_Other -> ignore
     end,
     loop().
 
+%%
+%% Processes that tries to call a fun that belongs to
+%% a module that currently is being purged will end
+%% up here (pending_purge_lambda) in a suspended state.
+%% When the purge operation completes or aborts (soft
+%% purge that failed) these processes will be resumed.
+%%
+pending_purge_lambda(_Module, Fun, Args) ->
+    %%
+    %% When the process is resumed, the following
+    %% scenarios exist:
+    %% * The code that the fun refers to is still
+    %%   there due to a failed soft purge. The
+    %%   call to the fun will succeed via apply/2.
+    %% * The code was purged, and a current version
+    %%   of the module is loaded which does not
+    %%   contain this fun. The call will result
+    %%   in an exception being raised.
+    %% * The code was purged, and no current
+    %%   version of the module is loaded. An attempt
+    %%   to load the module (via the error_handler)
+    %%   will be made. This may or may not succeed.
+    %%   If the module is loaded, it may or may
+    %%   not contain the fun. The call will
+    %%   succeed if the error_handler was able
+    %%   to load the module and loaded module
+    %%   contains this fun; otherwise, an exception
+    %%   will be raised.
+    %%
+    apply(Fun, Args).
 
 %% purge(Module)
 %%  Kill all processes running code from *old* Module, and then purge the
@@ -60,16 +93,14 @@ purge(Mod) when is_atom(Mod) ->
 	    Result
     end.
 
-
 do_purge(Mod) ->
-    case erts_internal:copy_literals(Mod, true) of
-        false ->
-            {false, false};
-        true ->
-            DidKill = check_proc_code(erlang:processes(), Mod, true),
-            true = erts_internal:copy_literals(Mod, false),
-	    WasPurged = erts_internal:purge_module(Mod),
-            {WasPurged, DidKill}
+    case erts_internal:purge_module(Mod, prepare) of
+	false ->
+	    {false, false};
+	true ->
+	    DidKill = check_proc_code(erlang:processes(), Mod, true),
+	    true = erts_internal:purge_module(Mod, complete),
+	    {true, DidKill}
     end.
 
 %% soft_purge(Module)
@@ -85,21 +116,17 @@ soft_purge(Mod) ->
 	    Result
     end.
 
-
 do_soft_purge(Mod) ->
-    case erts_internal:copy_literals(Mod, true) of
+    case erts_internal:purge_module(Mod, prepare) of
 	false ->
 	    true;
 	true ->
-	    DoPurge = check_proc_code(erlang:processes(), Mod, false),
-	    true = erts_internal:copy_literals(Mod, false),
-	    case DoPurge of
-		false ->
-		    false;
-		true ->
-		    erts_internal:purge_module(Mod),
-		    true
-	    end
+	    Res = check_proc_code(erlang:processes(), Mod, false),
+	    erts_internal:purge_module(Mod,
+				       case Res of
+					   false -> abort;
+					   true -> complete
+				       end)
     end.
 
 %%
@@ -283,8 +310,7 @@ cpc_sched_kill(Pid,
 
 cpc_request(#cpc_static{tag = Tag, module = Mod}, Pid, AllowGc) ->
     erts_internal:check_process_code(Pid, Mod, [{async, {Tag, Pid, AllowGc}},
-						{allow_gc, AllowGc},
-						{copy_literals, true}]).
+						{allow_gc, AllowGc}]).
 
 cpc_request_gc(CpcS, [Pid|Pids]) ->
     cpc_request(CpcS, Pid, true),
@@ -297,3 +323,72 @@ cpc_init(CpcS, [Pid|Pids], NoReqs) ->
     cpc_init(CpcS, Pids, NoReqs+1).
 
 % end of check_proc_code() implementation.
+
+%%
+%% FOR TESTING ONLY
+%%
+%% do_test_purge() is for testing only. The purge is done
+%% as usual, but the tester can control when to enter the
+%% specific phases.
+%%
+do_test_purge(Mod, From, Type, Ref) when Type == true; Type == false ->
+    Mon = erlang:monitor(process, From),
+    Res = case Type of
+	      true -> do_test_hard_purge(Mod, From, Ref, Mon);
+	      false -> do_test_soft_purge(Mod, From, Ref, Mon)
+	  end,
+    From ! {test_purge, Res, Ref},
+    erlang:demonitor(Mon, [flush]),
+    ok;
+do_test_purge(_, _, _, _) ->
+    ok.
+
+do_test_soft_purge(Mod, From, Ref, Mon) ->
+    PrepRes = erts_internal:purge_module(Mod, prepare),
+    TestRes = test_progress(started, From, Mon, Ref, ok),
+    case PrepRes of
+	false ->
+	    _ = test_progress(continued, From, Mon, Ref, TestRes),
+	    true;
+	true ->
+	    Res = check_proc_code(erlang:processes(), Mod, false),
+	    _ = test_progress(continued, From, Mon, Ref, TestRes),
+	    erts_internal:purge_module(Mod,
+				       case Res of
+					   false -> abort;
+					   true -> complete
+				       end)
+    end.
+
+do_test_hard_purge(Mod, From, Ref, Mon) ->
+    PrepRes = erts_internal:purge_module(Mod, prepare),
+    TestRes = test_progress(started, From, Mon, Ref, ok),
+    case PrepRes of
+	false ->
+	    _ = test_progress(continued, From, Mon, Ref, TestRes),
+	    {false, false};
+	true ->
+	    DidKill = check_proc_code(erlang:processes(), Mod, true),
+	    _ = test_progress(continued, From, Mon, Ref, TestRes),
+	    true = erts_internal:purge_module(Mod, complete),
+	    {true, DidKill}
+    end.
+
+test_progress(_State, _From, _Mon, _Ref, died) ->
+    %% Test process died; continue so we wont
+    %% leave the system in an inconsistent
+    %% state...
+    died;
+test_progress(started, From, Mon, Ref, ok) ->
+    From ! {started, Ref},
+    receive
+	{'DOWN', Mon, process, From, _} -> died;
+	{continue, Ref} -> ok
+    end;
+test_progress(continued, From, Mon, Ref, ok) ->
+    From ! {continued, Ref},
+    receive
+	{'DOWN', Mon, process, From, _} -> died;
+	{complete, Ref} -> ok
+    end.
+
diff --git a/erts/preloaded/src/erts_dirty_process_code_checker.erl b/erts/preloaded/src/erts_dirty_process_code_checker.erl
new file mode 100644
index 0000000000..911642082c
--- /dev/null
+++ b/erts/preloaded/src/erts_dirty_process_code_checker.erl
@@ -0,0 +1,82 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2016. All Rights Reserved.
+%%
+%% 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
+%%
+%%     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%
+%%
+
+-module(erts_dirty_process_code_checker).
+
+-export([start/0]).
+
+%%
+%% The erts_dirty_process_code_checker is started at
+%% VM boot by the VM. It is a spawned as a system
+%% process, i.e, the whole VM will terminate if
+%% this process terminates.
+%%
+start() ->
+    process_flag(trap_exit, true),
+    msg_loop().
+
+msg_loop() ->
+    _ = receive
+	    Request ->
+		handle_request(Request)
+	end,
+    msg_loop().
+
+check_process(Requester, Target, ReqId, Module) ->
+    Result = erts_internal:check_dirty_process_code(Target, Module),
+    Requester ! {check_process_code, ReqId, Result}.
+					  
+handle_request({Requester,
+		Target,
+		Prio,
+		{check_process_code,
+		 ReqId,
+		 Module,
+		 _Flags} = Op}) ->
+    %%
+    %% Target may have stopped executing dirty since the
+    %% initial request was made. Check its current state
+    %% and try to send the request if possible; otherwise,
+    %% check the dirty executing process and send the result...
+    %%
+    try
+	case erts_internal:is_process_executing_dirty(Target) of
+	    true ->
+		check_process(Requester, Target, ReqId, Module);
+	    false ->
+		case erts_internal:request_system_task(Requester,
+						       Target,
+						       Prio,
+						       Op) of
+		    ok ->
+			ok;
+		    dirty_execution ->
+			check_process(Requester, Target, ReqId, Module)
+		end
+	end
+    catch
+	_ : _ ->
+	    ok %% Ignore all failures; someone passed us garbage...
+    end;
+handle_request(_Garbage) ->
+    ignore.
+
+		    
+	    
diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 2459ea2a2c..6229754c8c 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -38,11 +38,13 @@
 -export([system_check/1,
          gather_system_check_result/1]).
 
--export([request_system_task/3]).
+-export([request_system_task/3, request_system_task/4]).
 
 -export([check_process_code/3]).
--export([copy_literals/2]).
--export([purge_module/1]).
+-export([check_dirty_process_code/2]).
+-export([is_process_executing_dirty/1]).
+-export([release_literal_area_switch/0]).
+-export([purge_module/2]).
 
 -export([flush_monitor_messages/3]).
 
@@ -204,14 +206,25 @@ port_info(_Result, _Item) ->
 -spec request_system_task(Pid, Prio, Request) -> 'ok' when
       Prio :: 'max' | 'high' | 'normal' | 'low',
       Request :: {'garbage_collect', term()}
-	       | {'check_process_code', term(), module(), non_neg_integer()},
+	       | {'check_process_code', term(), module(), non_neg_integer()}
+	       | {'copy_literals', term(), boolean()},
       Pid :: pid().
 
 request_system_task(_Pid, _Prio, _Request) ->
     erlang:nif_error(undefined).
 
+-spec request_system_task(RequesterPid, TargetPid, Prio, Request) -> 'ok' | 'dirty_execution' when
+      Prio :: 'max' | 'high' | 'normal' | 'low',
+      Request :: {'garbage_collect', term()}
+	       | {'check_process_code', term(), module(), non_neg_integer()}
+	       | {'copy_literals', term(), boolean()},
+      RequesterPid :: pid(),
+      TargetPid :: pid().
+
+request_system_task(_RequesterPid, _TargetPid, _Prio, _Request) ->
+    erlang:nif_error(undefined).
+
 -define(ERTS_CPC_ALLOW_GC, (1 bsl 0)).
--define(ERTS_CPC_COPY_LITERALS, (1 bsl 1)).
 
 -spec check_process_code(Module, Flags) -> boolean() when
       Module :: module(),
@@ -223,7 +236,7 @@ check_process_code(_Module, _Flags) ->
       Pid :: pid(),
       Module :: module(),
       RequestId :: term(),
-      Option :: {async, RequestId} | {allow_gc, boolean()} | {copy_literals, boolean()},
+      Option :: {async, RequestId} | {allow_gc, boolean()},
       OptionList :: [Option],
       CheckResult :: boolean() | aborted.
 check_process_code(Pid, Module, OptionList)  ->
@@ -265,8 +278,6 @@ get_cpc_opts([{async, _ReqId} = AsyncTuple | Options], _OldAsync, Flags) ->
     get_cpc_opts(Options, AsyncTuple, Flags);
 get_cpc_opts([{allow_gc, AllowGC} | Options], Async, Flags) ->
     get_cpc_opts(Options, Async, cpc_flags(Flags, ?ERTS_CPC_ALLOW_GC, AllowGC));
-get_cpc_opts([{copy_literals, CopyLit} | Options], Async, Flags) ->
-    get_cpc_opts(Options, Async, cpc_flags(Flags, ?ERTS_CPC_COPY_LITERALS, CopyLit));
 get_cpc_opts([], Async, Flags) ->
     {Async, Flags}.
 
@@ -275,15 +286,26 @@ cpc_flags(OldFlags, Bit, true) ->
 cpc_flags(OldFlags, Bit, false) ->
     OldFlags band (bnot Bit).
 
--spec copy_literals(Module,Bool) -> 'true' | 'false' | 'aborted' when
-      Module :: module(),
-      Bool :: boolean().
-copy_literals(_Mod, _Bool) ->
+-spec check_dirty_process_code(Pid,Module) -> 'true' | 'false' when
+      Pid :: pid(),
+      Module :: module().
+check_dirty_process_code(_Pid,_Module) ->
     erlang:nif_error(undefined).
 
--spec purge_module(Module) -> boolean() when
-      Module :: module().
-purge_module(_Module) ->
+-spec is_process_executing_dirty(Pid) -> 'true' | 'false' when
+      Pid :: pid().
+is_process_executing_dirty(_Pid) ->
+    erlang:nif_error(undefined).
+
+-spec release_literal_area_switch() -> 'true' | 'false'.
+
+release_literal_area_switch() ->
+    erlang:nif_error(undefined).
+
+-spec purge_module(Module, Op) -> boolean() when
+      Module :: module(),
+      Op :: 'prepare' | 'abort' | 'complete'.
+purge_module(_Module, _Op) ->
     erlang:nif_error(undefined).
 
 -spec system_check(Type) -> 'ok' when
diff --git a/erts/preloaded/src/erts_literal_area_collector.erl b/erts/preloaded/src/erts_literal_area_collector.erl
new file mode 100644
index 0000000000..3befad8dfb
--- /dev/null
+++ b/erts/preloaded/src/erts_literal_area_collector.erl
@@ -0,0 +1,113 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2016. All Rights Reserved.
+%%
+%% 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
+%%
+%%     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%
+%%
+-module(erts_literal_area_collector).
+
+-export([start/0]).
+
+%% Currently we only allow two outstanding literal
+%% copying jobs that garbage collect in order to
+%% copy the literals. Maybe we could allow more
+%% than two outstanding processes, but for now we
+%% play it safe...
+-define(MAX_GC_OUTSTND, 2).
+
+%%
+%% The erts_literal_area_collector is started at
+%% VM boot by the VM. It is a spawned as a system
+%% process, i.e, the whole VM will terminate if
+%% this process terminates.
+%%
+start() ->
+    process_flag(trap_exit, true),
+    msg_loop(undefined, 0, 0, []).
+
+%%
+%% The VM will send us a 'copy_literals' message
+%% when it has a new literal area that needs to
+%% be handled is added. We will also be informed
+%% about more areas when we call
+%% erts_internal:release_literal_area_switch().
+%%
+msg_loop(Area, Outstnd, GcOutstnd, NeedGC) ->
+    receive
+
+	%% A new area to handle has arrived...
+	copy_literals when Outstnd == 0 ->
+	    switch_area();
+
+	%% Process (_Pid) has completed the request...
+	{copy_literals, {Area, _GcAllowed, _Pid}, ok} when Outstnd == 1 ->
+	    switch_area(); %% Last process completed...
+	{copy_literals, {Area, false, _Pid}, ok} ->
+	    msg_loop(Area, Outstnd-1, GcOutstnd, NeedGC);
+	{copy_literals, {Area, true, _Pid}, ok} when NeedGC == [] ->
+	    msg_loop(Area, Outstnd-1, GcOutstnd-1, []);
+	{copy_literals, {Area, true, _Pid}, ok} ->
+	    send_copy_req(hd(NeedGC), Area, true),
+	    msg_loop(Area, Outstnd-1, GcOutstnd, tl(NeedGC));
+
+	%% Process (Pid) failed to complete the request
+	%% since it needs to garbage collect in order to
+	%% complete the request...
+	{copy_literals, {Area, false, Pid}, need_gc} when GcOutstnd < ?MAX_GC_OUTSTND ->
+	    send_copy_req(Pid, Area, true),
+	    msg_loop(Area, Outstnd, GcOutstnd+1, NeedGC);
+	{copy_literals, {Area, false, Pid}, need_gc} ->
+	    msg_loop(Area, Outstnd, GcOutstnd, [Pid|NeedGC]);
+
+	%% Not handled message regarding the area that we
+	%% currently are working with. Crash the VM so
+	%% we notice this bug...
+	{copy_literals, {Area, _, _}, _} = Msg when erlang:is_reference(Area) ->
+	    exit({not_handled_message, Msg});
+
+	%% Unexpected garbage message. Get rid of it...
+	_Ignore ->
+	    msg_loop(Area, Outstnd, GcOutstnd, NeedGC)
+
+    end.
+
+switch_area() ->
+    Res = erts_internal:release_literal_area_switch(),
+    erlang:garbage_collect(), %% Almost no live data now...
+    case Res of
+	false ->
+	    %% No more areas to handle...
+	    msg_loop(undefined, 0, 0, []);
+	true ->
+	    %% Send requests to all processes to copy
+	    %% all live data they have referring to the
+	    %% literal area that is to be released...
+	    Area = make_ref(),
+	    Outstnd = send_copy_reqs(erlang:processes(), Area, false),
+	    msg_loop(Area, Outstnd, 0, [])
+    end.
+
+send_copy_reqs(Ps, Area, GC) ->
+    send_copy_reqs(Ps, Area, GC, 0).
+
+send_copy_reqs([], _Area, _GC, N) ->
+    N;
+send_copy_reqs([P|Ps], Area, GC, N) ->
+    send_copy_req(P, Area, GC),
+    send_copy_reqs(Ps, Area, GC, N+1).
+
+send_copy_req(P, Area, GC) ->
+    erts_internal:request_system_task(P, normal, {copy_literals, {Area, GC, P}, GC}).
diff --git a/erts/preloaded/src/init.erl b/erts/preloaded/src/init.erl
index 67929c53c2..962528f7ab 100644
--- a/erts/preloaded/src/init.erl
+++ b/erts/preloaded/src/init.erl
@@ -669,9 +669,9 @@ unload(_) ->
     do_unload(sub([heart|erlang:pre_loaded()],erlang:loaded())).
 
 do_unload([M|Mods]) ->
-    catch erts_internal:purge_module(M),
+    catch erlang:purge_module(M),
     catch erlang:delete_module(M),
-    catch erts_internal:purge_module(M),
+    catch erlang:purge_module(M),
     do_unload(Mods);
 do_unload([]) ->
     purge_all_hipe_refs(),