Implement monitoring process by registered name

pguyot · pguyot · commit 9299f6d80b86 · 2025-08-10T10:44:04.000+02:00
Also simplify gen_server implementation when ServerRef is an atom

Signed-off-by: Paul Guyot &lt;pguyot@kallisys.net&gt;
diff --git a/libs/estdlib/src/gen_server.erl b/libs/estdlib/src/gen_server.erl
@@ -387,20 +387,13 @@ stop(ServerRef) ->
 %%-----------------------------------------------------------------------------
 -spec stop(ServerRef :: server_ref(), Reason :: term(), Timeout :: non_neg_integer() | infinity) ->
     ok | {error, Reason :: term()}.
-stop(Name, Reason, Timeout) when is_atom(Name) ->
-    case erlang:whereis(Name) of
-        undefined ->
-            {error, undefined};
-        Pid when is_pid(Pid) ->
-            stop(Pid, Reason, Timeout)
-    end;
-stop(Pid, Reason, Timeout) when is_pid(Pid) ->
-    MonitorRef = monitor(process, Pid),
+stop(ServerRef, Reason, Timeout) ->
+    MonitorRef = monitor(process, ServerRef),
     Pid ! {'$stop', Reason},
     receive
-        {'DOWN', MonitorRef, process, Pid, Reason} ->
+        {'DOWN', MonitorRef, process, _, Reason} ->
             ok;
-        {'DOWN', MonitorRef, process, Pid, AnotherReason} ->
+        {'DOWN', MonitorRef, process, _, AnotherReason} ->
             erlang:exit(AnotherReason)
     after Timeout ->
         demonitor(MonitorRef, [flush]),
@@ -431,29 +424,22 @@ call(ServerRef, Request) ->
 %%-----------------------------------------------------------------------------
 -spec call(ServerRef :: server_ref(), Request :: term(), TimeoutMs :: timeout()) ->
     Reply :: term() | {error, Reason :: term()}.
-call(Name, Request, TimeoutMs) when is_atom(Name) ->
-    case erlang:whereis(Name) of
-        undefined ->
-            erlang:exit({noproc, {?MODULE, ?FUNCTION_NAME, [Name, Request]}});
-        Pid when is_pid(Pid) ->
-            call(Pid, Request, TimeoutMs)
-    end;
-call(Pid, Request, TimeoutMs) when is_pid(Pid) ->
-    MonitorRef = monitor(process, Pid),
-    Pid ! {'$gen_call', {self(), MonitorRef}, Request},
+call(ServerRef, Request, TimeoutMs) ->
+    MonitorRef = monitor(process, ServerRef),
+    ServerRef ! {'$gen_call', {self(), MonitorRef}, Request},
     receive
-        {'DOWN', MonitorRef, process, Pid, {E, []} = _Reason} ->
-            erlang:exit({E, {?MODULE, ?FUNCTION_NAME, [Pid, Request]}});
-        {'DOWN', MonitorRef, process, Pid, {_E, _L} = Reason} ->
+        {'DOWN', MonitorRef, process, _, {E, []} = _Reason} ->
+            erlang:exit({E, {?MODULE, ?FUNCTION_NAME, [ServerRef, Request]}});
+        {'DOWN', MonitorRef, process, _, {_E, _L} = Reason} ->
             erlang:exit(Reason);
-        {'DOWN', MonitorRef, process, Pid, Atom} when is_atom(Atom) ->
-            erlang:exit({Atom, {?MODULE, ?FUNCTION_NAME, [Pid, Request]}});
+        {'DOWN', MonitorRef, process, _, Atom} when is_atom(Atom) ->
+            erlang:exit({Atom, {?MODULE, ?FUNCTION_NAME, [ServerRef, Request]}});
         {MonitorRef, Reply} ->
             demonitor(MonitorRef, [flush]),
             Reply
     after TimeoutMs ->
         demonitor(MonitorRef, [flush]),
-        erlang:exit({timeout, {?MODULE, ?FUNCTION_NAME, [Pid, Request]}})
+        erlang:exit({timeout, {?MODULE, ?FUNCTION_NAME, [ServerRef, Request]}})
     end.
 
 %%-----------------------------------------------------------------------------
@@ -467,15 +453,8 @@ call(Pid, Request, TimeoutMs) when is_pid(Pid) ->
 %% @end
 %%-----------------------------------------------------------------------------
 -spec cast(ServerRef :: server_ref(), Request :: term()) -> ok | {error, Reason :: term()}.
