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/emulator/beam')

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 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 ++++++++------
 4 files changed, 57 insertions(+), 9 deletions(-)

(limited to 'erts/emulator/beam')

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);
-- 
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/emulator/beam')

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 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/emulator/beam')

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/emulator/beam')

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/emulator/beam')

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 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/emulator/beam')

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/emulator/beam')

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/emulator/beam')

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/emulator/beam')

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/emulator/beam')

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 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'erts/emulator/beam')

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;
             }
-- 
cgit v1.2.3