Rewrite and simplify thread support for upstream OpenBSD code.

Clean up uses of "thread_private.h", which is an OpenBSD implementation detail that doesn't belong in libc/private/.

Our arc4random() can be more like upstream OpenBSD by using MADV_WIPEONFORK. Also prefer to die via async_safe_fatal() rather than returning and relying on the caller (which is OpenBSD code that just calls abort() without a message).

Change-Id: I3804a648414b222ad752ab4b6b940d54fd7dd16f

Author: enh-google

libc/Android.bp

@@ -998,7 +998,6 @@ cc_library_static {
         "bionic/system_property_set.cpp",
         "bionic/tdestroy.cpp",
         "bionic/termios.cpp",
-        "bionic/thread_private.cpp",
         "bionic/threads.cpp",
         "bionic/time.cpp",
         "bionic/tmpfile.cpp",

libc/bionic/libc_init_common.cpp

@@ -49,7 +49,6 @@
 #include "private/bionic_defs.h"
 #include "private/bionic_globals.h"
 #include "private/bionic_tls.h"
-#include "private/thread_private.h"
 #include "pthread_internal.h"
 
 extern "C" int __system_properties_init(void);
@@ -108,11 +107,6 @@ static void __check_max_thread_id() {
 }
 #endif
 
-static void arc4random_fork_handler() {
-  _rs_forked = 1;
-  _thread_arc4_lock();
-}
-
 __BIONIC_WEAK_FOR_NATIVE_BRIDGE
 void __libc_init_scudo() {
   // Heap tagging level *must* be set before interacting with Scudo, otherwise
@@ -203,9 +197,12 @@ void __libc_init_common() {
 #endif
 }
 
+extern "C" void arc4random_mutex_lock();
+extern "C" void arc4random_mutex_unlock();
+
 void __libc_init_fork_handler() {
   // Register atfork handlers to take and release the arc4random lock.
-  pthread_atfork(arc4random_fork_handler, _thread_arc4_unlock, _thread_arc4_unlock);
+  pthread_atfork(arc4random_mutex_lock, arc4random_mutex_unlock, arc4random_mutex_unlock);
 }
 
 extern "C" void scudo_malloc_set_add_large_allocation_slack(int add_slack);

libc/bionic/thread_private.cpp

@@ -56,7 +56,6 @@
 #include "private/FdPath.h"
 #include "private/__bionic_get_shell_path.h"
 #include "private/bionic_fortify.h"
-#include "private/thread_private.h"
 
 #define	NDYNAMIC 10		/* add ten more whenever necessary */
 

libc/private/thread_private.h

@@ -1,4 +1,4 @@
-/*	$OpenBSD: arc4random_linux.h,v 1.7 2014/07/20 20:51:13 bcook Exp $	*/
+/*    $OpenBSD: arc4random_linux.h,v 1.7 2014/07/20 20:51:13 bcook Exp $    */
 
 /*
  * Copyright (c) 1996, David Mazieres <dm@uun.org>
@@ -18,67 +18,56 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-/*
- * Stub functions for portability.
- */
-
-#include <errno.h>
 #include <pthread.h>
-#include <signal.h>
 #include <sys/mman.h>
 #include <sys/prctl.h>
 
 #include <async_safe/log.h>
 
-// Android gets these from "thread_private.h" so we can set an atfork handler.
-// TODO: we should investigate MADV_WIPEONFORK for the structs allocated
-// by _rs_allocate() [where OpenBSD uses their MAP_INHERIT_ZERO and has an
-// empty _rs_forkdetect()], but because the mutex guards the creation of that
-// VMA, we'd still need an external mutex, and we'd still want some way to
-// lock/unlock around a fork().
-#include "thread_private.h"
-//static pthread_mutex_t arc4random_mtx = PTHREAD_MUTEX_INITIALIZER;
-//#define _ARC4_LOCK()   pthread_mutex_lock(&arc4random_mtx)
-//#define _ARC4_UNLOCK() pthread_mutex_unlock(&arc4random_mtx)
+static pthread_mutex_t g_arc4random_mutex = PTHREAD_MUTEX_INITIALIZER;
 
-static inline void _getentropy_fail(void) {
-    async_safe_fatal("getentropy failed: %s", strerror(errno));
+void arc4random_mutex_lock() {
+  pthread_mutex_lock(&g_arc4random_mutex);
 }
 
-volatile sig_atomic_t _rs_forked;
+void arc4random_mutex_unlock() {
+  pthread_mutex_unlock(&g_arc4random_mutex);
+}
+
+#define _ARC4_LOCK() arc4random_mutex_lock()
+#define _ARC4_UNLOCK() arc4random_mutex_unlock()
 
-static inline void
-_rs_forkdetect(void)
-{
-	static pid_t _rs_pid = 0;
-	pid_t pid = getpid();
+static inline void _getentropy_fail(void) {
+  async_safe_fatal("getentropy failed: %m");
+}
 
-	if (_rs_pid == 0 || _rs_pid != pid || _rs_forked) {
-		_rs_pid = pid;
-		_rs_forked = 0;
-		if (rs)
-			memset(rs, 0, sizeof(*rs));
-	}
+static inline void _rs_forkdetect(void) {
+  // Not needed thanks to the MADV_WIPEONFORK below.
 }
 
-static inline int
-_rs_allocate(struct _rs **rsp, struct _rsx **rsxp)
-{
-	// OpenBSD's arc4random_linux.h allocates two separate mappings, but for
-	// themselves they just allocate both structs into one mapping like this.
-	struct {
-		struct _rs rs;
-		struct _rsx rsx;
-	} *p;
+static inline int _rs_allocate(struct _rs** rsp, struct _rsx** rsxp) {
+  // OpenBSD's arc4random_linux.h allocates two separate mappings, but for
+  // themselves they just allocate both structs into one mapping like this.
+  struct data {
+    struct _rs rs;
+    struct _rsx rsx;
+  };
+  const size_t size = sizeof(struct data);
 
-	if ((p = mmap(NULL, sizeof(*p), PROT_READ|PROT_WRITE,
-	    MAP_ANON|MAP_PRIVATE, -1, 0)) == MAP_FAILED)
-		return (-1);
+  struct data* p = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0);
+  if (p == MAP_FAILED) {
+    async_safe_fatal("arc4random data allocation failed: %m");
+  }
 
-	prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, p, sizeof(*p), "arc4random data");
+  // Equivalent to OpenBSD's minherit(MAP_INHERIT_ZERO).
+  if (madvise(p, size, MADV_WIPEONFORK) == -1) {
+    async_safe_fatal("arc4random data MADV_WIPEONFORK failed: %m");
+  }
 
-	*rsp = &p->rs;
-	*rsxp = &p->rsx;
+  // Give the allocation a name to make tombstones more intelligible.
+  prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, p, size, "arc4random data");
 
-	return (0);
+  *rsp = &p->rs;
+  *rsxp = &p->rsx;
+  return 0;
 }

libc/stdio/stdio.cpp

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <pthread.h>
+#include <time.h>
+
+// An internal OpenBSD interface, used by res_randomid() only.
+#define __MUTEX_NAME(name) __CONCAT(__libc_mutex_,name)
+#define _THREAD_PRIVATE_MUTEX(name) static pthread_mutex_t __MUTEX_NAME(name) = PTHREAD_MUTEX_INITIALIZER
+#define _THREAD_PRIVATE_MUTEX_LOCK(name) pthread_mutex_lock(&__MUTEX_NAME(name))
+#define _THREAD_PRIVATE_MUTEX_UNLOCK(name) pthread_mutex_unlock(&__MUTEX_NAME(name))
+
+// An internal OpenBSD interface, used by gdtoa only.
+// Note that these aren't exactly the usual OpenBSD ones which lazy-initialize!
+#define _MUTEX_LOCK(l) pthread_mutex_lock((pthread_mutex_t*) l)
+#define _MUTEX_UNLOCK(l) pthread_mutex_unlock((pthread_mutex_t*) l)