[libc][NFC] Do not call mmap and munmap from thread functions.

[sivachandra]

Summary

Instead, memory is allocated and deallocated using mmap and munmap
syscalls directly.

[michaelrj]

LGTM

libc/src/threads/linux/CMakeLists.txt

add_entrypoint_object(
   thrd_create
   SRCS
     thrd_create.cpp
   HDRS
     ../thrd_create.h
   DEPENDS
     .threads_utils
     libc.include.errno
+    libc.include.sys_mman
     libc.include.sys_syscall
     libc.include.threads
     libc.src.__support.common
     libc.src.__support.OSUtil.osutil
-    libc.src.errno.errno
-    libc.src.sys.mman.mmap
   COMPILE_OPTIONS
     -O3
     -fno-omit-frame-pointer # This allows us to sniff out the thread args from
                             # the new thread's stack reliably.
 )
 
 add_entrypoint_object(
   thrd_join
   SRCS
     thrd_join.cpp
   HDRS
     ../thrd_join.h
   DEPENDS
     .threads_utils
     libc.include.sys_syscall
     libc.include.threads
     libc.src.__support.CPP.atomic
     libc.src.__support.common
     libc.src.__support.OSUtil.osutil
-    libc.src.sys.mman.munmap
 )
 
 add_entrypoint_object(
   cnd_init
   SRCS
     cnd_init.cpp
   HDRS
     ../cnd_init.h

libc/src/threads/linux/thrd_create.cpp

 //===-- Linux implementation of the thrd_create function ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Futex.h"
 
-#include "include/errno.h"                // For E* error values.
-#include "include/sys/mman.h"             // For PROT_* and MAP_* definitions.
-#include "include/sys/syscall.h"          // For syscall numbers.
-#include "include/threads.h"              // For thrd_* type definitions.
 #include "src/__support/OSUtil/syscall.h" // For syscall function.
 #include "src/__support/architectures.h"
 #include "src/__support/common.h"
-#include "src/errno/llvmlibc_errno.h"
-#include "src/sys/mman/mmap.h"
-#include "src/sys/mman/munmap.h"
 #include "src/threads/linux/Thread.h"
 #include "src/threads/thrd_create.h"
 
+#include <errno.h>       // For E* error values.
 #include <linux/sched.h> // For CLONE_* flags.
 #include <stdint.h>
+#include <sys/mman.h>    // For PROT_* and MAP_* definitions.
+#include <sys/syscall.h> // For syscall numbers.
+#include <threads.h>     // For thrd_* type definitions.
+
+#ifdef SYS_mmap2
+constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap2;
+#elif SYS_mmap
+constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap;
+#else
+#error "SYS_mmap or SYS_mmap2 not available on the target platform"
+#endif
 
 namespace __llvm_libc {
 
 // We align the start args to 16-byte boundary as we adjust the allocated
 // stack memory with its size. We want the adjusted address to be at a
 // 16-byte boundary to satisfy the x86_64 and aarch64 ABI requirements.
 // If different architecture in future requires higher alignment, then we
 // can add a platform specific alignment spec.
unsigned clone_flags =
       | CLONE_SYSVSEM // Share a single list of System V semaphore adjustment
                       // values
       | CLONE_PARENT_SETTID   // Set child thread ID in |ptid| of the parent.
       | CLONE_CHILD_CLEARTID; // Let the kernel clear the tid address and futex
                               // wake the joining thread.
   // TODO: Add the CLONE_SETTLS flag and setup the TLS area correctly when
   // making the clone syscall.
 
-  void *stack = __llvm_libc::mmap(nullptr, ThreadParams::DEFAULT_STACK_SIZE,
-                                  PROT_READ | PROT_WRITE,
-                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
-  if (stack == MAP_FAILED)
-    return llvmlibc_errno == ENOMEM ? thrd_nomem : thrd_error;
+  // Allocate thread stack.
+  long mmap_result =
+      __llvm_libc::syscall(MMAP_SYSCALL_NUMBER,
+                           0, // No special address
+                           ThreadParams::DEFAULT_STACK_SIZE,
+                           PROT_READ | PROT_WRITE,      // Read and write stack
+                           MAP_ANONYMOUS | MAP_PRIVATE, // Process private
+                           -1, // Not backed by any file
+                           0   // No offset
+      );
+  if (mmap_result < 0 && (uintptr_t(mmap_result) >=
+                          UINTPTR_MAX - ThreadParams::DEFAULT_STACK_SIZE)) {
+    return -mmap_result == ENOMEM ? thrd_nomem : thrd_error;
+  }
+  void *stack = reinterpret_cast<void *>(mmap_result);
 
   thread->__stack = stack;
   thread->__stack_size = ThreadParams::DEFAULT_STACK_SIZE;
   thread->__retval = -1;
   FutexWordType *clear_tid_address = &thread->__clear_tid.__word;
   *clear_tid_address = ThreadParams::CLEAR_TID_VALUE;
 
   // When the new thread is spawned by the kernel, the new thread gets the
#elif defined(LLVM_LIBC_ARCH_AARCH64)
   );
 #else
 #error "Unsupported architecture for the clone syscall."
 #endif
 
   if (clone_result == 0) {
     start_thread();
   } else if (clone_result < 0) {
-    __llvm_libc::munmap(thread->__stack, thread->__stack_size);
+    __llvm_libc::syscall(SYS_munmap, mmap_result,
+                         ThreadParams::DEFAULT_STACK_SIZE);
     int error_val = -clone_result;
     return error_val == ENOMEM ? thrd_nomem : thrd_error;
   }
 
   return thrd_success;
 }
 
 } // namespace __llvm_libc

libc/src/threads/linux/thrd_join.cpp

 //===-- Linux implementation of the thrd_join function --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Futex.h"
 
-#include "include/sys/syscall.h" // For syscall numbers.
-#include "include/threads.h"     // For thrd_* type definitions.
 #include "src/__support/CPP/atomic.h"
 #include "src/__support/OSUtil/syscall.h" // For syscall function.
 #include "src/__support/common.h"
-#include "src/sys/mman/munmap.h"
 #include "src/threads/linux/Thread.h"
 #include "src/threads/thrd_join.h"
 
 #include <linux/futex.h> // For futex operations.
+#include <sys/syscall.h> // For syscall numbers.
+#include <threads.h>     // For thrd_* type definitions.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, thrd_join, (thrd_t * thread, int *retval)) {
   auto *clear_tid_address =
       reinterpret_cast<cpp::Atomic<FutexWordType> *>(&thread->__clear_tid);
 
   // The kernel should set the value at the clear tid address to zero.
   // If not, it is a spurious wake and we should continue to wait on
   // the futex.
   while (clear_tid_address->load() != 0) {
     // We cannot do a FUTEX_WAIT_PRIVATE here as the kernel does a
     // FUTEX_WAKE and not a FUTEX_WAKE_PRIVATE.
     __llvm_libc::syscall(SYS_futex, &clear_tid_address->val, FUTEX_WAIT,
                          ThreadParams::CLEAR_TID_VALUE, nullptr);
   }
 
   *retval = thread->__retval;
 
-  if (__llvm_libc::munmap(thread->__stack, thread->__stack_size) == -1)
+  if (__llvm_libc::syscall(SYS_munmap, reinterpret_cast<long>(thread->__stack),
+                           thread->__stack_size) == -1)
     return thrd_error;
 
   return thrd_success;
 }
 
 } // namespace __llvm_libc