Merge pull request #1637 from pguyot/w17/merge-main

Merge main into feature/distributed-erlang

These changes are made under both the "Apache 2.0" and the "GNU Lesser General
Public License 2.1 or later" license terms (dual license).

SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later

Author: bettio

.github/workflows/build-and-test-other.yaml

@@ -94,7 +94,7 @@ jobs:
 
         - arch: "arm32v7"
           platform: "arm/v7"
-          tag: "bullseye"
+          tag: "bookworm"
           # -D_FILE_OFFSET_BITS=64 is required for making atomvm:posix_readdir/1 test work
           # otherwise readdir will fail due to 64 bits inode numbers with 32 bit ino_t
           cflags: "-mcpu=cortex-a7 -mfloat-abi=hard -O2 -mthumb -mthumb-interwork -D_FILE_OFFSET_BITS=64"

CHANGELOG.md

@@ -56,6 +56,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixed `gen_server` internal messages to match OTP so it works across erlang distribution
 - Utilize reserved `phy_init` partition on ESP32 to store wifi calibration for faster connections.
 - Support for zero count in `lists:duplicate/2`.
+- packbeam: fix memory leak preventing building with address sanitizer
 
 ## [0.6.6] - Unreleased
 
@@ -119,6 +120,7 @@ memory error
 - Fixed segfault when calling `lists:reverse/1` (#1600)
 - Fixed nif_atomvm_posix_read GC bug
 - Fixed `erlang:is_number/1` function, now returns true also for floats
+- Fixed unlink protocol and add support for `link/1` on ports
 
 ### Changed
 

CMakeModules/BuildElixir.cmake

@@ -94,3 +94,64 @@ macro(pack_runnable avm_name main)
     add_dependencies(${avm_name} ${avm_name}_main ${ARCHIVE_TARGETS} PackBEAM)
 
 endmacro()
+
+
+macro(pack_test avm_name main)
+    find_package(Elixir REQUIRED)
+
+    # Compile the main module
+    add_custom_command(
+        OUTPUT Elixir.${main}.beam
+        COMMAND elixirc ${CMAKE_CURRENT_SOURCE_DIR}/${main}.ex
+        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${main}.ex
+        COMMENT "Compiling ${main}.ex"
+        VERBATIM
+    )
+
+    add_custom_target(
+        ${avm_name}_main
+        DEPENDS Elixir.${main}.beam
+    )
+
+    # Compile test modules
+    foreach(module_name ${ARGN})
+        add_custom_command(
+            OUTPUT Elixir.${module_name}.beam
+            COMMAND elixirc ${CMAKE_CURRENT_SOURCE_DIR}/${module_name}.ex
+            DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${module_name}.ex
+            COMMENT "Compiling ${module_name}.ex"
+            VERBATIM
+        )
+        set(TEST_BEAMS ${TEST_BEAMS} Elixir.${module_name}.beam)
+    endforeach()
+
+    add_custom_target(
+        ${avm_name}_tests
+        DEPENDS ${TEST_BEAMS}
+    )
+
+    if(AVM_RELEASE)
+        set(INCLUDE_LINES "")
+    else()
+        set(INCLUDE_LINES "-i")
+    endif()
+
+    # Set up standard libraries
+    set(ARCHIVE_TARGETS estdlib eavmlib exavmlib etest)
+    foreach(archive_name ${ARCHIVE_TARGETS})
+        if(${archive_name} STREQUAL "exavmlib")
+            set(ARCHIVES ${ARCHIVES} ${CMAKE_BINARY_DIR}/libs/${archive_name}/lib/${archive_name}.avm)
+        else()
+            set(ARCHIVES ${ARCHIVES} ${CMAKE_BINARY_DIR}/libs/${archive_name}/src/${archive_name}.avm)
+        endif()
+    endforeach()
+
+    add_custom_target(
+        ${avm_name} ALL
+        COMMAND ${CMAKE_BINARY_DIR}/tools/packbeam/PackBEAM ${INCLUDE_LINES} ${avm_name}.avm Elixir.${main}.beam ${TEST_BEAMS} ${ARCHIVES}
+        COMMENT "Packing test ${avm_name}.avm"
+        VERBATIM
+    )
+    add_dependencies(${avm_name} ${avm_name}_main ${avm_name}_tests ${ARCHIVE_TARGETS} PackBEAM)
+
+endmacro()

src/libAtomVM/context.c

@@ -150,18 +150,45 @@ struct Context
 typedef struct Context Context;
 #endif
 
-#define CONTEXT_MONITOR_RESOURCE_TAG 0x2
-#define CONTEXT_MONITOR_MONITORED_PID_TAG 0x3
-#define CONTEXT_MONITOR_MONITORING_PID_TAG 0x1
+enum ContextMonitorType
+{
+    CONTEXT_MONITOR_LINK_LOCAL,
+    CONTEXT_MONITOR_MONITORING_LOCAL,
+    CONTEXT_MONITOR_MONITORED_LOCAL,
+    CONTEXT_MONITOR_RESOURCE,
+};
+
+#define UNLINK_ID_LINK_ACTIVE 0x0
 
 /**
  * @brief A regular monitor or a half link.
  */
 struct Monitor
 {
     struct ListHead monitor_list_head;
-    uint64_t ref_ticks; // 0 for links
-    term monitor_obj; // pid for links, CONTEXT_MONITOR_*_TAG for monitors
+    enum ContextMonitorType monitor_type;
+};
+
+struct LinkLocalMonitor
+{
+    struct Monitor monitor;
+    uint64_t unlink_id;
+    term link_local_process_id;
+};
+
+struct MonitorLocalMonitor
+{
+    struct Monitor monitor;
+    uint64_t ref_ticks;
+    term monitor_obj;
+};
+
+// The other half is called ResourceMonitor and is a linked list of resources
+struct ResourceContextMonitor
+{
+    struct Monitor monitor;
+    uint64_t ref_ticks;
+    void *resource_obj;
 };
 
 struct ExtendedRegister
@@ -364,9 +391,10 @@ void context_process_kill_signal(Context *ctx, struct TermSignal *signal);
  * @brief Process a process info request signal.
  *
  * @param ctx the context being executed
- * @param signal the kill message
+ * @param signal the process info signal
+ * @param process_table_locked whether process table is already locked
  */
-void context_process_process_info_request_signal(Context *ctx, struct BuiltInAtomRequestSignal *signal);
+void context_process_process_info_request_signal(Context *ctx, struct BuiltInAtomRequestSignal *signal, bool process_table_locked);
 
 /**
  * @brief Process a trap answer signal.
@@ -395,6 +423,23 @@ void context_process_flush_monitor_signal(Context *ctx, uint64_t ref_ticks, bool
  */
 bool context_process_signal_set_group_leader(Context *ctx, struct TermSignal *signal);
 
+/**
+ * @brief Process a link exit signal.
+ *
+ * @param ctx the context being executed
+ * @param signal the signal with the exit info tuple
+ * @return true if the process is trapping exit and info tuple was enqueued as a message;
+ */
+bool context_process_link_exit_signal(Context *ctx, struct TermSignal *signal);
+
+/**
+ * @brief Process a monitor down signal.
+ *
+ * @param ctx the context being executed
+ * @param signal the signal with the down info tuple
+ */
+void context_process_monitor_down_signal(Context *ctx, struct TermSignal *signal);
+
 /**
  * @brief Get process information.
  *
@@ -431,30 +476,53 @@ struct Monitor *monitor_new(term monitor_pid, uint64_t ref_ticks, bool is_monito
  *
  * @param resource resource object
  * @param ref_ticks reference associated with the monitor
- * @param process_id process being monitored
  * @return the allocated resource monitor or NULL if allocation failed
  */
 struct Monitor *monitor_resource_monitor_new(void *resource, uint64_t ref_ticks);
 
 /**
  * @brief Half-unlink process to another process
- * @details Called within the process only. For the other end of the
- * link, an UnlinkSignal is sent that calls this function.
+ * @details If process is found, an unlink id is generated and the link is
+ * deactivated.
  *
  * @param ctx the context being executed
- * @param monitor_pid process to unlink from
- * @return 0 on success
+ * @param link_pid process to unlink from
+ * @param unlink_id on output, unlink id to send to the target process
+ * @return true if process was found
  */
-void context_unlink(Context *ctx, term monitor_pid);
+bool context_set_unlink_id(Context *ctx, term link_pid, uint64_t *unlink_id);
 
 /**
- * @brief Destroy a monitor on a process.
- * @details Called within the process only. This function is called from
- * DemonitorSignal.
+ * @brief Half-unlink process to another process
+ * @details Called within the process only when an UnlinkID signal is received.
+ * If link is found, remove it and sends an UnlinkIDAck signal to the linked
+ * process.
+ *
+ * @param ctx the context being executed
+ * @param link_pid process to unlink from
+ * @param unlink_id unlink id from the signal
+ * @param process_table_locked whether process table is already locked
+ */
+void context_ack_unlink(Context *ctx, term link_pid, uint64_t unlink_id, bool process_table_locked);
+
+/**
+ * @brief Half-unlink process to another process
+ * @details Called within the process only when an UnlinkIDAck signal is received.
+ * If link is found and matches, remove it.
  *
  * @param ctx the context being executed
+ * @param link_pid process to unlink from
+ * @param unlink_id unlink id from the signal
+ */
+void context_unlink_ack(Context *ctx, term link_pid, uint64_t unlink_id);
+
+/**
+ * @brief Destroy a monitor on a process (monitoring, monitored or resource)
+ * @details Called within the process only. This function is called from
+ * DemonitorSignal as well as demonitor nif on monitoring process.
+ *
+ * @param ctx the context being executed (monitoring or monitored)
  * @param ref_ticks reference of the monitor to remove
- * @return 0 on success
  */
 void context_demonitor(Context *ctx, uint64_t ref_ticks);
 
@@ -477,9 +545,12 @@ term context_get_monitor_pid(Context *ctx, uint64_t ref_ticks, bool *is_monitori
  * only exist once.
  *
  * @param ctx the context being executed
- * @param new_monitor monitor object to add
+ * @param new_monitor monitor object to add (ownership belongs to context
+ * afterwards)
+ * @return true if the monitor was added, false if it already existed and
+ * new_monitor waw freed.
  */
-void context_add_monitor(Context *ctx, struct Monitor *new_monitor);
+bool context_add_monitor(Context *ctx, struct Monitor *new_monitor);
 
 #ifdef __cplusplus
 }

src/libAtomVM/context.h

@@ -734,27 +734,3 @@ Module *globalcontext_get_module_by_index(GlobalContext *global, int index)
     SMP_RWLOCK_UNLOCK(global->modules_lock);
     return result;
 }
