erts: Check process registers during CLA check

Author: jhogberg

Diff for: erts/emulator/beam/beam_bif_load.c

@@ -1092,7 +1092,24 @@ erts_check_copy_literals_gc_need(Process *c_p, int *redsp,
 		goto done;
 	}
     }
-    
+
+    /* Check if there are any *direct* references to literals in the process'
+     * registers.
+     *
+     * These are not guaranteed to be kept up to date, but as we can only land
+     * here during signal handling we KNOW that these are either up to date, or
+     * they are not actually live (effective arity is 0 in a `receive`). Should
+     * any of these registers contain garbage, we merely risk scheduling a
+     * pointless garbage collection as `any_heap_ref_ptrs` doesn't follow
+     * pointers, it just range-checks them. */
+    scanned += c_p->arity;
+    if (any_heap_ref_ptrs(&c_p->arg_reg[0],
+                          &c_p->arg_reg[c_p->arity],
+                          literals,
+                          lit_bsize)) {
+        goto done;
+    }
+
     res = 0; /* no need for gc */
 
 done: {

Diff for: erts/emulator/test/signal_SUITE.erl

@@ -57,12 +57,13 @@
          copy_literal_area_signal_recv/1,
          copy_literal_area_signal_exit/1,
          copy_literal_area_signal_recv_exit/1,
+         copy_literal_area_signal_registers/1,
          simultaneous_signals_basic/1,
          simultaneous_signals_recv/1,
          simultaneous_signals_exit/1,
          simultaneous_signals_recv_exit/1]).
 
--export([spawn_spammers/3]).
+-export([check_literal_conversion/1, spawn_spammers/3]).
 
 init_per_testcase(Func, Config) when is_atom(Func), is_list(Config) ->
     [{testcase, Func}|Config].
@@ -107,6 +108,7 @@ groups() ->
        copy_literal_area_signal_recv,
        copy_literal_area_signal_exit,
        copy_literal_area_signal_recv_exit,
+       copy_literal_area_signal_registers,
        simultaneous_signals_basic,
        simultaneous_signals_recv,
        simultaneous_signals_exit,
@@ -945,6 +947,48 @@ copy_literal_area_signal_exit(Config) when is_list(Config) ->
 copy_literal_area_signal_recv_exit(Config) when is_list(Config) ->
     copy_literal_area_signal_test(true, true).
 
+%% Tests the case where the literal is only present in the process' saved
+%% registers. This is easy to provoke with hibernation, but can also occur
+%% if a process happens to be scheduled out on e.g. a function call with a
+%% literal argument just as it's being purged.
+copy_literal_area_signal_registers(Config) when is_list(Config) ->
+    persistent_term:put({?MODULE, ?FUNCTION_NAME}, [make_ref()]),
+    LiteralArgs = persistent_term:get({?MODULE, ?FUNCTION_NAME}),
+    true = is_list(LiteralArgs),
+    0 = erts_debug:size_shared(LiteralArgs), %% Should be a literal...
+
+    Self = self(),
+
+    {Pid, Monitor} =
+        spawn_monitor(fun() ->
+                              Self ! {sync, LiteralArgs},
+                              erlang:hibernate(?MODULE,
+                                               check_literal_conversion,
+                                               LiteralArgs)
+                      end),
+
+    receive
+        {sync, LiteralArgs} ->
+            receive after 500 ->
+                {current_function,{erlang,hibernate,3}} =
+                    process_info(Pid, current_function)
+            end
+    end,
+
+    persistent_term:erase({?MODULE, ?FUNCTION_NAME}),
+    receive after 1 -> ok end,
+
+    literal_area_collector_test:check_idle(),
+
+    false = (0 =:= erts_debug:size_shared(LiteralArgs)),
+    Pid ! check_literal_conversion,
+
+    receive
+        {'DOWN', Monitor, process, Pid, R} ->
+            normal = R,
+            ok
+    end.
+
 copy_literal_area_signal_test(RecvPair, Exit) ->
     persistent_term:put({?MODULE, ?FUNCTION_NAME}, make_ref()),
     Literal = persistent_term:get({?MODULE, ?FUNCTION_NAME}),
@@ -958,12 +1002,7 @@ copy_literal_area_signal_test(RecvPair, Exit) ->
                        true ->
                             ok
                     end,
-                    receive check_literal_conversion -> ok end,
-                    receive
-                        Literal ->
-                            %% Should not be a literal anymore...
-                            false = (0 == erts_debug:size_shared(Literal))
-                    end
+                    check_literal_conversion(Literal)
             end,
     PMs = lists:map(fun (_) ->
                             spawn_opt(ProcF, [link, monitor])
@@ -1014,6 +1053,15 @@ copy_literal_area_signal_test(RecvPair, Exit) ->
                   end, PMs),
     ok.
 
+%% Exported for optional use with hibernate/3
+check_literal_conversion(Literal) ->
+    receive
+        check_literal_conversion ->
+            %% Should not be a literal anymore...
+            false = (0 == erts_debug:size_shared(Literal)),
+            ok
+    end.
+
 simultaneous_signals_basic(Config) when is_list(Config) ->
     simultaneous_signals_test(false, false).