1 files changed, 37 insertions, 71 deletions

diff --git a/erts/emulator/beam/register.c b/erts/emulator/beam/register.c
index bf3267cff1..c7e02c6d48 100644
--- a/erts/emulator/beam/register.c
+++ b/erts/emulator/beam/register.c
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  *
- * Copyright Ericsson AB 1996-2016. All Rights Reserved.
+ * Copyright Ericsson AB 1996-2018. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -38,16 +38,15 @@ static Hash process_reg;
 
 #define REG_HASH(term) ((HashValue) atom_val(term))
 
-static erts_smp_rwmtx_t regtab_rwmtx;
+static erts_rwmtx_t regtab_rwmtx;
 
-#define reg_try_read_lock()		erts_smp_rwmtx_tryrlock(&regtab_rwmtx)
-#define reg_try_write_lock()		erts_smp_rwmtx_tryrwlock(&regtab_rwmtx)
-#define reg_read_lock()			erts_smp_rwmtx_rlock(&regtab_rwmtx)
-#define reg_write_lock()		erts_smp_rwmtx_rwlock(&regtab_rwmtx)
-#define reg_read_unlock()		erts_smp_rwmtx_runlock(&regtab_rwmtx)
-#define reg_write_unlock()		erts_smp_rwmtx_rwunlock(&regtab_rwmtx)
+#define reg_try_read_lock()		erts_rwmtx_tryrlock(&regtab_rwmtx)
+#define reg_try_write_lock()		erts_rwmtx_tryrwlock(&regtab_rwmtx)
+#define reg_read_lock()			erts_rwmtx_rlock(&regtab_rwmtx)
+#define reg_write_lock()		erts_rwmtx_rwlock(&regtab_rwmtx)
+#define reg_read_unlock()		erts_rwmtx_runlock(&regtab_rwmtx)
+#define reg_write_unlock()		erts_rwmtx_rwunlock(&regtab_rwmtx)
 
-#ifdef ERTS_SMP
 static ERTS_INLINE void
 reg_safe_read_lock(Process *c_p, ErtsProcLocks *c_p_locks)
 {
@@ -64,7 +63,7 @@ reg_safe_read_lock(Process *c_p, ErtsProcLocks *c_p_locks)
 	}
 
 	/* Release process locks in order to avoid deadlock */
-	erts_smp_proc_unlock(c_p, *c_p_locks);
+	erts_proc_unlock(c_p, *c_p_locks);
 	*c_p_locks = 0;
     }
 
@@ -87,14 +86,13 @@ reg_safe_write_lock(Process *c_p, ErtsProcLocks *c_p_locks)
 	}
 
 	/* Release process locks in order to avoid deadlock */
-	erts_smp_proc_unlock(c_p, *c_p_locks);
+	erts_proc_unlock(c_p, *c_p_locks);
 	*c_p_locks = 0;
     }
 
     reg_write_lock();
 }
 
-#endif
 
 static ERTS_INLINE int
 is_proc_alive(Process *p)