-cast(Name, Request) when is_atom(Name) ->
-    case erlang:whereis(Name) of
-        undefined ->
-            {error, undefined};
-        Pid when is_pid(Pid) ->
-            cast(Pid, Request)
-    end;
-cast(Pid, Request) when is_pid(Pid) ->
-    Pid ! {'$gen_cast', Request},
+cast(ServerRef, Request) ->
+    ServerRef ! {'$gen_cast', Request},
     ok.
 
 %%-----------------------------------------------------------------------------
diff --git a/src/libAtomVM/context.c b/src/libAtomVM/context.c
@@ -30,6 +30,7 @@
 #include "globalcontext.h"
 #include "list.h"
 #include "mailbox.h"
+#include "memory.h"
 #include "smp.h"
 #include "synclist.h"
 #include "sys.h"
@@ -252,6 +253,7 @@ void context_destroy(Context *ctx)
                 case CONTEXT_MONITOR_LINK_LOCAL:
                 case CONTEXT_MONITOR_MONITORED_LOCAL:
                 case CONTEXT_MONITOR_MONITORING_LOCAL:
+                case CONTEXT_MONITOR_MONITORING_LOCAL_REGISTEREDNAME:
                     UNREACHABLE();
             }
         }
@@ -418,15 +420,34 @@ void context_process_monitor_down_signal(Context *ctx, struct TermSignal *signal
     LIST_FOR_EACH (item, &ctx->monitors_head) {
         struct Monitor *monitor = GET_LIST_ENTRY(item, struct Monitor, monitor_list_head);
         if (monitor->monitor_type == CONTEXT_MONITOR_MONITORING_LOCAL) {
-            struct MonitorLocalMonitor *monitored_monitor = CONTAINER_OF(monitor, struct MonitorLocalMonitor, monitor);
-            if (monitored_monitor->monitor_obj == monitor_obj && monitored_monitor->ref_ticks == ref_ticks) {
+            struct MonitorLocalMonitor *monitoring_monitor = CONTAINER_OF(monitor, struct MonitorLocalMonitor, monitor);
+            if (monitoring_monitor->monitor_obj == monitor_obj && monitoring_monitor->ref_ticks == ref_ticks) {
                 // Remove link
                 list_remove(&monitor->monitor_list_head);
                 free(monitor);
                 // Enqueue the term as a message.
                 mailbox_send(ctx, signal->signal_term);
                 break;
             }
+        } else if (monitor->monitor_type == CONTEXT_MONITOR_MONITORING_LOCAL_REGISTEREDNAME) {
+            int32_t monitor_process_id = term_to_local_process_id(monitor_obj);
+            struct MonitorLocalRegisteredNameMonitor *monitoring_monitor = CONTAINER_OF(monitor, struct MonitorLocalRegisteredNameMonitor, monitor);
+            if (monitoring_monitor->monitor_process_id == monitor_process_id && monitoring_monitor->ref_ticks == ref_ticks) {
+                // Remove link
+                list_remove(&monitor->monitor_list_head);
+
+                // We need to modify the monitor_obj item
+                BEGIN_WITH_STACK_HEAP(TUPLE_SIZE(2), temp_heap)
+                term name_tuple = term_alloc_tuple(2, &temp_heap);
+                term_put_tuple_element(name_tuple, 0, monitoring_monitor->monitor_name);
+                term_put_tuple_element(name_tuple, 1, ctx->global->node_name);
+                term_put_tuple_element(signal->signal_term, 3, name_tuple);
+                mailbox_send(ctx, signal->signal_term);
+                END_WITH_STACK_HEAP(temp_heap, ctx->global);
+
+                free(monitor);
+                break;
+            }
         }
     }
     // If monitor was not found, it was removed and message should not be sent.
@@ -623,6 +644,18 @@ static struct Monitor *context_monitors_handle_terminate(Context *ctx)
                 free(monitor);
                 break;
             }
+            case CONTEXT_MONITOR_MONITORING_LOCAL_REGISTEREDNAME: {
+                // We are the monitoring process.
+                struct MonitorLocalRegisteredNameMonitor *monitoring_monitor = CONTAINER_OF(monitor, struct MonitorLocalRegisteredNameMonitor, monitor);
+                int32_t local_process_id = monitoring_monitor->monitor_process_id;
+                Context *target = globalcontext_get_process_nolock(glb, local_process_id);
+                if (LIKELY(target != NULL)) {
+                    // target can be null if we didn't process a MonitorDownSignal
+                    mailbox_send_ref_signal(target, DemonitorSignal, monitoring_monitor->ref_ticks);
+                }
+                free(monitor);
+                break;
+            }
             case CONTEXT_MONITOR_LINK_LOCAL: {
                 struct LinkLocalMonitor *link_monitor = CONTAINER_OF(monitor, struct LinkLocalMonitor, monitor);
                 // Handle the case of inactive link.
@@ -747,6 +780,20 @@ struct Monitor *monitor_new(term monitor_pid, uint64_t ref_ticks, bool is_monito
     return &monitor->monitor;
 }
 
+struct Monitor *monitor_registeredname_monitor_new(int32_t monitor_process_id, term monitor_name, uint64_t ref_ticks)
+{
+    struct MonitorLocalRegisteredNameMonitor *monitor = malloc(sizeof(struct MonitorLocalRegisteredNameMonitor));
+    if (IS_NULL_PTR(monitor)) {
+        return NULL;
+    }
+    monitor->monitor.monitor_type = CONTEXT_MONITOR_MONITORING_LOCAL_REGISTEREDNAME;
+    monitor->monitor_process_id = monitor_process_id;
+    monitor->monitor_name = monitor_name;
+    monitor->ref_ticks = ref_ticks;
+
+    return &monitor->monitor;
+}
+
 struct Monitor *monitor_resource_monitor_new(void *resource, uint64_t ref_ticks)
 {
     struct ResourceContextMonitor *monitor = malloc(sizeof(struct ResourceContextMonitor));
@@ -786,6 +833,17 @@ bool context_add_monitor(Context *ctx, struct Monitor *new_monitor)
                     }
                     break;
                 }
+                case CONTEXT_MONITOR_MONITORING_LOCAL_REGISTEREDNAME: {
+                    struct MonitorLocalRegisteredNameMonitor *new_local_registeredname_monitor = CONTAINER_OF(new_monitor, struct MonitorLocalRegisteredNameMonitor, monitor);
+                    struct MonitorLocalRegisteredNameMonitor *existing_local_registeredname_monitor = CONTAINER_OF(existing, struct MonitorLocalRegisteredNameMonitor, monitor);
+                    if (UNLIKELY(existing_local_registeredname_monitor->monitor_process_id == new_local_registeredname_monitor->monitor_process_id
+                            && existing_local_registeredname_monitor->monitor_name == new_local_registeredname_monitor->monitor_name
+                            && existing_local_registeredname_monitor->ref_ticks == new_local_registeredname_monitor->ref_ticks)) {
+                        free(new_monitor);
+                        return false;
+                    }
+                    break;
+                }
                 case CONTEXT_MONITOR_RESOURCE: {
                     struct ResourceContextMonitor *new_resource_monitor = CONTAINER_OF(new_monitor, struct ResourceContextMonitor, monitor);
                     struct ResourceContextMonitor *existing_resource_monitor = CONTAINER_OF(existing, struct ResourceContextMonitor, monitor);
@@ -933,6 +991,15 @@ void context_demonitor(Context *ctx, uint64_t ref_ticks)
                 }
                 break;
             }