-
-bool globalcontext_demonitor(GlobalContext *global, uint64_t ref_ticks)
-{
-    struct ListHead *pitem;
-
-    struct ListHead *processes_table_list = synclist_wrlock(&global->processes_table);
-    LIST_FOR_EACH (pitem, processes_table_list) {
-        Context *p = GET_LIST_ENTRY(pitem, Context, processes_table_head);
-
-        struct ListHead *item;
-        LIST_FOR_EACH (item, &p->monitors_head) {
-            struct Monitor *monitor = GET_LIST_ENTRY(item, struct Monitor, monitor_list_head);
-            if (monitor->ref_ticks == ref_ticks) {
-                list_remove(&monitor->monitor_list_head);
-                free(monitor);
-                synclist_unlock(&global->processes_table);
-                return true;
-            }
-        }
-    }
-
-    synclist_unlock(&global->processes_table);
-    return false;
-}

src/libAtomVM/globalcontext.c

@@ -532,17 +532,6 @@ Module *globalcontext_get_module(GlobalContext *global, AtomString module_name_a
  */
 Module *globalcontext_load_module_from_avm(GlobalContext *global, const char *module_name);
 
-/**
- * @brief remove a monitor
- *
- * @details iterate on the list of all processes and then on each monitor
- * to find a given monitor, and remove it
- * @param global the global context
- * @param ref_ticks the reference to the monitor
- * @return true if the monitor was found
- */
-bool globalcontext_demonitor(GlobalContext *global, uint64_t ref_ticks);
-
 #ifndef __cplusplus
 static inline uint64_t globalcontext_get_ref_ticks(GlobalContext *global)
 {

src/libAtomVM/globalcontext.h

@@ -50,7 +50,7 @@ void scan_iff(const void *iff_binary, int buf_size, unsigned long *offsets, unsi
 
     int current_pos = 12;
 
-    uint32_t iff_size = READ_32_ALIGNED(data + 4);
+    uint32_t iff_size = READ_32_UNALIGNED(data + 4);
     int file_size = iff_size;
     if (UNLIKELY(buf_size < file_size)) {
         fprintf(stderr, "error: buffer holding IFF is smaller than IFF size: %i\n", buf_size);

src/libAtomVM/iff.c

@@ -97,7 +97,9 @@ void mailbox_message_dispose(MailboxMessage *m, Heap *heap)
         }
         case KillSignal:
         case TrapAnswerSignal:
-        case SetGroupLeaderSignal: {
+        case SetGroupLeaderSignal:
+        case LinkExitSignal:
+        case MonitorDownSignal: {
             struct TermSignal *term_signal = CONTAINER_OF(m, struct TermSignal, base);
             term mso_list = term_signal->storage[STORAGE_MSO_LIST_INDEX];
             HeapFragment *fragment = mailbox_message_to_heap_fragment(term_signal, term_signal->heap_end);
@@ -110,12 +112,17 @@ void mailbox_message_dispose(MailboxMessage *m, Heap *heap)
             free(request_signal);
             break;
         }
-        case TrapExceptionSignal:
-        case UnlinkSignal: {
+        case TrapExceptionSignal: {
             struct ImmediateSignal *immediate_signal = CONTAINER_OF(m, struct ImmediateSignal, base);
             free(immediate_signal);
             break;
         }
+        case UnlinkIDSignal:
+        case UnlinkIDAckSignal: {
+            struct ImmediateRefSignal *immediate_ref_signal = CONTAINER_OF(m, struct ImmediateRefSignal, base);
+            free(immediate_ref_signal);
+            break;
+        }
         case FlushMonitorSignal:
         case FlushInfoMonitorSignal:
         case DemonitorSignal: {
@@ -308,6 +315,20 @@ void mailbox_send_ref_signal(Context *c, enum MessageType type, uint64_t ref_tic
     mailbox_post_message(c, &ref_signal->base);
 }
 
+void mailbox_send_immediate_ref_signal(Context *c, enum MessageType type, term immediate, uint64_t ref_ticks)
+{
+    struct ImmediateRefSignal *immediate_ref_signal = malloc(sizeof(struct ImmediateRefSignal));
+    if (IS_NULL_PTR(immediate_ref_signal)) {
+        fprintf(stderr, "Failed to allocate memory: %s:%i.\n", __FILE__, __LINE__);
+        return;
+    }
+    immediate_ref_signal->base.type = type;
+    immediate_ref_signal->immediate = immediate;
+    immediate_ref_signal->ref_ticks = ref_ticks;
+
+    mailbox_post_message(c, &immediate_ref_signal->base);
+}
+
 void mailbox_send_monitor_signal(Context *c, enum MessageType type, struct Monitor *monitor)
 {
     struct MonitorPointerSignal *monitor_signal = malloc(sizeof(struct MonitorPointerSignal));