From 7baaabb297d0687564f147061a38cd8501b89ae9 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Tue, 5 Mar 2019 16:06:25 +0100
Subject: Revert "erts: Add debug dist obuf memory leak check"

This reverts commit f4c121b1d98bf3db7e6eecbb9fb5b292f2bc3bb0.
---
 erts/emulator/beam/dist.c           | 69 +++----------------------------------
 erts/emulator/beam/erl_init.c       |  5 ---
 erts/emulator/beam/erl_lock_check.c |  3 +-
 3 files changed, 6 insertions(+), 71 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index a1da1addf9..2c2af4bdd3 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -772,77 +772,25 @@ void init_dist(void)
 
 #define ErtsDistOutputBuf2Binary(OB) OB->bin
 
-#ifdef DEBUG
-
-struct obuf_list;
-struct obuf_list {
-    erts_refc_t refc;
-    struct obuf_list *next;
-    struct obuf_list *prev;
-};
-#define obuf_list_size sizeof(struct obuf_list)
-static struct obuf_list *erts_obuf_list = NULL;
-static erts_mtx_t erts_obuf_list_mtx;
-
-static void
-insert_obuf(struct obuf_list *obuf, erts_aint_t initial) {
-    erts_mtx_lock(&erts_obuf_list_mtx);
-    obuf->next = erts_obuf_list;
-    obuf->prev = NULL;
-    erts_refc_init(&obuf->refc, initial);
-    if (erts_obuf_list)
-        erts_obuf_list->prev = obuf;
-    erts_obuf_list = obuf;
-    erts_mtx_unlock(&erts_obuf_list_mtx);
-}
-
-static void
-remove_obuf(struct obuf_list *obuf) {
-    if (erts_refc_dectest(&obuf->refc, 0) == 0) {
-        erts_mtx_lock(&erts_obuf_list_mtx);
-        if (obuf->prev) {
-            obuf->prev->next = obuf->next;
-        } else {
-            erts_obuf_list = obuf->next;
-        }
-        if (obuf->next) obuf->next->prev = obuf->prev;
-        erts_mtx_unlock(&erts_obuf_list_mtx);
-    }
-}
-
-void check_obuf(void);
-void check_obuf(void) {
-    erts_mtx_lock(&erts_obuf_list_mtx);
-    ERTS_ASSERT(erts_obuf_list == NULL);
-    erts_mtx_unlock(&erts_obuf_list_mtx);
-}
-#else
-#define insert_obuf(...)
-#define remove_obuf(...)
-#define obuf_list_size 0
-#endif
-
 static ERTS_INLINE ErtsDistOutputBuf *
 alloc_dist_obuf(Uint size, Uint headers)
 {
     int i;
     ErtsDistOutputBuf *obuf;
     Uint obuf_size = sizeof(ErtsDistOutputBuf)*(headers) +
-        sizeof(byte)*size + obuf_list_size;
+        sizeof(byte)*size;
     Binary *bin = erts_bin_drv_alloc(obuf_size);
-    size += obuf_list_size;
     obuf = (ErtsDistOutputBuf *) &bin->orig_bytes[size];
     erts_refc_add(&bin->intern.refc, headers - 1, 1);
     for (i = 0; i < headers; i++) {
         obuf[i].bin = bin;
-        obuf[i].extp = (byte *)&bin->orig_bytes[0] + obuf_list_size;
+        obuf[i].extp = (byte *)&bin->orig_bytes[0];
 #ifdef DEBUG
         obuf[i].dbg_pattern = ERTS_DIST_OUTPUT_BUF_DBG_PATTERN;
         obuf[i].alloc_endp = obuf->extp + size;
         ASSERT(bin == ErtsDistOutputBuf2Binary(obuf));
 #endif
     }
-    insert_obuf((struct obuf_list*)&bin->orig_bytes[0], headers);
     return obuf;
 }
 
@@ -851,10 +799,7 @@ free_dist_obuf(ErtsDistOutputBuf *obuf)
 {
     Binary *bin = ErtsDistOutputBuf2Binary(obuf);
     ASSERT(obuf->dbg_pattern == ERTS_DIST_OUTPUT_BUF_DBG_PATTERN);
-    remove_obuf((struct obuf_list*)&bin->orig_bytes[0]);
-    if (erts_refc_dectest(&bin->intern.refc, 0) == 0) {
-        erts_bin_free(bin);
-    }
+    erts_bin_release(bin);
 }
 
 static ERTS_INLINE Sint
@@ -2430,8 +2375,8 @@ erts_dsig_send(ErtsDSigSendContext *ctx)
 	case ERTS_DSIG_SEND_PHASE_FIN: {
 
 	    ASSERT(ctx->obuf->extp < ctx->obuf->ext_endp);
-	    ASSERT(((byte*)&ctx->obuf->bin->orig_bytes[0]+obuf_list_size) <= ctx->obuf->extp - ctx->max_finalize_prepend);
-	    ASSERT(ctx->obuf->ext_endp <= ((byte*)ctx->obuf->bin->orig_bytes+obuf_list_size) + ctx->data_size + ctx->dhdr_ext_size);
+	    ASSERT(((byte*)&ctx->obuf->bin->orig_bytes[0]) <= ctx->obuf->extp - ctx->max_finalize_prepend);
+	    ASSERT(ctx->obuf->ext_endp <= ((byte*)ctx->obuf->bin->orig_bytes) + ctx->data_size + ctx->dhdr_ext_size);
 
 	    ctx->data_size = ctx->obuf->ext_endp - ctx->obuf->extp;
 
@@ -4711,10 +4656,6 @@ init_nodes_monitors(void)
 {
     erts_mtx_init(&nodes_monitors_mtx, "nodes_monitors", NIL,
         ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
-#ifdef DEBUG
-    erts_mtx_init(&erts_obuf_list_mtx, "sad", NIL,
-                  ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DISTRIBUTION);
-#endif
     nodes_monitors = NULL;
     no_nodes_monitors = 0;
 }
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index 82d5140d1c..12750b9aa6 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -2417,17 +2417,12 @@ erts_exit_vv(int n, int flush_async, char *fmt, va_list args1, va_list args2)
     erts_exit_epilogue();
 }
 
-void check_obuf(void);
 __decl_noreturn void __noreturn erts_exit_epilogue(void)
 {
     int n = erts_exit_code;
 
     sys_tty_reset(n);
 
-#ifdef DEBUG
-    check_obuf();
-#endif
-
     if (n == ERTS_INTR_EXIT)
 	exit(0);
     else if (n == ERTS_DUMP_EXIT)
diff --git a/erts/emulator/beam/erl_lock_check.c b/erts/emulator/beam/erl_lock_check.c
index 39eabb6710..3aab4828cc 100644
--- a/erts/emulator/beam/erl_lock_check.c
+++ b/erts/emulator/beam/erl_lock_check.c
@@ -164,8 +164,7 @@ static erts_lc_lock_order_t erts_lock_order[] = {
     {	"os_monotonic_time",			NULL			},
     {	"erts_alloc_hard_debug",		NULL			},
     {	"hard_dbg_mseg",		        NULL	                },
-    {	"erts_mmap",				NULL			},
-    {   "sad", NULL}
+    {	"erts_mmap",				NULL			}
 };
 
 #define ERTS_LOCK_ORDER_SIZE \
-- 
cgit v1.2.3


From d7a742cb421ed24ac37c283dcbd060e52d713f3c Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 18 Mar 2019 17:15:03 +0100
Subject: erts: Fix make system to pass TYPE from top level

This makes it possible to do:
    make release TYPE=debug

from ERL_TOP and it will build the correct things.
---
 erts/Makefile | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'erts')

diff --git a/erts/Makefile b/erts/Makefile
index 60c70b6a2c..e62c896170 100644
--- a/erts/Makefile
+++ b/erts/Makefile
@@ -129,9 +129,13 @@ makefiles:
 
 .PHONY: release
 release:
+ifeq ($(TYPE),)
 	for t in $(TYPES); do \
 	  ( cd emulator && $(MAKE) release TYPE=$$t ) || exit $$?; \
 	done
+else
+	( cd emulator && $(MAKE) release TYPE=$(TYPE) ) || exit $$?;
+endif
 	$(V_at)for d in $(ERTSDIRS) $(XINSTDIRS); do \
 		if test -d $$d; then \
 			( cd $$d && $(MAKE) $@ ) || exit $$? ; \
-- 
cgit v1.2.3


From 9915cfe184afa4fd3a361f65ec906a7bd164ead1 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Thu, 21 Mar 2019 10:53:52 +0100
Subject: erts: Fix atom16 testcase after dist frag impl

---
 erts/emulator/test/erts_test_utils.erl | 1 +
 1 file changed, 1 insertion(+)

(limited to 'erts')

diff --git a/erts/emulator/test/erts_test_utils.erl b/erts/emulator/test/erts_test_utils.erl
index 0c3ef3e0fc..e4e00a0a16 100644
--- a/erts/emulator/test/erts_test_utils.erl
+++ b/erts/emulator/test/erts_test_utils.erl
@@ -19,6 +19,7 @@
 %%
 
 -module(erts_test_utils).
+-compile(r16).
 
 %%
 %% THIS MODULE IS ALSO USED BY *OTHER* APPLICATIONS TEST CODE
-- 
cgit v1.2.3


From 04ebb0fbb74ae9332c75041ddc302697ceb1a01e Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Thu, 21 Mar 2019 10:53:37 +0100
Subject: erts: Fix verify_nc in distribution suite

When the calling process is trapping exits a stray message
will end up in the mailbox which is problematic. This change
uses a monitor instead.
---
 erts/emulator/test/distribution_SUITE.erl | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/test/distribution_SUITE.erl b/erts/emulator/test/distribution_SUITE.erl
index 4f70b51aa0..516030ff82 100644
--- a/erts/emulator/test/distribution_SUITE.erl
+++ b/erts/emulator/test/distribution_SUITE.erl
@@ -2428,17 +2428,22 @@ stop_node(Node) ->
 verify_nc(Node) ->
     P = self(),
     Ref = make_ref(),
-    spawn(Node,
-          fun() ->
-                  R = erts_test_utils:check_node_dist(fun(E) -> E end),
-                  P ! {Ref, R}
-          end),
+    Pid = spawn(Node,
+                fun() ->
+                        R = erts_test_utils:check_node_dist(fun(E) -> E end),
+                        P ! {Ref, R}
+                end),
+    MonRef = monitor(process, Pid),
     receive
         {Ref, ok} ->
+            demonitor(MonRef,[flush]),
             ok;
         {Ref, Error} ->
-            ct:log("~s",[Error]),
-            ct:fail(failed_nc_refc_check)
+            ct:log("~p",[Error]),
+            ct:fail(failed_nc_refc_check);
+        {'DOWN', MonRef, _, _, _} = Down ->
+            ct:log("~p",[Down]),
+            ct:fail(crashed_nc_refc_check)
     end.
 
 freeze_node(Node, MS) ->
-- 
cgit v1.2.3


From 38318c2131107e110c94d62d96431d5950a9d698 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 11 Mar 2019 15:24:43 +0100
Subject: erts: Fix file desc leak in poll debug get_evts

---
 erts/emulator/sys/common/erl_poll.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'erts')