+            case CONTEXT_MONITOR_MONITORING_LOCAL_REGISTEREDNAME: {
+                struct MonitorLocalRegisteredNameMonitor *local_registeredname_monitor = CONTAINER_OF(monitor, struct MonitorLocalRegisteredNameMonitor, monitor);
+                if (local_registeredname_monitor->ref_ticks == ref_ticks) {
+                    list_remove(&monitor->monitor_list_head);
+                    free(monitor);
+                    return;
+                }
+                break;
+            }
             case CONTEXT_MONITOR_RESOURCE: {
                 struct ResourceContextMonitor *resource_monitor = CONTAINER_OF(monitor, struct ResourceContextMonitor, monitor);
                 if (resource_monitor->ref_ticks == ref_ticks) {
@@ -963,6 +1030,14 @@ term context_get_monitor_pid(Context *ctx, uint64_t ref_ticks, bool *is_monitori
                 }
                 break;
             }
+            case CONTEXT_MONITOR_MONITORING_LOCAL_REGISTEREDNAME: {
+                struct MonitorLocalRegisteredNameMonitor *local_registeredname_monitor = CONTAINER_OF(monitor, struct MonitorLocalRegisteredNameMonitor, monitor);
+                if (local_registeredname_monitor->ref_ticks == ref_ticks) {
+                    *is_monitoring = true;
+                    return term_from_local_process_id(local_registeredname_monitor->monitor_process_id);
+                }
+                break;
+            }
             case CONTEXT_MONITOR_LINK_LOCAL:
             case CONTEXT_MONITOR_LINK_REMOTE:
             case CONTEXT_MONITOR_RESOURCE:
@@ -1103,6 +1178,16 @@ COLD_FUNC void context_dump(Context *ctx)
                 fprintf(stderr, "\n");
                 break;
             }
