Implement monitoring process by registered name

pguyot · pguyot · commit ecdc71bcf204 · 2025-08-10T14:18:14.000+02:00
Also simplify gen_server implementation when ServerRef is an atom
Also fix CodeQL queries to work with "term _Atomic"

Signed-off-by: Paul Guyot &lt;pguyot@kallisys.net&gt;
diff --git a/code-queries/non-term-to-term-func.ql b/code-queries/non-term-to-term-func.ql
@@ -20,6 +20,10 @@ predicate isTermType(Type t) {
     (
         t instanceof TypedefType
         and isTermType(t.(TypedefType).getBaseType())
+    ) or
+    (
+        t instanceof SpecifiedType
+        and isTermType(t.(SpecifiedType).getBaseType())
     )
 }
 
diff --git a/code-queries/term-to-non-term-func.ql b/code-queries/term-to-non-term-func.ql
@@ -20,6 +20,10 @@ predicate isTermType(Type t) {
     (
         t instanceof TypedefType
         and isTermType(t.(TypedefType).getBaseType())
+    ) or
+    (
+        t instanceof SpecifiedType
+        and isTermType(t.(SpecifiedType).getBaseType())
     )
 }
 
diff --git a/libs/estdlib/src/erlang.erl b/libs/estdlib/src/erlang.erl
@@ -1133,8 +1133,8 @@ send(_Target, _Message) ->
 %% @end
 %%-----------------------------------------------------------------------------
 -spec monitor
-    (Type :: process, Pid :: pid()) -> reference();
-    (Type :: port, Port :: port()) -> reference().
+    (Type :: process, Pid :: pid() | atom()) -> reference();
+    (Type :: port, Port :: port() | atom()) -> reference().
 monitor(_Type, _PidOrPort) ->
     erlang:nif_error(undefined).
 
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),
-    Pid ! {'$stop', Reason},
+stop(ServerRef, Reason, Timeout) ->
+    MonitorRef = monitor(process, ServerRef),
+    ServerRef ! {'$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,30 @@ 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),
+    ActualTimeout =
+        try
+            ServerRef ! {'$gen_call', {self(), MonitorRef}, Request},
+            TimeoutMs
+        catch
+            error:badarg ->
+                % Process no longer exists, monitor will send a message
+                1000
+        end,
     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 ->
+    after ActualTimeout ->
         demonitor(MonitorRef, [flush]),
-        erlang:exit({timeout, {?MODULE, ?FUNCTION_NAME, [Pid, Request]}})
+        erlang:exit({timeout, {?MODULE, ?FUNCTION_NAME, [ServerRef, Request]}})
     end.
 
 %%-----------------------------------------------------------------------------
@@ -467,15 +461,14 @@ 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) ->
+    try
+        ServerRef ! {'$gen_cast', Request}
+    catch
+        error:badarg ->
+            % Process does not exist, ignore error
+            ok
+    end,
     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
diff --git a/tests/erlang_tests/test_monitor.erl b/tests/erlang_tests/test_monitor.erl
diff --git a/tests/libs/estdlib/test_gen_server.erl b/tests/libs/estdlib/test_gen_server.erl

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,10 @@ predicate isTermType(Type t) {`
`20`	`20`	`(`
`21`	`21`	`t instanceof TypedefType`
`22`	`22`	`and isTermType(t.(TypedefType).getBaseType())`
	`23`	`+ ) or`
	`24`	`+ (`
	`25`	`+ t instanceof SpecifiedType`
	`26`	`+ and isTermType(t.(SpecifiedType).getBaseType())`
`23`	`27`	`)`
`24`	`28`	`}`
`25`	`29`