@@ -141,11 +139,11 @@ static void reg_free(RegProc *obj)
 void init_register_table(void)
 {
     HashFunctions f;
-    erts_smp_rwmtx_opt_t rwmtx_opt = ERTS_SMP_RWMTX_OPT_DEFAULT_INITER;
-    rwmtx_opt.type = ERTS_SMP_RWMTX_TYPE_FREQUENT_READ;
-    rwmtx_opt.lived = ERTS_SMP_RWMTX_LONG_LIVED;
+    erts_rwmtx_opt_t rwmtx_opt = ERTS_RWMTX_OPT_DEFAULT_INITER;
+    rwmtx_opt.type = ERTS_RWMTX_TYPE_FREQUENT_READ;
+    rwmtx_opt.lived = ERTS_RWMTX_LONG_LIVED;
 
-    erts_smp_rwmtx_init_opt(&regtab_rwmtx, &rwmtx_opt, "reg_tab", NIL,
+    erts_rwmtx_init_opt(&regtab_rwmtx, &rwmtx_opt, "reg_tab", NIL,
         ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 
     f.hash = (H_FUN) reg_hash;
@@ -175,7 +173,7 @@ int erts_register_name(Process *c_p, Eterm name, Eterm id)
     Process *proc = NULL;
     Port *port = NULL;
     RegProc r, *rp;
-    ERTS_SMP_CHK_HAVE_ONLY_MAIN_PROC_LOCK(c_p);
+    ERTS_CHK_HAVE_ONLY_MAIN_PROC_LOCK(c_p);
 
     if (is_not_atom(name) || name == am_undefined)
 	return res;
@@ -185,7 +183,7 @@ int erts_register_name(Process *c_p, Eterm name, Eterm id)
     else {
 	if (is_not_internal_pid(id) && is_not_internal_port(id))
 	    return res;
-	erts_smp_proc_unlock(c_p, ERTS_PROC_LOCK_MAIN);
+	erts_proc_unlock(c_p, ERTS_PROC_LOCK_MAIN);
 	if (is_internal_port(id)) {
 	    port = erts_id2port(id);
 	    if (!port)
@@ -193,15 +191,13 @@ int erts_register_name(Process *c_p, Eterm name, Eterm id)
 	}
     }
 
-#ifdef ERTS_SMP
     {
 	ErtsProcLocks proc_locks = proc ? ERTS_PROC_LOCK_MAIN : 0;
 	reg_safe_write_lock(proc, &proc_locks);
 
 	if (proc && !proc_locks)
-	    erts_smp_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
+	    erts_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
     }
-#endif
 
     if (is_internal_pid(id)) {
 	if (!proc)
@@ -215,7 +211,7 @@ int erts_register_name(Process *c_p, Eterm name, Eterm id)
     }
     else {
 	ASSERT(!INVALID_PORT(port, id));
-	ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(port));
+	ERTS_LC_ASSERT(erts_lc_is_port_locked(port));
 	r.pt = port;
 	if (r.pt->common.u.alive.reg)
 	    goto done;
@@ -250,8 +246,8 @@ int erts_register_name(Process *c_p, Eterm name, Eterm id)
 	erts_port_release(port);
     if (c_p != proc) {
 	if (proc)
-	    erts_smp_proc_unlock(proc, ERTS_PROC_LOCK_MAIN);
-	erts_smp_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
+	    erts_proc_unlock(proc, ERTS_PROC_LOCK_MAIN);
+	erts_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
     }
     return res;
 }
@@ -272,17 +268,15 @@ erts_whereis_name_to_id(Process *c_p, Eterm name)
     HashValue hval;
     int ix;
     HashBucket* b;
-#ifdef ERTS_SMP
     ErtsProcLocks c_p_locks = 0;
     if (c_p) {
         c_p_locks = ERTS_PROC_LOCK_MAIN;
-        ERTS_SMP_CHK_HAVE_ONLY_MAIN_PROC_LOCK(c_p);
+        ERTS_CHK_HAVE_ONLY_MAIN_PROC_LOCK(c_p);
     }
     reg_safe_read_lock(c_p, &c_p_locks);
 
     if (c_p && !c_p_locks)
-        erts_smp_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
-#endif
+        erts_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
 
     hval = REG_HASH(name);
     ix = hval % process_reg.size;
@@ -331,7 +325,6 @@ erts_whereis_name(Process *c_p,
     HashValue hval;
     int ix;
     HashBucket* b;
-#ifdef ERTS_SMP
     ErtsProcLocks current_c_p_locks;
     Port *pending_port = NULL;
 
@@ -348,7 +341,6 @@ erts_whereis_name(Process *c_p,
      * - read reg lock
      * - current_c_p_locks (either c_p_locks or 0) on c_p
      */
-#endif
 
     hval = REG_HASH(name);
     ix = hval % process_reg.size;
@@ -370,7 +362,6 @@ erts_whereis_name(Process *c_p,
 	if (!rp)
 	    *proc = NULL;
 	else {
-#ifdef ERTS_SMP
 	    if (!rp->p)
 		*proc = NULL;
 	    else {
@@ -387,17 +378,10 @@ erts_whereis_name(Process *c_p,
 		    *proc = rp->p;
 		else {
 		    if (need_locks)
-			erts_smp_proc_unlock(rp->p, need_locks);
+			erts_proc_unlock(rp->p, need_locks);
 		    *proc = NULL;
 		}
 	    }
-#else
-	    if (rp->p
-		&& ((flags & ERTS_P2P_FLG_ALLOW_OTHER_X) || is_proc_alive(rp->p)))
-		*proc = rp->p;
-	    else
-		*proc = NULL;
-#endif
 	    if (*proc && (flags & ERTS_P2P_FLG_INC_REFC))
 		erts_proc_inc_refc(*proc);
 	}
@@ -407,7 +391,6 @@ erts_whereis_name(Process *c_p,
 	if (!rp || !rp->pt)
 	    *port = NULL;
 	else {
-#ifdef ERTS_SMP
             if (lock_port) {
                 if (pending_port == rp->pt)
                     pending_port = NULL;
@@ -419,11 +402,11 @@ erts_whereis_name(Process *c_p,
                         pending_port = NULL;
                     }
 		    
-                    if (erts_smp_port_trylock(rp->pt) == EBUSY) {
+                    if (erts_port_trylock(rp->pt) == EBUSY) {
                         Eterm id = rp->pt->common.id; /* id read only... */
                         /* Unlock all locks, acquire port lock, and restart... */
                         if (current_c_p_locks) {
-                            erts_smp_proc_unlock(c_p, current_c_p_locks);
+                            erts_proc_unlock(c_p, current_c_p_locks);
                             current_c_p_locks = 0;
                         }
                         reg_read_unlock();
@@ -431,19 +414,16 @@ erts_whereis_name(Process *c_p,
                         goto restart;
                     }
                 }
-                ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(rp->pt));
+                ERTS_LC_ASSERT(erts_lc_is_port_locked(rp->pt));
             }
-#endif
 	    *port = rp->pt;
 	}
     }
 
-#ifdef ERTS_SMP
     if (c_p && !current_c_p_locks)
-	erts_smp_proc_lock(c_p, c_p_locks);
+	erts_proc_lock(c_p, c_p_locks);
     if (pending_port)
 	erts_port_release(pending_port);
-#endif
 
     reg_read_unlock();
 }
@@ -476,7 +456,6 @@ int erts_unregister_name(Process *c_p,
     RegProc r, *rp;
     Port *port = c_prt;
     ErtsProcLocks current_c_p_locks = 0;
-#ifdef ERTS_SMP
 
     /*
      * SMP note: If 'c_prt != NULL' and 'c_prt->reg->name == name',
@@ -492,18 +471,15 @@ int erts_unregister_name(Process *c_p,
  restart:
 
     reg_safe_write_lock(c_p, &current_c_p_locks);
-#endif
 
     r.name = name;
     if (is_non_value(name)) {
 	/* Unregister current process name */
 	ASSERT(c_p);
-#ifdef ERTS_SMP
 	if (current_c_p_locks != c_p_locks) {
-	    erts_smp_proc_lock(c_p, c_p_locks);
+	    erts_proc_lock(c_p, c_p_locks);
 	    current_c_p_locks = c_p_locks;
 	}
-#endif
 	if (c_p->common.u.alive.reg) {
 	    r.name = c_p->common.u.alive.reg->name;
 	} else {
@@ -516,36 +492,34 @@ int erts_unregister_name(Process *c_p,
     if ((rp = (RegProc*) hash_get(&process_reg, (void*) &r)) != NULL) {
 	if (rp->pt) {
 	    if (port != rp->pt) {
-#ifdef ERTS_SMP
 		if (port) {
 		    ASSERT(port != c_prt);
 		    erts_port_release(port);
 		    port = NULL;
 		}
 
-		if (erts_smp_port_trylock(rp->pt) == EBUSY) {
+		if (erts_port_trylock(rp->pt) == EBUSY) {
 		    Eterm id = rp->pt->common.id; /* id read only... */
 		    /* Unlock all locks, acquire port lock, and restart... */
 		    if (current_c_p_locks) {
-			erts_smp_proc_unlock(c_p, current_c_p_locks);
+			erts_proc_unlock(c_p, current_c_p_locks);
 			current_c_p_locks = 0;
 		    }
 		    reg_write_unlock();
 		    port = erts_id2port(id);
 		    goto restart;
 		}
-#endif
 		port = rp->pt;
 	    }
 
 	    ASSERT(rp->pt == port);
-	    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(port));
+	    ERTS_LC_ASSERT(erts_lc_is_port_locked(port));
 
 	    rp->pt->common.u.alive.reg = NULL;
 
 	    if (IS_TRACED_FL(port, F_TRACE_PORTS)) {
                 if (current_c_p_locks) {
-                    erts_smp_proc_unlock(c_p, current_c_p_locks);
+                    erts_proc_unlock(c_p, current_c_p_locks);
                     current_c_p_locks = 0;
                 }
 		trace_port(port, am_unregister, r.name);
@@ -553,7 +527,6 @@ int erts_unregister_name(Process *c_p,
 
 	} else if (rp->p) {
 
-#ifdef ERTS_SMP
 	    erts_proc_safelock(c_p,
 			       current_c_p_locks,
 			       c_p_locks,
@@ -561,17 +534,14 @@ int erts_unregister_name(Process *c_p,
 			       (c_p == rp->p) ?  current_c_p_locks : 0,
 			       ERTS_PROC_LOCK_MAIN);
 	    current_c_p_locks = c_p_locks;
-#endif
 	    rp->p->common.u.alive.reg = NULL;
 	    if (IS_TRACED_FL(rp->p, F_TRACE_PROCS)) {
                 trace_proc(rp->p, (c_p == rp->p) ? c_p_locks : ERTS_PROC_LOCK_MAIN,
                            rp->p, am_unregister, r.name);
 	    }
-#ifdef ERTS_SMP
 	    if (rp->p != c_p) {
-		erts_smp_proc_unlock(rp->p, ERTS_PROC_LOCK_MAIN);
+		erts_proc_unlock(rp->p, ERTS_PROC_LOCK_MAIN);
 	    }
-#endif
 	}
 	hash_erase(&process_reg, (void*) &r);
 	res = 1;
@@ -585,14 +555,12 @@ int erts_unregister_name(Process *c_p,
 	    erts_port_release(port);
 	}
 	if (c_prt) {
-	    erts_smp_port_lock(c_prt);
+	    erts_port_lock(c_prt);
 	}
     }
-#ifdef ERTS_SMP
     if (c_p && !current_c_p_locks) {
-	erts_smp_proc_lock(c_p, c_p_locks);
+	erts_proc_lock(c_p, c_p_locks);
     }
-#endif
     return res;
 }
 
@@ -633,14 +601,12 @@ BIF_RETTYPE registered_0(BIF_ALIST_0)
     Uint need;
     Eterm* hp;
     HashBucket **bucket;
-#ifdef ERTS_SMP
     ErtsProcLocks proc_locks = ERTS_PROC_LOCK_MAIN;
 
-    ERTS_SMP_CHK_HAVE_ONLY_MAIN_PROC_LOCK(BIF_P);
+    ERTS_CHK_HAVE_ONLY_MAIN_PROC_LOCK(BIF_P);
     reg_safe_read_lock(BIF_P, &proc_locks);
     if (!proc_locks)
-	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
-#endif
+	erts_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 
     bucket = process_reg.bucket;