+            case CONTEXT_MONITOR_MONITORING_LOCAL_REGISTEREDNAME: {
+                struct MonitorLocalRegisteredNameMonitor *local_registeredname_monitor = CONTAINER_OF(monitor, struct MonitorLocalRegisteredNameMonitor, monitor);
+                fprintf(stderr, "monitor to ");
+                term_display(stderr, local_registeredname_monitor->monitor_name, ctx);
+                fprintf(stderr, " (");
+                term_display(stderr, term_from_local_process_id(local_registeredname_monitor->monitor_process_id), ctx);
+                fprintf(stderr, ") ref=%lu", (long unsigned) local_registeredname_monitor->ref_ticks);
+                fprintf(stderr, "\n");
+                break;
+            }
             case CONTEXT_MONITOR_RESOURCE: {
                 struct ResourceContextMonitor *resource_monitor = CONTAINER_OF(monitor, struct ResourceContextMonitor, monitor);
                 fprintf(stderr, "monitored by resource %p ref=%lu", resource_monitor->resource_obj, (long unsigned) resource_monitor->ref_ticks);
diff --git a/src/libAtomVM/context.h b/src/libAtomVM/context.h
@@ -159,6 +159,7 @@ enum ContextMonitorType
     CONTEXT_MONITOR_MONITORED_LOCAL,
     CONTEXT_MONITOR_RESOURCE,
     CONTEXT_MONITOR_LINK_REMOTE,
+    CONTEXT_MONITOR_MONITORING_LOCAL_REGISTEREDNAME,
 };
 
 #define UNLINK_ID_LINK_ACTIVE 0x0
@@ -186,6 +187,14 @@ struct MonitorLocalMonitor
     term monitor_obj;
 };
 