diff --git a/erts/emulator/sys/common/erl_poll.c b/erts/emulator/sys/common/erl_poll.c
index c71d23f58c..9662996039 100644
--- a/erts/emulator/sys/common/erl_poll.c
+++ b/erts/emulator/sys/common/erl_poll.c
@@ -2354,6 +2354,7 @@ uint32_t epoll_events(int kp_fd, int fd)
             fprintf(stderr,"failed to parse file %s on line %d, errno = %d\n", fname,
                     line,
                     errno);
+            fclose(f);
             return 0;
         }
         if (fd == ev_fd) {
@@ -2408,6 +2409,7 @@ ERTS_POLL_EXPORT(erts_poll_get_selected_events)(ErtsPollSet *ps,
     if (fscanf(f,"pos:\t%x\nflags:\t%x", &pos, &flags) != 2) {
         fprintf(stderr,"failed to parse file %s, errno = %d\n", fname, errno);
         ASSERT(0);
+        fclose(f);
         return;
     }
     if (fscanf(f,"\nmnt_id:\t%x\n", &mnt_id));
@@ -2422,6 +2424,7 @@ ERTS_POLL_EXPORT(erts_poll_get_selected_events)(ErtsPollSet *ps,
             fprintf(stderr,"failed to parse file %s on line %d, errno = %d\n",
                     fname, line, errno);
             ASSERT(0);
+            fclose(f);
             return;
         }
         if (fd == ps->wake_fds[0] || fd == ps->wake_fds[1])
@@ -2437,6 +2440,7 @@ ERTS_POLL_EXPORT(erts_poll_get_selected_events)(ErtsPollSet *ps,
         ev[fd] = (ERTS_POLL_EV_IN|ERTS_POLL_EV_OUT) & ERTS_POLL_EV_N2E(events);
         line++;
     }
+    fclose(f);
 #else
     for (fd = 0; fd < len; fd++)
         ev[fd] = ERTS_POLL_EV_NONE;
-- 
cgit v1.2.3


From c0ca8209570b42bfbb029eb7e9ae8750a43fb739 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 18 Mar 2019 13:33:30 +0100
Subject: erts: Add crash dumping of EXITING and FREE processes

---
 erts/emulator/beam/break.c            | 32 ++++++++++--
 erts/emulator/beam/dist.c             | 19 +++++++
 erts/emulator/beam/dist.h             |  1 +
 erts/emulator/beam/erl_process_dump.c | 14 ++---
 erts/emulator/test/dump_SUITE.erl     | 98 +++++++++++++++++++++++++++++++----
 5 files changed, 145 insertions(+), 19 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/break.c b/erts/emulator/beam/break.c
index 27bf2187c2..303ab9d9b7 100644
--- a/erts/emulator/beam/break.c
+++ b/erts/emulator/beam/break.c
@@ -39,6 +39,7 @@
 #include "erl_hl_timer.h"
 #include "erl_thr_progress.h"
 #include "erl_proc_sig_queue.h"
+#include "dist.h"
 
 /* Forward declarations -- should really appear somewhere else */
 static void process_killer(void);
@@ -81,11 +82,32 @@ process_info(fmtfn_t to, void *to_arg)
 	    /* Do not include processes with no heap,
 	     * they are most likely just created and has invalid data
 	     */
-	    if (!ERTS_PROC_IS_EXITING(p) && p->heap != NULL)
+	    if (p->heap != NULL)
 		print_process_info(to, to_arg, p, 0);
 	}
     }
 
+    /* Look for FREE processes in the run-queues and dist entries.
+       These have been removed from the ptab but we still want them
+       in the crash dump for debugging. */
+
+    /* First loop through all run-queues */
+    for (i = 0; i < erts_no_schedulers + ERTS_NUM_DIRTY_RUNQS; i++) {
+        ErtsRunQueue *rq = ERTS_RUNQ_IX(i);
+        int j;
+        for (j = 0; j < ERTS_NO_PROC_PRIO_QUEUES; j++) {
+            Process *p = rq->procs.prio[j].first;
+            while (p) {
+                if (ERTS_PSFLG_FREE & erts_atomic32_read_acqb(&p->state))
+                    print_process_info(to, to_arg, p, 0);
+                p = p->next;
+            }
+        }
+    }
+
+    /* Then check all dist entries */
+    erts_dist_print_procs_suspended_on_de(to, to_arg);
+
     port_info(to, to_arg);
 }
 
