erts: Add enif_is_process/port_alive

6 files changed, 154 insertions, 5 deletions

diff --git a/erts/doc/src/erl_nif.xml b/erts/doc/src/erl_nif.xml
index e62f5792a5..6befdc124b 100644
--- a/erts/doc/src/erl_nif.xml
+++ b/erts/doc/src/erl_nif.xml
@@ -532,6 +532,14 @@ typedef struct {
           <seealso marker="#ErlNifEnv">environment</seealso>. <c>ErlNifPid</c>
           is an opaque type.</p>
         </item>
+      <tag><marker id="ErlNifPort"/>ErlNifPort</tag>
+       <item>
+          <p><c>ErlNifPort</c> is a port identifier. In contrast to
+          port id terms (instances of <c>ERL_NIF_TERM</c>), <c>ErlNifPort</c>'s are self
+          contained and not bound to any
+          <seealso marker="#ErlNifEnv">environment</seealso>. <c>ErlNifPort</c>
+          is an opaque type.</p>
+        </item>
 
       <tag><marker id="ErlNifResourceType"/>ErlNifResourceType</tag>
        <item>
@@ -801,6 +809,12 @@ typedef enum {
     pid variable <c>*pid</c> from it and return true. Otherwise return false.
     No check if the process is alive is done.</p></desc>
     </func>
+    <func><name><ret>int</ret><nametext>enif_get_local_port(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPort* port_id)</nametext></name>
+    <fsummary>Read an local port term</fsummary>
+    <desc><p>If <c>term</c> is the port of a node local port, initialize the
+    port variable <c>*port_id</c> from it and return true. Otherwise return false.
+    No check if the port is alive is done.</p></desc>
+    </func>
     <func><name><ret>int</ret><nametext>enif_get_list_cell(ErlNifEnv* env, ERL_NIF_TERM list, ERL_NIF_TERM* head, ERL_NIF_TERM* tail)</nametext></name>
       <fsummary>Get head and tail from a list</fsummary>
       <desc><p>Set <c>*head</c> and <c>*tail</c> from
@@ -969,6 +983,17 @@ typedef enum {
       <fsummary>Determine if a term is a port</fsummary>
       <desc><p>Return true if <c>term</c> is a port.</p></desc>
     </func>
+    <func><name><ret>int</ret><nametext>enif_is_port_alive(ErlNifEnv* env, ErlNifPort *port_id)</nametext></name>
+      <fsummary>Determine if a local port is alive or not.</fsummary>
+      <desc><p>Return true if <c>port_id</c> is currently alive.</p>
+      <p>This function can only be used in a from a NIF-calling thread.</p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_is_process_alive(ErlNifEnv* env, ErlNifPid *pid)</nametext></name>
+      <fsummary>Determine if a local process is alive or not.</fsummary>
+      <desc><p>Return true if <c>pid</c> is currently alive.</p>
+      <p>This function is only thread-safe when the emulator with SMP support is used.
+      It can only be used in a non-SMP emulator from a NIF-calling thread.</p></desc>
+    </func>
     <func><name><ret>int</ret><nametext>enif_is_ref(ErlNifEnv* env, ERL_NIF_TERM term)</nametext></name>
       <fsummary>Determine if a term is a reference</fsummary>
       <desc><p>Return true if <c>term</c> is a reference.</p></desc>
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index 703c96777a..8440fd26b5 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -404,12 +404,28 @@ static int is_offheap(const ErlOffHeap* oh)
 
 ErlNifPid* enif_self(ErlNifEnv* caller_env, ErlNifPid* pid)
 {
+    if (caller_env->proc->common.id == ERTS_INVALID_PID)
+        return NULL;
     pid->pid = caller_env->proc->common.id;
     return pid;
 }
+
 int enif_get_local_pid(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPid* pid)
 {
-    return is_internal_pid(term) ? (pid->pid=term, 1) : 0;
+    if (is_internal_pid(term)) {
+        pid->pid=term;
+        return 1;
+    }
+    return 0;
+}
+
+int enif_get_local_port(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPort* port)
+{
+    if (is_internal_port(term)) {
+        port->port_id=term;
+        return 1;
+    }
+    return 0;
 }
 
 int enif_is_atom(ErlNifEnv* env, ERL_NIF_TERM term)
@@ -1158,6 +1174,58 @@ int enif_make_reverse_list(ErlNifEnv* env, ERL_NIF_TERM term, ERL_NIF_TERM *list
     return 1;
 }
 
+int enif_is_process_alive(ErlNifEnv* env, ErlNifPid *proc)
+{
+    ErtsProcLocks rp_locks = 0; /* We don't need any locks,
+                                   just to check if it is alive */
+    Eterm target = proc->pid;
+    Process* rp;
+    Process* c_p;
+    int scheduler = erts_get_scheduler_id() != 0;
+
+    if (env != NULL) {
+	c_p = env->proc;
+	if (target == c_p->common.id) {
+            /* We are alive! */
+	    return 1;
+	}
+    }
+    else {
+#ifdef ERTS_SMP
+	c_p = NULL;
+#else
+	erts_exit(ERTS_ABORT_EXIT,"enif_is_process_alive: "
+                  "env==NULL on non-SMP VM");
+#endif
+    }
+
+    rp = (scheduler
+	  ? erts_proc_lookup(target)
+	  : erts_pid2proc_opt(c_p, ERTS_PROC_LOCK_MAIN,
+			      target, rp_locks, ERTS_P2P_FLG_INC_REFC));
+    if (rp == NULL) {
+        ASSERT(env == NULL || target != c_p->common.id);
+	return 0;
+    } else {
+        if (!scheduler)
+            erts_proc_dec_refc(rp);
+        return 1;
+    }
+}
+
+int enif_is_port_alive(ErlNifEnv *env, ErlNifPort *port)
+{
+    /* only allowed if called from scheduler */
+    if (erts_get_scheduler_id() == 0)
+        erts_exit(ERTS_ABORT_EXIT,"enif_is_port_alive: called from non-scheduler");
+
+    return erts_port_lookup(
+        port->port_id,
+        (erts_port_synchronous_ops
+         ? ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP
+         : ERTS_PORT_SFLGS_INVALID_LOOKUP)) != NULL;
+}
+
 ERL_NIF_TERM
 enif_now_time(ErlNifEnv *env)
 {
diff --git a/erts/emulator/beam/erl_nif.h b/erts/emulator/beam/erl_nif.h
index 959fcb5412..6ee22a693c 100644
--- a/erts/emulator/beam/erl_nif.h
+++ b/erts/emulator/beam/erl_nif.h
@@ -150,7 +150,12 @@ typedef enum
 typedef struct
 {
     ERL_NIF_TERM pid;  /* internal, may change */
-}ErlNifPid;
+} ErlNifPid;
+
+typedef struct
+{
+    ERL_NIF_TERM port_id;  /* internal, may change */
+}ErlNifPort;
 
 typedef ErlDrvSysInfo ErlNifSysInfo;
 
diff --git a/erts/emulator/beam/erl_nif_api_funcs.h b/erts/emulator/beam/erl_nif_api_funcs.h
index 3fe60e3df8..21864c8b35 100644
--- a/erts/emulator/beam/erl_nif_api_funcs.h
+++ b/erts/emulator/beam/erl_nif_api_funcs.h
@@ -166,6 +166,9 @@ ERL_NIF_API_FUNC_DECL(ErlNifTime, enif_convert_time_unit, (ErlNifTime, ErlNifTim
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM, enif_now_time, (ErlNifEnv *env));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM, enif_cpu_time, (ErlNifEnv *env));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM, enif_make_unique_integer, (ErlNifEnv *env, ErlNifUniqueInteger properties));
+ERL_NIF_API_FUNC_DECL(int, enif_is_process_alive, (ErlNifEnv *env, ErlNifPid *pid));
+ERL_NIF_API_FUNC_DECL(int, enif_is_port_alive, (ErlNifEnv *env, ErlNifPort *port_id));
+ERL_NIF_API_FUNC_DECL(int, enif_get_local_port, (ErlNifEnv* env, ERL_NIF_TERM, ErlNifPort* port_id));
 
 /*
 ** ADD NEW ENTRIES HERE (before this comment) !!!
@@ -324,6 +327,9 @@ ERL_NIF_API_FUNC_DECL(int,enif_is_on_dirty_scheduler,(ErlNifEnv*));
 #  define enif_now_time ERL_NIF_API_FUNC_MACRO(enif_now_time)
 #  define enif_cpu_time ERL_NIF_API_FUNC_MACRO(enif_cpu_time)
 #  define enif_make_unique_integer ERL_NIF_API_FUNC_MACRO(enif_make_unique_integer)
+#  define enif_is_process_alive ERL_NIF_API_FUNC_MACRO(enif_is_process_alive)
+#  define enif_is_port_alive ERL_NIF_API_FUNC_MACRO(enif_is_port_alive)
+#  define enif_get_local_port ERL_NIF_API_FUNC_MACRO(enif_get_local_port)
 
 /*
 ** ADD NEW ENTRIES HERE (before this comment)
diff --git a/erts/emulator/test/nif_SUITE.erl b/erts/emulator/test/nif_SUITE.erl
index d3bf91092f..3202986ce7 100644
--- a/erts/emulator/test/nif_SUITE.erl
+++ b/erts/emulator/test/nif_SUITE.erl
@@ -43,7 +43,8 @@
 	 nif_exception/1, call_nif_exception/1,
 	 nif_nan_and_inf/1, nif_atom_too_long/1,
 	 nif_monotonic_time/1, nif_time_offset/1, nif_convert_time_unit/1,
-         nif_now_time/1, nif_cpu_time/1, nif_unique_integer/1
+         nif_now_time/1, nif_cpu_time/1, nif_unique_integer/1,
+         nif_is_process_alive/1, nif_is_port_alive/1
 	]).
 
 -export([many_args_100/100]).
@@ -75,7 +76,8 @@ all() ->
      nif_schedule, dirty_nif, dirty_nif_send, dirty_nif_exception,
      nif_exception, nif_nan_and_inf, nif_atom_too_long,
      nif_monotonic_time, nif_time_offset, nif_convert_time_unit,
-     nif_now_time, nif_cpu_time, nif_unique_integer
+     nif_now_time, nif_cpu_time, nif_unique_integer,
+     nif_is_process_alive, nif_is_port_alive
     ].
 
 init_per_testcase(_Case, Config) ->
@@ -1939,6 +1941,23 @@ nif_unique_integer(Config) ->
     true = is_integer(unique_integer_nif([])),
     true = is_integer(unique_integer_nif([])).
 
+nif_is_process_alive(Config) ->
+    ensure_lib_loaded(Config),
+
+    {Pid,_} = spawn_monitor(fun() -> receive ok -> nok end end),
+    true = is_process_alive_nif(Pid),
+    exit(Pid, die),
+    receive _ -> ok end, %% Clear monitor
+    false = is_process_alive_nif(Pid).
+
+nif_is_port_alive(Config) ->
+    ensure_lib_loaded(Config),
+
+    Port = open_port({spawn,"/bin/sh -s unix:cmd"},[stderr_to_stdout,eof]),
+    true = is_port_alive_nif(Port),
+    port_close(Port),
+    false = is_port_alive_nif(Port).
+
 %% The NIFs:
 lib_version() -> undefined.
 call_history() -> ?nif_stub.
@@ -1997,6 +2016,8 @@ call_nif_exception(_) -> ?nif_stub.
 call_nif_nan_or_inf(_) -> ?nif_stub.
 call_nif_atom_too_long(_) -> ?nif_stub.
 unique_integer_nif(_) -> ?nif_stub.
+is_process_alive_nif(_) -> ?nif_stub.
+is_port_alive_nif(_) -> ?nif_stub.
 
 %% maps
 is_map_nif(_) -> ?nif_stub.
diff --git a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
index 1960689590..2ce0168788 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
+++ b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
@@ -30,6 +30,7 @@ static int static_cntA; /* zero by default */
 static int static_cntB = NIF_SUITE_LIB_VER * 100;
 
 static ERL_NIF_TERM atom_false;
+static ERL_NIF_TERM atom_true;
 static ERL_NIF_TERM atom_self;
 static ERL_NIF_TERM atom_ok;
 static ERL_NIF_TERM atom_join;
@@ -138,6 +139,7 @@ static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
 						    msgenv_dtor,
 						    ERL_NIF_RT_CREATE, NULL);
     atom_false = enif_make_atom(env,"false");
+    atom_true = enif_make_atom(env,"true");
     atom_self = enif_make_atom(env,"self");
     atom_ok = enif_make_atom(env,"ok");
     atom_join = enif_make_atom(env,"join");
@@ -2008,6 +2010,26 @@ static ERL_NIF_TERM unique_integer(ErlNifEnv* env, int argc, const ERL_NIF_TERM
     return enif_make_unique_integer(env, properties);
 }
 
+static ERL_NIF_TERM is_process_alive(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifPid pid;
+    if (!enif_get_local_pid(env, argv[0], &pid))
+        return enif_make_badarg(env);
+    if (enif_is_process_alive(env, &pid))
+        return atom_true;
+    return atom_false;
+}
+
+static ERL_NIF_TERM is_port_alive(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifPort port;
+    if (!enif_get_local_port(env, argv[0], &port))
+        return enif_make_badarg(env);
+    if (enif_is_port_alive(env, &port))
+        return atom_true;
+    return atom_false;
+}
+
 static ErlNifFunc nif_funcs[] =
 {
     {"lib_version", 0, lib_version},
@@ -2083,7 +2105,9 @@ static ErlNifFunc nif_funcs[] =
     {"convert_time_unit", 3, convert_time_unit},
     {"now_time", 0, now_time},
     {"cpu_time", 0, cpu_time},
-    {"unique_integer_nif", 1, unique_integer}
+    {"unique_integer_nif", 1, unique_integer},
+    {"is_process_alive_nif", 1, is_process_alive},
+    {"is_port_alive_nif", 1, is_port_alive}
 };
 
 ERL_NIF_INIT(nif_SUITE,nif_funcs,load,reload,upgrade,unload)