+struct MonitorLocalRegisteredNameMonitor
+{
+    struct Monitor monitor;
+    uint64_t ref_ticks;
+    int32_t monitor_process_id;
+    term monitor_name;
+};
+
 // The other half is called ResourceMonitor and is a linked list of resources
 struct ResourceContextMonitor
 {
@@ -477,13 +486,24 @@ struct Monitor *monitor_link_new(term link_pid);
 /**
  * @brief Create a monitor on a process.
  *
- * @param monitor_pid monitoring process
+ * @param monitor_pid monitored process
  * @param ref_ticks reference of the monitor
  * @param is_monitoring if ctx is the monitoring process
  * @return the allocated monitor or NULL if allocation failed
  */
 struct Monitor *monitor_new(term monitor_pid, uint64_t ref_ticks, bool is_monitoring);
 
+/**
+ * @brief Create a monitor on a process by registered name.
+ *
+ * @param monitor_process_id monitored process id
+ * @param monitor_name name of the monitor (atom)
+ * @param ref_ticks reference of the monitor
+ * @param is_monitoring if ctx is the monitoring process
+ * @return the allocated monitor or NULL if allocation failed
+ */
+struct Monitor *monitor_registeredname_monitor_new(int32_t monitor_process_id, term monitor_name, uint64_t ref_ticks);
+
 /**
  * @brief Create a resource monitor.
  *
@@ -545,8 +565,8 @@ void context_demonitor(Context *ctx, uint64_t ref_ticks);
  * @param ctx the context being executed
  * @param ref_ticks reference of the monitor to remove
  * @param is_monitoring whether ctx is the monitoring process.
- * @return pid of monitoring process, self() if process is monitoring (and not
- * monitored) or term_invalid() if no monitor could be found.
+ * @return pid of monitored or monitoring process or term_invalid()
+ * if no monitor could be found.
  */
 term context_get_monitor_pid(Context *ctx, uint64_t ref_ticks, bool *is_monitoring);
 
diff --git a/src/libAtomVM/nifs.c b/src/libAtomVM/nifs.c
@@ -4133,28 +4133,43 @@ static term nif_erlang_monitor(Context *ctx, int argc, term argv[])
     UNUSED(argc);
 
     term object_type = argv[0];
-    term target_pid = argv[1];
+    term target_proc = argv[1];
+    term target_pid;
+    size_t target_proc_size = 0;
 
     if (object_type != PROCESS_ATOM && object_type != PORT_ATOM) {
         RAISE_ERROR(BADARG_ATOM);
     }
 
-    VALIDATE_VALUE(target_pid, term_is_local_pid_or_port);
+    if (term_is_atom(target_proc)) {
+        target_pid = globalcontext_get_registered_process(ctx->global, term_to_atom_index(target_proc));
+        target_proc_size = TUPLE_SIZE(2);
+    } else {
+        VALIDATE_VALUE(target_proc, term_is_local_pid_or_port);
+        target_pid = target_proc;
+    }
 
-    int local_process_id = term_to_local_process_id(target_pid);
-    // Monitoring self is possible but no monitor is actually created
-    if (UNLIKELY(local_process_id == ctx->process_id)) {
-        if (UNLIKELY(memory_ensure_free_opt(ctx, REF_SIZE, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
-            RAISE_ERROR(OUT_OF_MEMORY_ATOM);
+    Context *target;
+    int32_t local_process_id;
+    if (UNLIKELY(target_pid == UNDEFINED_ATOM)) {
+        target = NULL;
+    } else {
+        local_process_id = term_to_local_process_id(target_pid);
+        // Monitoring self is possible but no monitor is actually created
+        if (UNLIKELY(local_process_id == ctx->process_id)) {
+            if (UNLIKELY(memory_ensure_free_opt(ctx, REF_SIZE, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
+                RAISE_ERROR(OUT_OF_MEMORY_ATOM);
+            }
+            uint64_t ref_ticks = globalcontext_get_ref_ticks(ctx->global);
+            term ref = term_from_ref_ticks(ref_ticks, &ctx->heap);
+            return ref;
         }
-        uint64_t ref_ticks = globalcontext_get_ref_ticks(ctx->global);
-        term ref = term_from_ref_ticks(ref_ticks, &ctx->heap);
-        return ref;
+
+        target = globalcontext_get_process_lock(ctx->global, local_process_id);
     }
 
-    Context *target = globalcontext_get_process_lock(ctx->global, local_process_id);
     if (IS_NULL_PTR(target)) {
-        int res_size = REF_SIZE + TUPLE_SIZE(5);
+        int res_size = REF_SIZE + TUPLE_SIZE(5) + target_proc_size;
         if (UNLIKELY(memory_ensure_free_opt(ctx, res_size, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
             RAISE_ERROR(OUT_OF_MEMORY_ATOM);
         }
@@ -4164,7 +4179,14 @@ static term nif_erlang_monitor(Context *ctx, int argc, term argv[])
         term_put_tuple_element(down_message_tuple, 0, DOWN_ATOM);
         term_put_tuple_element(down_message_tuple, 1, ref);
         term_put_tuple_element(down_message_tuple, 2, object_type);
-        term_put_tuple_element(down_message_tuple, 3, target_pid);
+        if (term_is_atom(target_proc)) {
+            term target_proc_tuple = term_alloc_tuple(2, &ctx->heap);
+            term_put_tuple_element(target_proc_tuple, 0, target_proc);
+            term_put_tuple_element(target_proc_tuple, 1, ctx->global->node_name);
+            term_put_tuple_element(down_message_tuple, 3, target_proc_tuple);
+        } else {
+            term_put_tuple_element(down_message_tuple, 3, target_proc);
+        }
         term_put_tuple_element(down_message_tuple, 4, NOPROC_ATOM);
         mailbox_send(ctx, down_message_tuple);
         return ref;
@@ -4175,7 +4197,12 @@ static term nif_erlang_monitor(Context *ctx, int argc, term argv[])
     }
     uint64_t ref_ticks = globalcontext_get_ref_ticks(ctx->global);
     term monitoring_pid = term_from_local_process_id(ctx->process_id);
-    struct Monitor *self_monitor = monitor_new(target_pid, ref_ticks, true);
+    struct Monitor *self_monitor;
+    if (term_is_atom(target_proc)) {
+        self_monitor = monitor_registeredname_monitor_new(local_process_id, target_proc, ref_ticks);
+    } else {
+        self_monitor = monitor_new(target_pid, ref_ticks, true);
+    }
     if (IS_NULL_PTR(self_monitor)) {
         globalcontext_get_process_unlock(ctx->global, target);
         RAISE_ERROR(OUT_OF_MEMORY_ATOM);
diff --git a/tests/erlang_tests/test_monitor.erl b/tests/erlang_tests/test_monitor.erl