@@ -206,6 +228,7 @@ print_process_info(fmtfn_t to, void *to_arg, Process *p, ErtsProcLocks orig_lock
 {
     int garbing = 0;
     int running = 0;
+    int exiting = 0;
     Sint len;
     struct saved_calls *scb;
     erts_aint32_t state;
@@ -226,6 +249,9 @@ print_process_info(fmtfn_t to, void *to_arg, Process *p, ErtsProcLocks orig_lock
 			| ERTS_PSFLG_DIRTY_RUNNING))
         running = 1;
 
+    if (state & ERTS_PSFLG_EXITING)
+        exiting = 1;
+
     if (!(locks & ERTS_PROC_LOCK_MAIN)) {
         locks |= ERTS_PROC_LOCK_MAIN;
         if (ERTS_IS_CRASH_DUMPING && running) {
@@ -246,7 +272,7 @@ print_process_info(fmtfn_t to, void *to_arg, Process *p, ErtsProcLocks orig_lock
      * If the process is registered as a global process, display the
      * registered name
      */
-    if (p->common.u.alive.reg)
+    if (!ERTS_PROC_IS_EXITING(p) && p->common.u.alive.reg)
 	erts_print(to, to_arg, "Name: %T\n", p->common.u.alive.reg->name);
 
     /*
@@ -332,7 +358,7 @@ print_process_info(fmtfn_t to, void *to_arg, Process *p, ErtsProcLocks orig_lock
     }
 
     /* display the links only if there are any*/
-    if (ERTS_P_LINKS(p) || ERTS_P_MONITORS(p) || ERTS_P_LT_MONITORS(p)) {
+    if (!exiting && (ERTS_P_LINKS(p) || ERTS_P_MONITORS(p) || ERTS_P_LT_MONITORS(p))) {
 	PrintMonitorContext context = {1, to, to_arg};
 	erts_print(to, to_arg,"Link list: [");
 	erts_link_tree_foreach(ERTS_P_LINKS(p), doit_print_link, &context);	
diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index 2c2af4bdd3..4c200ecc83 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -5046,3 +5046,22 @@ erts_processes_monitoring_nodes(Process *c_p)
 
     return ctxt.res;
 }
+
+static void
+print_suspended_on_de(fmtfn_t to, void *to_arg, DistEntry *dep)
+{
+    for (; dep; dep = dep->next) {
+        ErtsProcList *curr = erts_proclist_peek_first(dep->suspended);
+        while (curr) {
+            if (!is_internal_pid(curr->u.pid))
+                print_process_info(to, to_arg, curr->u.p, 0);
+            curr = erts_proclist_peek_next(dep->suspended, curr);
+        }
+    }
+}
+
+void
+erts_dist_print_procs_suspended_on_de(fmtfn_t to, void *to_arg) {
+    print_suspended_on_de(to, to_arg, erts_hidden_dist_entries);
+    print_suspended_on_de(to, to_arg, erts_visible_dist_entries);
+}
diff --git a/erts/emulator/beam/dist.h b/erts/emulator/beam/dist.h
index 9b5e62ab7e..f953a2ab8c 100644
--- a/erts/emulator/beam/dist.h
+++ b/erts/emulator/beam/dist.h
@@ -319,5 +319,6 @@ extern int erts_dsig_prepare(ErtsDSigSendContext *,
                              int,
                              int);
 
+void erts_dist_print_procs_suspended_on_de(fmtfn_t to, void *to_arg);
 int erts_auto_connect(DistEntry* dep, Process *proc, ErtsProcLocks proc_locks);
 #endif
diff --git a/erts/emulator/beam/erl_process_dump.c b/erts/emulator/beam/erl_process_dump.c
index a164ed543e..71262061dd 100644
--- a/erts/emulator/beam/erl_process_dump.c
+++ b/erts/emulator/beam/erl_process_dump.c
@@ -121,12 +121,14 @@ Uint erts_process_memory(Process *p, int include_sigs_in_transit)
 
     size += sizeof(Process);
 
-    erts_link_tree_foreach(ERTS_P_LINKS(p),
-                           link_size, (void *) &size);
-    erts_monitor_tree_foreach(ERTS_P_MONITORS(p),
-                              monitor_size, (void *) &size);
-    erts_monitor_list_foreach(ERTS_P_LT_MONITORS(p),
-                              monitor_size, (void *) &size);
+    if ((erts_atomic32_read_nob(&p->state) & ERTS_PSFLG_EXITING) == 0) {
+        erts_link_tree_foreach(ERTS_P_LINKS(p),
+                               link_size, (void *) &size);
+        erts_monitor_tree_foreach(ERTS_P_MONITORS(p),
+                                  monitor_size, (void *) &size);
+        erts_monitor_list_foreach(ERTS_P_LT_MONITORS(p),
+                                  monitor_size, (void *) &size);
+    }
     size += (p->heap_sz + p->mbuf_sz) * sizeof(Eterm);
     if (p->abandoned_heap)
         size += (p->hend - p->heap) * sizeof(Eterm);
diff --git a/erts/emulator/test/dump_SUITE.erl b/erts/emulator/test/dump_SUITE.erl
index d0237b78cc..3b860ebdf6 100644
--- a/erts/emulator/test/dump_SUITE.erl
+++ b/erts/emulator/test/dump_SUITE.erl
@@ -24,7 +24,7 @@
 
 -export([all/0, suite/0, init_per_testcase/2, end_per_testcase/2]).
 
--export([signal_abort/1]).
+-export([signal_abort/1, exiting_dump/1, free_dump/1]).
 
 -export([load/0]).
 
@@ -35,7 +35,7 @@ suite() ->
      {timetrap, {minutes, 2}}].
 
 all() ->
-    [signal_abort].
+    [signal_abort, exiting_dump, free_dump].
 
 init_per_testcase(signal_abort, Config) ->
     SO = erlang:system_info(schedulers_online),
@@ -48,7 +48,10 @@ init_per_testcase(signal_abort, Config) ->
             {skip, "the platform does not support scheduler dump"};
        Dump ->
             Config
-    end.
+    end;
+init_per_testcase(_, Config) ->
+    Config.
+
 
 end_per_testcase(_, Config) ->
     Config.
@@ -79,8 +82,6 @@ signal_abort(Config) ->
 
     {ok, Bin} = get_dump_when_done(Dump),
 
-    ct:log("~s",[Bin]),
-
     {match, Matches} = re:run(Bin,"Current Process: <",[global]),
 
     ct:log("Found ~p",[Matches]),
@@ -91,6 +92,85 @@ signal_abort(Config) ->
 
     ok.
 
+load() ->
+    lists:seq(1,10000),
+    load().
+
+
+%% Test that crash dumping when a process is in the state EXITING works
+exiting_dump(Config) when is_list(Config) ->
+    Dump = filename:join(proplists:get_value(priv_dir, Config),"signal_abort.dump"),
+
+    {ok, Node} = start_node(Config),
+
+    Self = self(),
+
+    Pid = spawn_link(Node,
+                     fun() ->
+                             [begin
+                                  T = ets:new(hej,[]),
+                                  [ets:insert(T,{I,I}) || I <- lists:seq(1,1000)]
+                              end || _ <- lists:seq(1,1000)],
+                             Self ! ready,
+                             receive ok -> ok end
+                     end),
+
+    true = rpc:call(Node, os, putenv, ["ERL_CRASH_DUMP",Dump]),
+
+    receive ready -> unlink(Pid), Pid ! ok end,
+
+    rpc:call(Node, erlang, halt, ["dump"]),
+
+    {ok, Bin} = get_dump_when_done(Dump),
+
+    {match, Matches} = re:run(Bin,"^State: Exiting", [global, multiline]),
+
+    ct:log("Found ~p",[Matches]),
+
+    true = length(Matches) == 1,
+
+    file:delete(Dump),
+
+    ok.
+
+%% Test that crash dumping when a process is in the state FREE works
+free_dump(Config) when is_list(Config) ->
+    Dump = filename:join(proplists:get_value(priv_dir, Config),"signal_abort.dump"),
+
+    {ok, Node} = start_node(Config),
+
+    Self = self(),
+
+    Pid = spawn_link(Node,
+                     fun() ->
+                             Self ! ready,
+                             receive
+                                 ok ->
+                                     unlink(Self),
+                                     exit(lists:duplicate(1000,1000))
+                             end
+                     end),
+
+    true = rpc:call(Node, os, putenv, ["ERL_CRASH_DUMP",Dump]),
+
+    [erlang:monitor(process, Pid) || _ <- lists:seq(1,10000)],
+    receive ready -> unlink(Pid), Pid ! ok end,
+
+    rpc:call(Node, erlang, halt, ["dump"]),
+
+    {ok, Bin} = get_dump_when_done(Dump),
+
+    {match, Matches} = re:run(Bin,"^State: Non Existing", [global, multiline]),
+
+    ct:log("Found ~p",[Matches]),
+
+    true = length(Matches) == 1,
+
+    file:delete(Dump),
+
+    ok.
+
+
 get_dump_when_done(Dump) ->
     case file:read_file_info(Dump) of
         {ok, #file_info{ size = Sz }} ->
@@ -104,15 +184,13 @@ get_dump_when_done(Dump, Sz) ->
     timer:sleep(1000),
     case file:read_file_info(Dump) of
         {ok, #file_info{ size = Sz }} ->
-            file:read_file(Dump);
+            {ok, Bin} = file:read_file(Dump),
+            ct:log("~s",[Bin]),
+            {ok, Bin};
         {ok, #file_info{ size = NewSz }} ->
             get_dump_when_done(Dump, NewSz)
     end.
 
-load() ->
-    lists:seq(1,10000),
-    load().
-
 start_node(Config) when is_list(Config) ->
     Pa = filename:dirname(code:which(?MODULE)),
     Name = list_to_atom(atom_to_list(?MODULE)
-- 
cgit v1.2.3


From 043d9e406fc0ffae447b245b853014c7c739b31d Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 18 Mar 2019 15:06:02 +0100
Subject: erts: Always stop any testnodes before testcase exits

This needs to be done in order for automatic fd leak checking
to work properly.
---
 erts/emulator/test/distribution_SUITE.erl | 3 +++
 erts/emulator/test/fun_SUITE.erl          | 4 +++-
 2 files changed, 6 insertions(+), 1 deletion(-)

(limited to 'erts')

diff --git a/erts/emulator/test/distribution_SUITE.erl b/erts/emulator/test/distribution_SUITE.erl
index 516030ff82..32d53ec7cd 100644
--- a/erts/emulator/test/distribution_SUITE.erl
+++ b/erts/emulator/test/distribution_SUITE.erl
@@ -744,6 +744,7 @@ link_to_dead_new_node(Config) when is_list(Config) ->
         {'EXIT', Pid, noproc} ->
             ok;
         Other ->
+            stop_node(Node),
             ct:fail({unexpected_message, Other})
     after 5000 ->
               ct:fail(nothing_received)
@@ -1465,6 +1466,8 @@ measure_latency_large_message(Nodename, DataFun) ->
 
     ct:pal("~p",[IndexTimes]),
 
+    stop_node(N),
+
     case {lists:max(Times), lists:min(Times)} of
         {Max, Min} when Max * 0.25 > Min ->
             ct:fail({incorrect_latency, IndexTimes});
diff --git a/erts/emulator/test/fun_SUITE.erl b/erts/emulator/test/fun_SUITE.erl
index 4042b58ff2..7f6caa08f1 100644
--- a/erts/emulator/test/fun_SUITE.erl
+++ b/erts/emulator/test/fun_SUITE.erl
@@ -592,7 +592,8 @@ refc_dist(Config) when is_list(Config) ->
     3 = fun_refc(F2),
     true = erlang:garbage_collect(),
     2 = fun_refc(F),
-    refc_dist_send(Node, F).
+    refc_dist_send(Node, F),
+    test_server:stop_node(Node).
 
 refc_dist_send(Node, F) ->
     Pid = spawn_link(Node, fun() -> receive
@@ -682,6 +683,7 @@ t_arity(Config) when is_list(Config) ->
     43 = spawn_call(Node, fun(X, Y) -> A+X+Y end),
     1 = spawn_call(Node, fun(X, Y) -> X+Y end),
     45 = spawn_call(Node, fun(X, Y, Z) -> A+X+Y+Z end),
+    test_server:stop_node(Node),
     ok.
 
 t_is_function2(Config) when is_list(Config) ->
-- 
cgit v1.2.3


From 3379747ece9a9d87ddb29dff5bf2a9b6e9b1cd9d Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 18 Mar 2019 15:06:36 +0100
Subject: erts: Always run fds check after each testcase

---
 erts/emulator/test/Makefile               |  3 +-
 erts/emulator/test/bs_construct_SUITE.erl |  1 +
 erts/emulator/test/driver_SUITE.erl       |  3 ++
 erts/emulator/test/emulator.spec          |  1 +
 erts/emulator/test/erts_test_utils.erl    | 77 +++++++++++++++++++++++++++++++
 5 files changed, 84 insertions(+), 1 deletion(-)

(limited to 'erts')

diff --git a/erts/emulator/test/Makefile b/erts/emulator/test/Makefile
index 8c2054cb51..e69120bf13 100644
--- a/erts/emulator/test/Makefile
+++ b/erts/emulator/test/Makefile
@@ -248,12 +248,13 @@ include $(ERL_TOP)/make/otp_release_targets.mk
 
 release_spec:
 
-release_tests_spec: make_emakefile
+release_tests_spec: tests
 	$(INSTALL_DIR) "$(RELSYSDIR)"
 	$(INSTALL_DATA) $(EMAKEFILE) $(TEST_SPEC_FILES) \
 		$(ERL_FILES) $(HRL_FILES) "$(RELSYSDIR)"
 	$(INSTALL_DATA) $(NO_OPT_ERL_FILES) "$(RELSYSDIR)"
 	$(INSTALL_DATA) $(NATIVE_ERL_FILES) "$(RELSYSDIR)"
+	$(INSTALL_DATA) *.beam "$(RELSYSDIR)"
 	chmod -R u+w "$(RELSYSDIR)"
 	tar cf - *_SUITE_data | (cd "$(RELSYSDIR)"; tar xf -)
 
diff --git a/erts/emulator/test/bs_construct_SUITE.erl b/erts/emulator/test/bs_construct_SUITE.erl
index ad05cb3689..a20592dadd 100644
--- a/erts/emulator/test/bs_construct_SUITE.erl
+++ b/erts/emulator/test/bs_construct_SUITE.erl
@@ -45,6 +45,7 @@ all() ->
      bad_append, bs_add_overflow].
 
 init_per_suite(Config) ->
+    application:ensure_all_started(os_mon),
     Config.
 
 end_per_suite(_Config) ->
diff --git a/erts/emulator/test/driver_SUITE.erl b/erts/emulator/test/driver_SUITE.erl
index bb0f3498ab..381c284bde 100644
--- a/erts/emulator/test/driver_SUITE.erl
+++ b/erts/emulator/test/driver_SUITE.erl
@@ -88,6 +88,9 @@
 
 -export([get_check_io_total/1]).   % for z_SUITE.erl
 
+-compile(export_all).
+
+
 -include_lib("common_test/include/ct.hrl").
 
 
diff --git a/erts/emulator/test/emulator.spec b/erts/emulator/test/emulator.spec
index 7a6dd83020..4b1fec0bab 100644
--- a/erts/emulator/test/emulator.spec
+++ b/erts/emulator/test/emulator.spec
@@ -1,2 +1,3 @@
 {enable_builtin_hooks, false}.
+{ct_hooks, [erts_test_utils]}.
 {suites,"../emulator_test",all}.
diff --git a/erts/emulator/test/erts_test_utils.erl b/erts/emulator/test/erts_test_utils.erl
index e4e00a0a16..83bd3dadca 100644
--- a/erts/emulator/test/erts_test_utils.erl
+++ b/erts/emulator/test/erts_test_utils.erl
@@ -31,6 +31,83 @@
          available_internal_state/1,
          check_node_dist/0, check_node_dist/1, check_node_dist/3]).
 
+%% Suite Callbacks
+-export([id/1]).
+-export([init/2]).
+
+-export([pre_init_per_testcase/3]).
+-export([post_end_per_testcase/4]).
+
+-include_lib("kernel/include/file.hrl").
+
+-type config() :: proplists:proplist().
+-type reason() :: term().
+-type skip_or_fail() :: {skip, reason()} |
+                        {auto_skip, reason()} |
+                        {fail, reason()}.
+
+-record(state, { ts_conf_dir, target_system, install_opts, nodenames, nodes }).
+
+%% The id of this SCB
+-spec id(Opts :: term()) ->
+    Id :: term().
+id(_Opts) ->
+    ?MODULE.
+
+%% Always called before any other callback function.
+-spec init(Id :: term(), Opts :: proplists:proplist()) ->
+    {ok, State :: #state{}}.
+init(_Id, Opts) ->
+    {ok, []}.
+
+%% Called before each test case.
+-spec pre_init_per_testcase(TC :: atom(),
+			    Config :: config(),
+			    State :: #state{}) ->
+	{config() | skip_or_fail(), NewState :: #state{}}.
+pre_init_per_testcase(_TC,Config,State) ->
+    Before = available_internal_state(true),
+    CIOD = erts_debug:get_internal_state(check_io_debug),
+    available_internal_state(Before),
+    CIO = driver_SUITE:get_stable_check_io_info(),
+    0 = element(1, CIOD),
+    ct:log("~s~n~n~s",[os:cmd("ls -la /proc/"++ os:getpid() ++"/fd/*"),
+                       os:cmd("cat /proc/"++ os:getpid() ++"/fdinfo/*")]),
+    {Config, {CIO, CIOD}}.
+
+-spec post_end_per_testcase(TC :: atom(),
+			    Config :: config(),
+			    Return :: term(),
+			    State :: #state{}) ->
+	{ok | skip_or_fail(), NewState :: #state{}}.
+post_end_per_testcase(_TC,_Config,Return,St) ->
+    {links, Links} = erlang:process_info(self(), links),
+    ToKill = [Pid || Pid <- Links,
+                     try
+                         is_port(Pid) orelse
+                             begin
+                                 {_, Dict} = erlang:process_info(Pid,dictionary),
+                                 proplists:get_value(ct_process_type,Dict) /= system
+                             end
+                     catch _:_ ->
+                             false
+                     end],
+    ct:pal("Links To Kill: ~p", [ToKill]),
+    [ catch unlink(Pid) || Pid <- ToKill],
+    [ catch exit(Pid, die) || Pid <- ToKill],
+    timer:sleep(2000),
+    Before = available_internal_state(true),
+    AfterCIOD = erts_debug:get_internal_state(check_io_debug),
+    available_internal_state(Before),
+    AfterCIO = driver_SUITE:get_stable_check_io_info(),
+    case St of
+        {CIO, CIOD} ->
+            driver_SUITE:verify_chkio_state(CIO, AfterCIO),
+            0 = element(1, CIOD);
+        _ ->
+            ok
+    end,
+    {Return, []}.
 
 
 -define(VERSION_MAGIC,       131).
-- 
cgit v1.2.3


From 5f495e6b91bcc3e09ee343a2e9b4e1f7de11fa7a Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 18 Mar 2019 15:06:42 +0100
Subject: Revert "erts: Always run fds check after each testcase"

This reverts commit 1eb0a2c47edd036731ee1e4e4f7b5bdfc7d576fa.
---
 erts/emulator/test/Makefile               |  3 +-
 erts/emulator/test/bs_construct_SUITE.erl |  1 -
 erts/emulator/test/driver_SUITE.erl       |  3 --
 erts/emulator/test/emulator.spec          |  1 -
 erts/emulator/test/erts_test_utils.erl    | 77 -------------------------------
 5 files changed, 1 insertion(+), 84 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/test/Makefile b/erts/emulator/test/Makefile
index e69120bf13..8c2054cb51 100644
--- a/erts/emulator/test/Makefile
+++ b/erts/emulator/test/Makefile
@@ -248,13 +248,12 @@ include $(ERL_TOP)/make/otp_release_targets.mk
 
 release_spec:
 
-release_tests_spec: tests
+release_tests_spec: make_emakefile
 	$(INSTALL_DIR) "$(RELSYSDIR)"
 	$(INSTALL_DATA) $(EMAKEFILE) $(TEST_SPEC_FILES) \
 		$(ERL_FILES) $(HRL_FILES) "$(RELSYSDIR)"
 	$(INSTALL_DATA) $(NO_OPT_ERL_FILES) "$(RELSYSDIR)"
 	$(INSTALL_DATA) $(NATIVE_ERL_FILES) "$(RELSYSDIR)"
-	$(INSTALL_DATA) *.beam "$(RELSYSDIR)"
 	chmod -R u+w "$(RELSYSDIR)"
 	tar cf - *_SUITE_data | (cd "$(RELSYSDIR)"; tar xf -)
 
diff --git a/erts/emulator/test/bs_construct_SUITE.erl b/erts/emulator/test/bs_construct_SUITE.erl
index a20592dadd..ad05cb3689 100644
--- a/erts/emulator/test/bs_construct_SUITE.erl
+++ b/erts/emulator/test/bs_construct_SUITE.erl
@@ -45,7 +45,6 @@ all() ->
      bad_append, bs_add_overflow].
 
 init_per_suite(Config) ->
-    application:ensure_all_started(os_mon),
     Config.
 
 end_per_suite(_Config) ->
diff --git a/erts/emulator/test/driver_SUITE.erl b/erts/emulator/test/driver_SUITE.erl
index 381c284bde..bb0f3498ab 100644
--- a/erts/emulator/test/driver_SUITE.erl
+++ b/erts/emulator/test/driver_SUITE.erl
@@ -88,9 +88,6 @@
 
 -export([get_check_io_total/1]).   % for z_SUITE.erl
 
--compile(export_all).
-
-
 -include_lib("common_test/include/ct.hrl").
 
 
diff --git a/erts/emulator/test/emulator.spec b/erts/emulator/test/emulator.spec
index 4b1fec0bab..7a6dd83020 100644
--- a/erts/emulator/test/emulator.spec
+++ b/erts/emulator/test/emulator.spec
@@ -1,3 +1,2 @@
 {enable_builtin_hooks, false}.
-{ct_hooks, [erts_test_utils]}.
 {suites,"../emulator_test",all}.
diff --git a/erts/emulator/test/erts_test_utils.erl b/erts/emulator/test/erts_test_utils.erl
index 83bd3dadca..e4e00a0a16 100644
--- a/erts/emulator/test/erts_test_utils.erl
+++ b/erts/emulator/test/erts_test_utils.erl
@@ -31,83 +31,6 @@
          available_internal_state/1,
          check_node_dist/0, check_node_dist/1, check_node_dist/3]).
 
-%% Suite Callbacks
--export([id/1]).
--export([init/2]).
-
--export([pre_init_per_testcase/3]).
--export([post_end_per_testcase/4]).
-
--include_lib("kernel/include/file.hrl").
-
--type config() :: proplists:proplist().
--type reason() :: term().
--type skip_or_fail() :: {skip, reason()} |
-                        {auto_skip, reason()} |
-                        {fail, reason()}.
-
--record(state, { ts_conf_dir, target_system, install_opts, nodenames, nodes }).
-
-%% The id of this SCB
--spec id(Opts :: term()) ->
-    Id :: term().
-id(_Opts) ->
-    ?MODULE.
-
-%% Always called before any other callback function.
--spec init(Id :: term(), Opts :: proplists:proplist()) ->
-    {ok, State :: #state{}}.
-init(_Id, Opts) ->
-    {ok, []}.
-
-%% Called before each test case.
--spec pre_init_per_testcase(TC :: atom(),
-			    Config :: config(),
-			    State :: #state{}) ->
-	{config() | skip_or_fail(), NewState :: #state{}}.
-pre_init_per_testcase(_TC,Config,State) ->
-    Before = available_internal_state(true),
-    CIOD = erts_debug:get_internal_state(check_io_debug),
-    available_internal_state(Before),
-    CIO = driver_SUITE:get_stable_check_io_info(),
-    0 = element(1, CIOD),
-    ct:log("~s~n~n~s",[os:cmd("ls -la /proc/"++ os:getpid() ++"/fd/*"),
-                       os:cmd("cat /proc/"++ os:getpid() ++"/fdinfo/*")]),
-    {Config, {CIO, CIOD}}.
-
--spec post_end_per_testcase(TC :: atom(),
-			    Config :: config(),
-			    Return :: term(),
-			    State :: #state{}) ->
-	{ok | skip_or_fail(), NewState :: #state{}}.
-post_end_per_testcase(_TC,_Config,Return,St) ->
-    {links, Links} = erlang:process_info(self(), links),
-    ToKill = [Pid || Pid <- Links,
-                     try
-                         is_port(Pid) orelse
-                             begin
-                                 {_, Dict} = erlang:process_info(Pid,dictionary),
-                                 proplists:get_value(ct_process_type,Dict) /= system
-                             end
-                     catch _:_ ->
-                             false
-                     end],
-    ct:pal("Links To Kill: ~p", [ToKill]),
-    [ catch unlink(Pid) || Pid <- ToKill],
-    [ catch exit(Pid, die) || Pid <- ToKill],
-    timer:sleep(2000),
-    Before = available_internal_state(true),
-    AfterCIOD = erts_debug:get_internal_state(check_io_debug),
-    available_internal_state(Before),
-    AfterCIO = driver_SUITE:get_stable_check_io_info(),
-    case St of
-        {CIO, CIOD} ->
-            driver_SUITE:verify_chkio_state(CIO, AfterCIO),
-            0 = element(1, CIOD);
-        _ ->
-            ok
-    end,
-    {Return, []}.
 
 
 -define(VERSION_MAGIC,       131).
-- 
cgit v1.2.3


From 178721284f342e9c8408c336741e73b61162b138 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Tue, 19 Mar 2019 11:51:34 +0100
Subject: erts: Skip heavy process tab tests in debug emu

---
 erts/emulator/test/process_SUITE.erl | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'erts')

diff --git a/erts/emulator/test/process_SUITE.erl b/erts/emulator/test/process_SUITE.erl
index edf08ce0bd..e009f60860 100644
--- a/erts/emulator/test/process_SUITE.erl
+++ b/erts/emulator/test/process_SUITE.erl
@@ -133,6 +133,15 @@ init_per_group(_GroupName, Config) ->
 end_per_group(_GroupName, Config) ->
     Config.
 
+init_per_testcase(Func, Config)
+  when Func =:= processes_default_tab_test;
+       Func =:= processes_this_tab ->
+    case erlang:system_info(debug_compiled) of
+        true ->
+            {skip, "Don't run in debug"};
+        false ->
+            [{testcase, Func} | Config]
+    end;
 init_per_testcase(Func, Config) when is_atom(Func), is_list(Config) ->
     [{testcase, Func}|Config].
 
-- 
cgit v1.2.3


From c18f95e787125f8be5a5b1731b896f7008a5d5db Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Tue, 19 Mar 2019 14:08:16 +0100
Subject: erts: erts_factory_proc_init should not set hole marker

Setting the hole marker in debug on the entire heap is very slow
so instead we do it in erts_produce_heap.
---
 erts/emulator/beam/erl_message.c | 24 +++++++++++++++++++++---
 erts/emulator/beam/erl_message.h |  2 ++
 erts/emulator/beam/erl_process.h |  3 ---
 erts/emulator/beam/erl_vm.h      |  7 ++++---
 4 files changed, 27 insertions(+), 9 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_message.c b/erts/emulator/beam/erl_message.c
index e350a20339..2a0fb9e2aa 100644
--- a/erts/emulator/beam/erl_message.c
+++ b/erts/emulator/beam/erl_message.c
@@ -1137,10 +1137,28 @@ change_to_off_heap:
     return res;
 }
 
-void erts_factory_proc_init(ErtsHeapFactory* factory,
-			    Process* p)
+void erts_factory_proc_init(ErtsHeapFactory* factory, Process* p)
 {
-    erts_factory_proc_prealloc_init(factory, p, HEAP_LIMIT(p) - HEAP_TOP(p));
+    /* This function does not use HAlloc to allocate on the heap
+       as we do not want to use INIT_HEAP_MEM on the allocated
+       heap as that completely destroys the DEBUG emulators
+       performance. */
+    ErlHeapFragment *bp = p->mbuf;
+    factory->mode     = FACTORY_HALLOC;
+    factory->p        = p;
+    factory->hp_start = HEAP_TOP(p);
+    factory->hp       = factory->hp_start;
+    factory->hp_end   = HEAP_LIMIT(p);
+    factory->off_heap = &p->off_heap;
+    factory->message  = NULL;
+    factory->off_heap_saved.first    = p->off_heap.first;
+    factory->off_heap_saved.overhead = p->off_heap.overhead;
+    factory->heap_frags_saved = bp;
+    factory->heap_frags_saved_used = bp ? bp->used_size : 0;
+    factory->heap_frags = NULL; /* not used */
+    factory->alloc_type = 0; /* not used */
+
+    HEAP_TOP(p) = HEAP_LIMIT(p);
 }
 
 void erts_factory_proc_prealloc_init(ErtsHeapFactory* factory,
diff --git a/erts/emulator/beam/erl_message.h b/erts/emulator/beam/erl_message.h
index e5f623a370..5bd25737a7 100644
--- a/erts/emulator/beam/erl_message.h
+++ b/erts/emulator/beam/erl_message.h
@@ -22,6 +22,7 @@
 #define __ERL_MESSAGE_H__
 
 #include "sys.h"
+#include "erl_vm.h"
 #define ERTS_PROC_SIG_QUEUE_TYPE_ONLY
 #include "erl_proc_sig_queue.h"
 #undef ERTS_PROC_SIG_QUEUE_TYPE_ONLY
@@ -117,6 +118,7 @@ erts_produce_heap(ErtsHeapFactory* factory, Uint need, Uint xtra)
     }
     res = factory->hp;
     factory->hp += need;
+    INIT_HEAP_MEM(res, need);
     return res;
 }
 
diff --git a/erts/emulator/beam/erl_process.h b/erts/emulator/beam/erl_process.h
index 4ffa022d5c..711b73417d 100644
--- a/erts/emulator/beam/erl_process.h
+++ b/erts/emulator/beam/erl_process.h
@@ -1322,9 +1322,6 @@ ERTS_GLB_INLINE void erts_heap_frag_shrink(Process* p, Eterm* hp)
 #endif /* inline */
 
 Eterm* erts_heap_alloc(Process* p, Uint need, Uint xtra);
-#ifdef CHECK_FOR_HOLES
-Eterm* erts_set_hole_marker(Eterm* ptr, Uint sz);
-#endif
 
 extern erts_rwmtx_t erts_cpu_bind_rwmtx;
 /* If any of the erts_system_monitor_* variables are set (enabled),
diff --git a/erts/emulator/beam/erl_vm.h b/erts/emulator/beam/erl_vm.h
index 35eae18394..e623148587 100644
--- a/erts/emulator/beam/erl_vm.h
+++ b/erts/emulator/beam/erl_vm.h
@@ -67,9 +67,10 @@
                  (unsigned long)HEAP_TOP(p),(sz),__FILE__,__LINE__)),   \
  */
 #  ifdef CHECK_FOR_HOLES
-#    define INIT_HEAP_MEM(p,sz) erts_set_hole_marker(HEAP_TOP(p), (sz))
+Eterm* erts_set_hole_marker(Eterm* ptr, Uint sz);
+#    define INIT_HEAP_MEM(p,sz) erts_set_hole_marker(p, (sz))
 #  else
-#    define INIT_HEAP_MEM(p,sz) sys_memset(HEAP_TOP(p),0x01,(sz)*sizeof(Eterm*))
+#    define INIT_HEAP_MEM(p,sz) sys_memset(p,0x01,(sz)*sizeof(Eterm*))
 #  endif
 #else
 #  define INIT_HEAP_MEM(p,sz) ((void)0)
@@ -91,7 +92,7 @@
      ErtsHAllocLockCheck(p),					      \
      (IS_FORCE_HEAP_FRAGS || (((HEAP_LIMIT(p) - HEAP_TOP(p)) < (sz))) \
       ? erts_heap_alloc((p),(sz),(xtra))                              \
-      : (INIT_HEAP_MEM(p,sz),		                              \
+      : (INIT_HEAP_MEM(HEAP_TOP(p),sz),                               \
          HEAP_TOP(p) = HEAP_TOP(p) + (sz), HEAP_TOP(p) - (sz))))
 
 #define HAlloc(P, SZ) HAllocX(P,SZ,0)
-- 
cgit v1.2.3


From 80beed3bebbdacf8acdb6cc93992c4a473dac492 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Thu, 21 Mar 2019 10:38:13 +0100
Subject: Fix tests to work better in debug emulator

---
 erts/emulator/test/efile_SUITE.erl   | 7 ++++++-
 erts/emulator/test/process_SUITE.erl | 2 +-
 2 files changed, 7 insertions(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/test/efile_SUITE.erl b/erts/emulator/test/efile_SUITE.erl
index 7dcf302742..55c5343739 100644
--- a/erts/emulator/test/efile_SUITE.erl
+++ b/erts/emulator/test/efile_SUITE.erl
@@ -45,7 +45,12 @@ iter_max_files(Config) when is_list(Config) ->
 iter_max_files_1(Config) ->
     DataDir = proplists:get_value(data_dir,Config),
     TestFile = filename:join(DataDir, "existing_file"),
-    N = 10,
+    case erlang:system_info(debug_compiled) of
+        true ->
+            N = 5;
+        false ->
+            N = 10
+    end,
     %% Run on a different node in order to make the test more stable.
     Dir = filename:dirname(code:which(?MODULE)),
     {ok,Node} = test_server:start_node(test_iter_max_files,slave,
diff --git a/erts/emulator/test/process_SUITE.erl b/erts/emulator/test/process_SUITE.erl
index e009f60860..c698220013 100644
--- a/erts/emulator/test/process_SUITE.erl
+++ b/erts/emulator/test/process_SUITE.erl
@@ -134,7 +134,7 @@ end_per_group(_GroupName, Config) ->
     Config.
 
 init_per_testcase(Func, Config)
-  when Func =:= processes_default_tab_test;
+  when Func =:= processes_default_tab;
        Func =:= processes_this_tab ->
     case erlang:system_info(debug_compiled) of
         true ->
-- 
cgit v1.2.3


From 9eb5e4dc76690ab4059bf94848e41e87cf5606b1 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Fri, 22 Mar 2019 13:29:06 +0100
Subject: erts: Always do trylock on proc locks when crash dumping

---
 erts/emulator/beam/break.c | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/break.c b/erts/emulator/beam/break.c
index 303ab9d9b7..06d8c7cda8 100644
--- a/erts/emulator/beam/break.c
+++ b/erts/emulator/beam/break.c
@@ -75,6 +75,7 @@ port_info(fmtfn_t to, void *to_arg)
 void
 process_info(fmtfn_t to, void *to_arg)
 {
+    ErtsSchedulerData *esdp = erts_get_scheduler_data();
     int i, max = erts_ptab_max(&erts_proc);
     for (i = 0; i < max; i++) {
 	Process *p = erts_pix2proc(i);
@@ -82,8 +83,11 @@ process_info(fmtfn_t to, void *to_arg)
 	    /* Do not include processes with no heap,
 	     * they are most likely just created and has invalid data
 	     */
-	    if (p->heap != NULL)
-		print_process_info(to, to_arg, p, 0);
+	    if (p->heap != NULL) {
+                ErtsProcLocks locks = (p == esdp->current_process ||
+                                       p == esdp->free_process) ? ERTS_PROC_LOCK_MAIN : 0;
+		print_process_info(to, to_arg, p, locks);
+            }
 	}
     }
 
@@ -221,7 +225,7 @@ static int doit_print_monitor(ErtsMonitor *mon, void *vpcontext, Sint reds)
     }
     return 1;
 }
-			       
+
 /* Display info about an individual Erlang process */
 void
 print_process_info(fmtfn_t to, void *to_arg, Process *p, ErtsProcLocks orig_locks)
@@ -254,7 +258,7 @@ print_process_info(fmtfn_t to, void *to_arg, Process *p, ErtsProcLocks orig_lock
 
     if (!(locks & ERTS_PROC_LOCK_MAIN)) {
         locks |= ERTS_PROC_LOCK_MAIN;
-        if (ERTS_IS_CRASH_DUMPING && running) {
+        if (ERTS_IS_CRASH_DUMPING) {
             if (erts_proc_trylock(p, locks)) {
                 /* crash dumping and main lock taken, this probably means that
                    the process is doing a GC on a dirty-scheduler... so we cannot
-- 
cgit v1.2.3


From 87c2fb2e0b1d376a367a4066703db342faadd6d5 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Fri, 22 Mar 2019 13:31:21 +0100
Subject: erts: Fix non-payload dist exit signals

When interacting with jinterface and erl_interface
the old dist messages are used and they incorrectly
used the external data.
---
 erts/emulator/beam/dist.c | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'erts')

diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index 4c200ecc83..8669cc16c9 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -1913,6 +1913,7 @@ int erts_net_message(Port *prt,
                 goto invalid_message;
             }
             reason = tuple[5];
+            edep = NULL;
         }
 
 	if (is_not_ref(ref))
@@ -1959,12 +1960,14 @@ int erts_net_message(Port *prt,
 	    }
 	    token = NIL;
 	    reason = tuple[4];
+            edep = NULL;
 	} else if (type == DOP_EXIT_TT){
 	    if (tuple_arity != 5) {
 		goto invalid_message;
 	    }
 	    token = tuple[4];
 	    reason = tuple[5];
+            edep = NULL;
 	} else if (type == DOP_PAYLOAD_EXIT) {
             if (tuple_arity != 3) {
 		goto invalid_message;
@@ -2012,12 +2015,14 @@ int erts_net_message(Port *prt,
 	    }
 	    reason = tuple[4];
 	    token = NIL;
+            edep = NULL;
 	} else if (type == DOP_EXIT2_TT) {
 	    if (tuple_arity != 5) {
 		goto invalid_message;
 	    }
 	    token = tuple[4];
 	    reason = tuple[5];
+            edep = NULL;
 	} else if (type == DOP_PAYLOAD_EXIT2) {
             if (tuple_arity != 3) {
 		goto invalid_message;
-- 
cgit v1.2.3


From 9426d0cbb790b50ad5afcf348bb24e73e6b7b2da Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Fri, 22 Mar 2019 13:31:49 +0100
Subject: erts: Adjust dist obuf size correctly after hdr fin

---
 erts/emulator/beam/dist.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'erts')

diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index 8669cc16c9..faed10ff91 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -2885,7 +2885,9 @@ erts_dist_command(Port *prt, int initial_reds)
 	    ob = oq.first;
 	    ASSERT(ob);
 	    do {
+                obufsize += size_obuf(ob);
 		reds = erts_encode_ext_dist_header_finalize(ob, dep, flags, reds);
+                obufsize -= size_obuf(ob);
                 if (reds < 0)
                     break;
                 last_finalized  = ob;
@@ -2924,7 +2926,9 @@ erts_dist_command(Port *prt, int initial_reds)
 	while (oq.first && !preempt) {
 	    ErtsDistOutputBuf *fob;
 	    Uint size;
+            obufsize += size_obuf(oq.first);
             reds = erts_encode_ext_dist_header_finalize(oq.first, dep, flags, reds);
+            obufsize -= size_obuf(oq.first);
             if (reds < 0) {
                 preempt = 1;
                 break;
-- 
cgit v1.2.3


From ea8cff230088d442539976c75b85368d38429b06 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Fri, 22 Mar 2019 13:32:16 +0100
Subject: etp: Don't crash etp-stack* when c_p->i is null

---
 erts/etc/unix/etp-commands.in | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'erts')

diff --git a/erts/etc/unix/etp-commands.in b/erts/etc/unix/etp-commands.in
index e8dc59156f..dc28107ef5 100644
--- a/erts/etc/unix/etp-commands.in
+++ b/erts/etc/unix/etp-commands.in
@@ -1453,8 +1453,10 @@ define etp-stack-preamble
   set $etp_stack_p = ($arg0)->stop
   set $etp_stack_end = ($arg0)->hend
   printf "%% Stacktrace (%u)\n", $etp_stack_end-$etp_stack_p
-  etp-1 ((Eterm)($arg0)->i) 0
-  printf "  (I)\n"
+  if ($arg0)->i != 0
+    etp-1 ((Eterm)($arg0)->i) 0
+    printf "  (I)\n"
+  end
   if ($arg0)->cp != 0
     etp-1 ((Eterm)($arg0)->cp) 0
     printf "  (cp)\n"
-- 
cgit v1.2.3


From efff0397b63e5a0ef8676178af89991b97e31dbb Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 25 Mar 2019 11:42:45 +0100
Subject: erts: Fix faulty assert in reference_table_term

---
 erts/emulator/beam/erl_node_tables.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_node_tables.c b/erts/emulator/beam/erl_node_tables.c
index 215dc6fa71..49dea8919b 100644
--- a/erts/emulator/beam/erl_node_tables.c
+++ b/erts/emulator/beam/erl_node_tables.c
@@ -2295,7 +2295,7 @@ reference_table_term(Uint **hpp, ErlOffHeap *ohp, Uint *szp)
                 tup = MK_2TUP(AM_ets, drp->id);
             }
 	    else {
-		ASSERT(!drp->ctrl_ref && drp->node_ref && !drp->signal_ref);
+		ASSERT(!drp->ctrl_ref && (drp->node_ref || drp->sequence_ref) && !drp->signal_ref);
 		ASSERT(is_atom(drp->id));
 		tup = MK_2TUP(drp->id, MK_UINT(drp->creation));
 		tup = MK_2TUP(AM_node, tup);
-- 
cgit v1.2.3


From ef8db1270fc26dfad1ff467ee0acc87439d2c756 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 25 Mar 2019 11:43:43 +0100
Subject: erts: Pending signals can be for free processes

Since we no schedule free processes multiple times, pending
signals can be from free as well as current processes.
---
 erts/emulator/beam/erl_proc_sig_queue.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_proc_sig_queue.c b/erts/emulator/beam/erl_proc_sig_queue.c
index bd59c4afa3..aae976ccb9 100644
--- a/erts/emulator/beam/erl_proc_sig_queue.c
+++ b/erts/emulator/beam/erl_proc_sig_queue.c
@@ -611,7 +611,8 @@ proc_queue_signal(Process *c_p, Eterm pid, ErtsSignal *sig, int op)
 #endif
                 return 1;
             }
-            ASSERT(esdp->pending_signal.dbg_from == esdp->current_process);
+            ASSERT(esdp->pending_signal.dbg_from == esdp->current_process ||
+                   esdp->pending_signal.dbg_from == esdp->free_process);
             if (pend_sig != sig) {
                 /* Switch them and send previously pending signal instead */
                 Eterm pend_to = esdp->pending_signal.to;
-- 
cgit v1.2.3


From 7149d49992fb1a13c6753638733b59015c28c0a5 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 25 Mar 2019 11:45:50 +0100
Subject: erts: Fix so that exit/down terms stay alive

When the GC is run or the link/monitor node is deleted,
the terms associated with it will also be deallocated
so we have to make sure that we don't do any GCs and that
all link/monitor nodes are copied onto the heap before
the node is deallocated.
---
 erts/emulator/beam/erl_process.c | 43 ++++++++++++++++++++++++++++++----------
 1 file changed, 33 insertions(+), 10 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index f34289339f..6a0c5bde58 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -12090,9 +12090,11 @@ erts_proc_exit_handle_dist_monitor(ErtsMonitor *mon, void *vctxt, Sint reds)
     ErtsDSigSendContext ctx;
     ErtsMonLnkDist *dist;
     DistEntry *dep;
-    Eterm watcher;
+    Eterm watcher, ref, *hp;
     ErtsMonitorData *mdp = NULL;
     Eterm watched;
+    Uint watcher_sz, ref_sz;
+    ErtsHeapFactory factory;
 
     ASSERT(erts_monitor_is_target(mon) && mon->type == ERTS_MON_TYPE_DIST_PROC);
 
@@ -12124,10 +12126,18 @@ erts_proc_exit_handle_dist_monitor(ErtsMonitor *mon, void *vctxt, Sint reds)
     case ERTS_DSIG_PREP_CONNECTED:
         if (dist->connection_id != ctx.connection_id)
             break;
+        erts_factory_proc_init(&factory, c_p);
+        watcher_sz = size_object(watcher);
+        hp = erts_produce_heap(&factory, watcher_sz, 0);
+        watcher = copy_struct(watcher, watcher_sz, &hp, factory.off_heap);
+        ref_sz = size_object(mdp->ref);
+        hp = erts_produce_heap(&factory, ref_sz, 0);
+        ref = copy_struct(mdp->ref, ref_sz, &hp, factory.off_heap);
+        erts_factory_close(&factory);
         code = erts_dsig_send_m_exit(&ctx,
                                      watcher,
                                      watched,
-                                     mdp->ref,
+                                     ref,
                                      reason);
         switch (code) {
         case ERTS_DSIG_SEND_CONTINUE:
@@ -12332,13 +12342,15 @@ erts_proc_exit_handle_dist_link(ErtsLink *lnk, void *vctxt, Sint reds)
 {
     ErtsProcExitContext *ctxt = (ErtsProcExitContext *) vctxt;
     Process *c_p = ctxt->c_p;
-    Eterm reason = ctxt->reason;
+    Eterm reason = ctxt->reason, item, *hp;
+    Uint item_sz;
     int code;
     ErtsDSigSendContext ctx;
     ErtsMonLnkDist *dist;
     DistEntry *dep;
     ErtsLink *dlnk;
     ErtsLinkData *ldp = NULL;
+    ErtsHeapFactory factory;
 
     ASSERT(lnk->type == ERTS_LNK_TYPE_DIST_PROC);
     dlnk = erts_link_to_other(lnk, &ldp);
@@ -12365,9 +12377,14 @@ erts_proc_exit_handle_dist_link(ErtsLink *lnk, void *vctxt, Sint reds)
     case ERTS_DSIG_PREP_CONNECTED:
         if (dist->connection_id != ctx.connection_id)
             break;
+        erts_factory_proc_init(&factory, c_p);
+        item_sz = size_object(lnk->other.item);
+        hp = erts_produce_heap(&factory, item_sz, 0);
+        item = copy_struct(lnk->other.item, item_sz, &hp, factory.off_heap);
+        erts_factory_close(&factory);
         code = erts_dsig_send_exit_tt(&ctx,
                                       c_p->common.id,
-                                      lnk->other.item,
+                                      item,
                                       reason,
                                       SEQ_TRACE_TOKEN(c_p));
         switch (code) {
@@ -12584,6 +12601,8 @@ erts_continue_exit_process(Process *p)
 
     if (p->u.terminate) {
         trap_state = p->u.terminate;
+        /* Re-set the reason as it may have been gc:ed */
+        trap_state->reason = p->fvalue;
     } else {
         trap_state->phase = ERTS_CONTINUE_EXIT_TIMERS;
         trap_state->reason = p->fvalue;
@@ -12661,11 +12680,11 @@ restart:
             p->flags &= ~F_USING_DB;
         }
 
-        erts_set_gc_state(p, 1);
-
         trap_state->phase = ERTS_CONTINUE_EXIT_CLEAN_SYS_TASKS;
     case ERTS_CONTINUE_EXIT_CLEAN_SYS_TASKS:
-        
+
+        /* We enable GC again as it can produce more sys-tasks */
+        erts_set_gc_state(p, 1);
         state = erts_atomic32_read_acqb(&p->state);
         if ((state & ERTS_PSFLG_SYS_TASKS) || p->dirty_sys_tasks) {
             reds -= cleanup_sys_tasks(p, state, reds);
@@ -12788,6 +12807,9 @@ restart:
             erts_deref_dist_entry(trap_state->dep);
         }
 
+        /* Disable GC so that reason does not get moved */
+        erts_set_gc_state(p, 0);
+
         trap_state->pectxt.c_p = p;
         trap_state->pectxt.reason = trap_state->reason;
         trap_state->pectxt.dist_links = NULL;
@@ -12878,7 +12900,7 @@ restart:
                 goto yield;
             }
             }
-            erts_set_gc_state(p, 1);
+
             trap_state->pectxt.dist_state = NIL;
             if (reds <= 0)
                 goto yield;
@@ -12917,11 +12939,12 @@ restart:
          * From this point on we are no longer allowed to yield
          * this process.
          */
-
 #ifdef DEBUG
         yield_allowed = 0;
 #endif
 
+        erts_set_gc_state(p, 1);
+
         /* Set state to not active as we don't want this process
            to be scheduled in again after this. */
         state = erts_atomic32_read_band_relb(&p->state,
@@ -12960,7 +12983,7 @@ restart:
         erts_free(ERTS_ALC_T_CONT_EXIT_TRAP, trap_state);
         p->u.terminate = NULL;
     }
-    
+
     ERTS_CHK_HAVE_ONLY_MAIN_PROC_LOCK(p);
 
     if (IS_TRACED_FL(p, F_TRACE_SCHED_EXIT))
-- 
cgit v1.2.3


From 6907100826bf1956a8dbeb16ba2e736199913d0a Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 25 Mar 2019 13:36:01 +0100
Subject: erts: Include dist header in return from dist_ctrl_get_data

---
 erts/emulator/beam/dist.c | 68 ++++++++++++++++++++++++++++++++++-------------
 1 file changed, 49 insertions(+), 19 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index faed10ff91..8bbe6450eb 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -3361,14 +3361,13 @@ dist_ctrl_get_data_1(BIF_ALIST_1)
 {
     DistEntry *dep = ERTS_PROC_GET_DIST_ENTRY(BIF_P);
     const Sint initial_reds = ERTS_BIF_REDS_LEFT(BIF_P);
-    Sint reds = initial_reds;
+    Sint reds = initial_reds, obufsize = 0;
     ErtsDistOutputBuf *obuf;
-    Eterm *hp;
+    Eterm *hp, res;
     ProcBin *pb;
     erts_aint_t qsize;
     Uint32 conn_id, get_size;
-    Eterm res;
-    Uint hsz, bin_sz;
+    Uint hsz = 0, bin_sz;
 
     if (!dep)
         BIF_ERROR(BIF_P, EXC_NOTSUP);
@@ -3420,7 +3419,9 @@ dist_ctrl_get_data_1(BIF_ALIST_1)
         }
 
         obuf = dep->tmp_out_queue.first;
+        obufsize += size_obuf(obuf);
         reds = erts_encode_ext_dist_header_finalize(obuf, dep, dep->flags, reds);
+        obufsize -= size_obuf(obuf);
         if (reds < 0) {
             erts_de_runlock(dep);
             ERTS_BIF_YIELD1(bif_export[BIF_dist_ctrl_get_data_1],
@@ -3436,8 +3437,7 @@ dist_ctrl_get_data_1(BIF_ALIST_1)
 
     erts_de_runlock(dep);
 
-    bin_sz = obuf->ext_endp - obuf->extp;
-    hsz = PROC_BIN_SIZE;
+    bin_sz = obuf->ext_endp - obuf->extp + obuf->hdr_endp - obuf->hdrp;
 
     get_size = dep->opts & ERTS_DIST_CTRL_OPT_GET_SIZE;
     if (get_size) {
@@ -3446,18 +3446,50 @@ dist_ctrl_get_data_1(BIF_ALIST_1)
             hsz += BIG_UINT_HEAP_SIZE;
     }
 
-    hp = HAlloc(BIF_P, hsz);
-    pb = (ProcBin *) (char *) hp;
-    pb->thing_word = HEADER_PROC_BIN;
-    pb->size = bin_sz;
-    pb->next = MSO(BIF_P).first;
-    MSO(BIF_P).first = (struct erl_off_heap_header*) pb;
-    pb->val = ErtsDistOutputBuf2Binary(obuf);
-    pb->bytes = (byte*) obuf->extp;
-    pb->flags = 0;
-    hp += PROC_BIN_SIZE;
+    if (!obuf->hdrp) {
+        hp =  HAlloc(BIF_P, PROC_BIN_SIZE + hsz);
+        pb = (ProcBin *) (char *) hp;
+        pb->thing_word = HEADER_PROC_BIN;
+        pb->size = obuf->ext_endp - obuf->extp;
+        pb->next = MSO(BIF_P).first;
+        MSO(BIF_P).first = (struct erl_off_heap_header*) pb;
+        pb->val = ErtsDistOutputBuf2Binary(obuf);
+        pb->bytes = (byte*) obuf->extp;
+        pb->flags = 0;
+        res = make_binary(pb);
+    } else {
+        hp =  HAlloc(BIF_P, PROC_BIN_SIZE * 2 + 4 + hsz);
+        pb = (ProcBin *) (char *) hp;
+        pb->thing_word = HEADER_PROC_BIN;
+        pb->size = obuf->ext_endp - obuf->extp;
+        pb->next = MSO(BIF_P).first;
+        MSO(BIF_P).first = (struct erl_off_heap_header*) pb;
+        pb->val = ErtsDistOutputBuf2Binary(obuf);
+        pb->bytes = (byte*) obuf->extp;
+        pb->flags = 0;
+        hp += PROC_BIN_SIZE;
+
+        res = CONS(hp, make_binary(pb), NIL);
+        hp += 2;
+
+        pb = (ProcBin *) (char *) hp;
+        pb->thing_word = HEADER_PROC_BIN;
+        pb->size = obuf->hdr_endp - obuf->hdrp;
+        pb->next = MSO(BIF_P).first;
+        MSO(BIF_P).first = (struct erl_off_heap_header*) pb;
+        pb->val = ErtsDistOutputBuf2Binary(obuf);
+        erts_refc_inc(&pb->val->intern.refc, 1);
+        pb->bytes = (byte*) obuf->hdrp;
+        pb->flags = 0;
+        hp += PROC_BIN_SIZE;
+        res = CONS(hp, make_binary(pb), res);
+        hp += 2;
+    }
+
+    obufsize += size_obuf(obuf);
+
+    qsize = erts_atomic_add_read_nob(&dep->qsize, (erts_aint_t) -obufsize);
 
-    qsize = erts_atomic_add_read_nob(&dep->qsize, -size_obuf(obuf));
     ASSERT(qsize >= 0);
 
     if (qsize < erts_dist_buf_busy_limit/2
@@ -3472,8 +3504,6 @@ dist_ctrl_get_data_1(BIF_ALIST_1)
         }
     }
 
-    res = make_binary(pb);
-
     if (get_size) {
         Eterm sz_term;
         if (IS_USMALL(0, bin_sz))
-- 
cgit v1.2.3


From 7b6c36d65fabd9ba43beb2fa56cc1a17249aac64 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 25 Mar 2019 14:34:45 +0100
Subject: erts: Include external msg in need of GC

When many external messages suddenly appear in the mailbox
the young gen size is adjusted accordingly but it was
immediately shrunk as the data was not counted towards the
shrink size. This commit includes the ext dist size in the
shrink calculation which means that the decode of the external
messages will not trigger as many GCs which means much better
performance.
---
 erts/emulator/beam/erl_gc.c | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index 9317850d96..67a73e4d57 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -577,7 +577,7 @@ force_reschedule:
 }
 
 static ERTS_FORCE_INLINE Uint
-young_gen_usage(Process *p)
+young_gen_usage(Process *p, Uint *ext_msg_usage)
 {
     Uint hsz;
     Eterm *aheap;
@@ -604,7 +604,10 @@ young_gen_usage(Process *p)
                 if (ERTS_SIG_IS_MSG(mp)
                     && mp->data.attached
                     && mp->data.attached != ERTS_MSG_COMBINED_HFRAG) {
-                    hsz += erts_msg_attached_data_size(mp);
+                    Uint sz = erts_msg_attached_data_size(mp);
+                    if (ERTS_SIG_IS_EXTERNAL_MSG(mp))
+                        *ext_msg_usage += sz;
+                    hsz += sz;
                 }
             });
     }
@@ -676,6 +679,7 @@ garbage_collect(Process* p, ErlHeapFragment *live_hf_end,
 {
     Uint reclaimed_now = 0;
     Uint ygen_usage;
+    Uint ext_msg_usage = 0;
     Eterm gc_trace_end_tag;
     int reds;
     ErtsMonotonicTime start_time;
@@ -698,7 +702,7 @@ garbage_collect(Process* p, ErlHeapFragment *live_hf_end,
 	return delay_garbage_collection(p, live_hf_end, need, fcalls);
     }
 
-    ygen_usage = max_young_gen_usage ? max_young_gen_usage : young_gen_usage(p);
+    ygen_usage = max_young_gen_usage ? max_young_gen_usage : young_gen_usage(p, &ext_msg_usage);
 
     if (!ERTS_SCHEDULER_IS_DIRTY(esdp)) {
 	check_for_possibly_long_gc(p, ygen_usage);
@@ -739,7 +743,7 @@ garbage_collect(Process* p, ErlHeapFragment *live_hf_end,
             trace_gc(p, am_gc_minor_start, need, THE_NON_VALUE);
         }
         DTRACE2(gc_minor_start, pidbuf, need);
-        reds = minor_collection(p, live_hf_end, need, objv, nobj,
+        reds = minor_collection(p, live_hf_end, need + ext_msg_usage, objv, nobj,
 				ygen_usage, &reclaimed_now);
         DTRACE2(gc_minor_end, pidbuf, reclaimed_now);
         if (reds == -1) {
@@ -764,7 +768,7 @@ do_major_collection:
             trace_gc(p, am_gc_major_start, need, THE_NON_VALUE);
         }
         DTRACE2(gc_major_start, pidbuf, need);
-        reds = major_collection(p, live_hf_end, need, objv, nobj,
+        reds = major_collection(p, live_hf_end, need + ext_msg_usage, objv, nobj,
 				ygen_usage, &reclaimed_now);
         if (ERTS_SCHEDULER_IS_DIRTY(esdp))
             p->flags &= ~(F_DIRTY_MAJOR_GC|F_DIRTY_MINOR_GC);
@@ -1101,6 +1105,7 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
     Eterm* old_htop;
     Uint n;
     Uint ygen_usage = 0;
+    Uint ext_msg_usage = 0;
     struct erl_off_heap_header** prev = NULL;
     Sint64 reds;
     int hibernated = !!(p->flags & F_HIBERNATED);
@@ -1118,7 +1123,7 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
 	p->flags &= ~F_DIRTY_CLA;
     else {
         Uint size = byte_lit_size/sizeof(Uint);
-	ygen_usage = young_gen_usage(p);
+	ygen_usage = young_gen_usage(p, &ext_msg_usage);
         if (hibernated)
             size = size*2 + 3*ygen_usage;
         else
@@ -1130,7 +1135,7 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
 	}
     }
 
-    reds = (Sint64) garbage_collect(p, ERTS_INVALID_HFRAG_PTR, 0,
+    reds = (Sint64) garbage_collect(p, ERTS_INVALID_HFRAG_PTR, ext_msg_usage,
 				    p->arg_reg, p->arity, fcalls,
 				    ygen_usage);
     if (ERTS_PROC_IS_EXITING(p)) {
@@ -1348,6 +1353,9 @@ minor_collection(Process* p, ErlHeapFragment *live_hf_end,
     Eterm *mature = p->abandoned_heap ? p->abandoned_heap : p->heap;
     Uint mature_size = p->high_water - mature;
     Uint size_before = ygen_usage;
+#ifdef DEBUG
+    Uint debug_tmp = 0;
+#endif
 
     /*
      * Check if we have gone past the max heap size limit
@@ -1484,7 +1492,7 @@ minor_collection(Process* p, ErlHeapFragment *live_hf_end,
            process from there */
         ASSERT(!MAX_HEAP_SIZE_GET(p) ||
                !(MAX_HEAP_SIZE_FLAGS_GET(p) & MAX_HEAP_SIZE_KILL) ||
-               MAX_HEAP_SIZE_GET(p) > (young_gen_usage(p) +
+               MAX_HEAP_SIZE_GET(p) > (young_gen_usage(p, &debug_tmp) +
                                        (OLD_HEND(p) - OLD_HEAP(p)) +
                                        (HEAP_END(p) - HEAP_TOP(p))));
 
-- 
cgit v1.2.3


From 922fd35583157596559227e0ec9e0163e8c3b9bc Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang.org>
Date: Mon, 25 Mar 2019 17:53:49 +0100
Subject: erts: Yield when exiting/free process is suspended by de

---
 erts/emulator/beam/erl_process.c          |  2 +-
 erts/emulator/test/distribution_SUITE.erl | 16 +++++++++++-----
 2 files changed, 12 insertions(+), 6 deletions(-)

(limited to 'erts')

diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index 6a0c5bde58..9e662632b4 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -12894,8 +12894,8 @@ restart:
             switch (result) {
             case ERTS_DSIG_SEND_OK:
             case ERTS_DSIG_SEND_TOO_LRG: /*SEND_SYSTEM_LIMIT*/
-            case ERTS_DSIG_SEND_YIELD: /*SEND_YIELD_RETURN*/
                 break;
+            case ERTS_DSIG_SEND_YIELD: /*SEND_YIELD_RETURN*/
             case ERTS_DSIG_SEND_CONTINUE: { /*SEND_YIELD_CONTINUE*/
                 goto yield;
             }
diff --git a/erts/emulator/test/distribution_SUITE.erl b/erts/emulator/test/distribution_SUITE.erl
index 32d53ec7cd..449821e5ad 100644
--- a/erts/emulator/test/distribution_SUITE.erl
+++ b/erts/emulator/test/distribution_SUITE.erl
@@ -1422,7 +1422,7 @@ message_latency_large_exit(Nodename, ReasonFun) ->
 
               FlushTrace = fun F() ->
                                    receive
-                                       {trace, Pid, _, _} = M ->
+                                       {trace, Pid, _, _} ->
                                            F()
                                    after 0 ->
                                            ok
@@ -1456,8 +1456,14 @@ measure_latency_large_message(Nodename, DataFun) ->
 
     Echo = spawn(N, fun F() -> receive {From, Msg} -> From ! Msg, F() end end),
 
-    %% Test 32 MB and 320 MB and test the latency difference of sent messages
-    Payloads = [{I, <<0:(I * 32 * 1024 * 1024 * 8)>>} || I <- [1,10]],
+    case erlang:system_info(build_type) of
+        debug ->
+            %% Test 3.2 MB and 32 MB and test the latency difference of sent messages
+            Payloads = [{I, <<0:(I * 32 * 1024 * 8)>>} || I <- [1,10]];
+        _ ->
+            %% Test 32 MB and 320 MB and test the latency difference of sent messages
+            Payloads = [{I, <<0:(I * 32 * 1024 * 1024 * 8)>>} || I <- [1,10]]
+    end,
 
     IndexTimes = [{I, measure_latency(DataFun, Dropper, Echo, P)}
                   || {I, P} <- Payloads],
@@ -1490,7 +1496,7 @@ measure_latency(DataFun, Dropper, Echo, Payload) ->
                  end) || _ <- lists:seq(1,2)],
 
     [receive
-         {monitor, _Sender, busy_dist_port, _Info} = M ->
+         {monitor, _Sender, busy_dist_port, _Info} ->
              ok
      end || _ <- lists:seq(1,10)],
 
@@ -1736,7 +1742,7 @@ bad_dist_fragments(Config) when is_list(Config) ->
 
     start_monitor(Offender,P),
     Exit2Victim = spawn(Victim, fun() -> receive ok -> ok end end),
-    send_bad_fragments(Offender, Victim, P,{?DOP_PAYLOAD_EXIT2,P,ExitVictim},2,
+    send_bad_fragments(Offender, Victim, P,{?DOP_PAYLOAD_EXIT2,P,Exit2Victim},2,
                       [{hdr, 1, [132]}]),
 
     start_monitor(Offender,P),
-- 
cgit v1.2.3