[LIBC] Support custom attributes in pthread_create

[goldstein.w.n]

Summary

Only functional for stack growsdown (same as before), but custom
stack, stacksize, guardsize, and detachstate all should be
working.

[goldstein.w.n]

Rebase

[goldstein.w.n]

Use LLVM style

[goldstein.w.n]

Fix some nits

[sivachandra]

Sorry for the long delay here. Part of the reason why I have been putting this off is because you mixed up some nice cleanups with the actual feature enhancements. I have not yet gone through the tests.

libc/src/__support/threads/linux/thread.cpp

88

You already check for overflow isn't it? So, do we need to keep this TODO? This pattern repeats at many places in this patch.

230

Nit: Because of the naming convention we use for constants, this should be named INTTERNAL_STACK_DATA_SIZE.

libc/src/__support/threads/thread.h

140

Nit: Naming style for all of these constants should be fixed.

libc/src/pthread/pthread_attr_getstacksize.cpp

23

Can you point me to documentation which says the getstack* functions should fail with EINVAL? They way I read the POSIX docs, I thought the setstack* functions fail with EINVAL on improper stack sizes.

libc/src/pthread/pthread_attr_init.cpp

20

We will do something better after this change lands.

21

Can we use the value in the Thread class?

libc/src/pthread/pthread_create.cpp

46

Going by my comment above, do we need this? Also, considering that all pthread_attr_set* functions fail anyway on bad inputs, do we need do these checks here at all?

58

You can use LIBC_UNLIKELY: https://github.com/llvm/llvm-project/blob/main/libc/src/__support/macros/optimization.h#L25

libc/src/threads/thrd_create.cpp

14–15

Do we need this?

[goldstein.w.n]

1. Fix error check in pthread_attr_get* changes
2. Remove todos that have already been addressed
3. Use defaults from thread.h
4. Add back support for stacksize == 0

libc/src/__support/threads/linux/thread.cpp

88

Sorry, kind of left those in as questions for you (maybe overflow check is unnecessary and such). Will drop those.

libc/src/pthread/pthread_attr_getstacksize.cpp

23

Bah, you are right. the getstack* manpage re-iterates that setstack* can fail. Misread as getstack*. Sorry.

libc/src/pthread/pthread_attr_init.cpp

21

Done for all but PTHREAD_CREATE_JOINABLE because I believe that one we have no choice about.

libc/src/pthread/pthread_create.cpp

46

Going by my comment above, do we need this? Also, considering that all pthread_attr_set* functions fail anyway on bad inputs, do we need do these checks here at all?

My feeling is code like this which is far far far from any critical path is best future-proofed.
But if you think its not worth it LMK and I'll drop.

58

Sure. Generally my feeling was its not worth the clutter in far from critical path code but annotated all the known-to-never fail cases here.

[sivachandra]

Few more minor comments, but overall LGTM now.

libc/src/__support/threads/linux/thread.cpp

492

This is a good catch! What do you think of just exiting with a return code of say -1 if the thread is detached? We can take this up separately.

libc/src/pthread/pthread_attr_setstack.cpp

29

We avoid calling one entrypoint from another. So, we should keep this as before.

libc/src/threads/thrd_create.cpp

14

This is there for IWYU which we try to enforce in general. But, few parts of the libc have likely regressed.

libc/test/integration/src/pthread/pthread_create_test.cpp

40

General style fixes for this file:

• Member names should be in snake_case style.
• Function and method names should be in snake_case style.
• Variable names are in lower_case style.

62

I am a bit surprised this is not leading to a build failure. We should do an equality test here:

ASSERT_EQ(__llvm_libc::pthread_attr_getstack(...), 0);

Same with other similar checks below.

219

Change the "person" of your comments, here and elsewhere are necessary, by using "we" instead of "I".

286

You can add such tests which are reasonable separately.

[goldstein.w.n]

libc/src/__support/threads/linux/thread.cpp

492

Won't that be a massive memory leak?

Although its not super clear how to handle this w.o some degree of inline-assembly.

[sivachandra]

libc/src/__support/threads/linux/thread.cpp

492

What I mean is, just add

__llvm_libc::syscall_impl(SYS_exit, -1);

after line 489 but before the end of the scope.

[goldstein.w.n]

libc/src/__support/threads/linux/thread.cpp

492

Ahh, makes sense. I'll create follow up for that.

[goldstein.w.n]

Fix style/comments in tests.
Add tests for invalidly set parameters (and support in pthread_create).
Use STACK_ALIGNMENT variable instead of magic number 16 throughout.
Don't use pthread_set_stacksize in pthread_set_stack, just inline impl

[goldstein.w.n]

libc/src/__support/threads/linux/thread.cpp

492

Made 0, is I think its all the same and we have some tests that pthread_exit returns success. But see: D151142

[goldstein.w.n]

Rebase

[goldstein.w.n]

This seems to be causing build-bot failures:

https://lab.llvm.org/buildbot/#/builders/223/builds/20528/steps/4/logs/stdio

FAILED: projects/libc/test/integration/src/pthread/libc.test.integration.src.pthread.pthread_create_test.__build__ 
: && /usr/bin/clang++ -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wc++98-compat-extra-semi -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -Wmisleading-indentation -Wctad-maybe-unsupported -fdiagnostics-color -g -nostdlib -static projects/libc/startup/linux/aarch64/CMakeFiles/libc.startup.linux.aarch64.crt1.dir/start.cpp.o projects/libc/test/IntegrationTest/CMakeFiles/libc.test.IntegrationTest.test.dir/test.cpp.o projects/libc/test/integration/src/pthread/CMakeFiles/libc.test.integration.src.pthread.pthread_create_test.__build__.dir/pthread_create_test.cpp.o -o projects/libc/test/integration/src/pthread/libc.test.integration.src.pthread.pthread_create_test.__build__  projects/libc/test/integration/src/pthread/liblibc.test.integration.src.pthread.pthread_create_test.libc.a && :
/usr/bin/ld: projects/libc/test/integration/src/pthread/CMakeFiles/libc.test.integration.src.pthread.pthread_create_test.__build__.dir/pthread_create_test.cpp.o: in function `__clang_call_terminate':
pthread_create_test.cpp:(.text.__clang_call_terminate[__clang_call_terminate]+0x4): undefined reference to `__cxa_begin_catch'
/usr/bin/ld: pthread_create_test.cpp:(.text.__clang_call_terminate[__clang_call_terminate]+0x8): undefined reference to `std::terminate()'
/usr/bin/ld: projects/libc/test/integration/src/pthread/CMakeFiles/libc.test.integration.src.pthread.pthread_create_test.__build__.dir/pthread_create_test.cpp.o:(.data.DW.ref.__gxx_personality_v0[DW.ref.__gxx_personality_v0]+0x0): undefined reference to `__gxx_personality_v0'

@sivachandra do you know whats missing? I'm unable to repro this locally.
Will revert if don't hear back in a few hours.

[sivachandra]

I have landed a fix: https://reviews.llvm.org/D151158

There were two problems - 1. The integration tests were being built without -fno-exceptions, 2. On the aarch64 builder, the page size is 64KB which was way bigger than the 16KB stack min.

[goldstein.w.n]

In D148290#4362719, @sivachandra wrote:

I have landed a fix: https://reviews.llvm.org/D151158

There were two problems - 1. The integration tests were being built without -fno-exceptions, 2. On the aarch64 builder, the page size is 64KB which was way bigger than the 16KB stack min.

Ah, thank you :)

libc/src/__support/threads/linux/thread.cpp

 #include "src/errno/libc_errno.h"                   // For error macros
 
 #ifdef LIBC_TARGET_ARCH_IS_AARCH64
 #include <arm_acle.h>
 #endif
 
 #include <fcntl.h>
 #include <linux/futex.h>
+#include <linux/param.h> // For EXEC_PAGESIZE.
 #include <linux/prctl.h> // For PR_SET_NAME
 #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.
 
 namespace __llvm_libc {
 
 #ifdef SYS_mmap2
 static constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap2;
 #elif SYS_mmap
 static constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap;
 #else
 #error "SYS_mmap or SYS_mmap2 not available on the target platform"
 #endif
 
 static constexpr size_t NAME_SIZE_MAX = 16; // Includes the null terminator
-static constexpr size_t DEFAULT_STACK_SIZE = (1 << 16); // 64KB
 static constexpr uint32_t CLEAR_TID_VALUE = 0xABCD1234;
 static constexpr unsigned CLONE_SYSCALL_FLAGS =
     CLONE_VM        // Share the memory space with the parent.
     | CLONE_FS      // Share the file system with the parent.
     | CLONE_FILES   // Share the files with the parent.
     | CLONE_SIGHAND // Share the signal handlers with the parent.
     | CLONE_THREAD  // Same thread group as the parent.
     | 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
                            // wake the joining thread.
     | CLONE_SETTLS;        // Setup the thread pointer of the new thread.
 
 #ifdef LIBC_TARGET_ARCH_IS_AARCH64
 #define CLONE_RESULT_REGISTER "x0"
 #elif defined(LIBC_TARGET_ARCH_IS_RISCV64)
 #define CLONE_RESULT_REGISTER "t0"
 #elif defined(LIBC_TARGET_ARCH_IS_X86_64)
 #define CLONE_RESULT_REGISTER "rax"
 #else
 #error "CLONE_RESULT_REGISTER not defined for your target architecture"
 #endif
 
-LIBC_INLINE ErrorOr<void *> alloc_stack(size_t size) {
+static constexpr ErrorOr<size_t> add_no_overflow(size_t lhs, size_t rhs) {
+  if (lhs > SIZE_MAX - rhs)
+    return Error{EINVAL};
+  if (rhs > SIZE_MAX - lhs)
+    return Error{EINVAL};
+  return lhs + rhs;
+}
+
+static constexpr ErrorOr<size_t> round_to_page(size_t v) {
+  auto vp_or_err = add_no_overflow(v, EXEC_PAGESIZE - 1);
+  if (!vp_or_err)
+    return vp_or_err;
+
+  return vp_or_err.value() & -EXEC_PAGESIZE;
+}
+
+LIBC_INLINE ErrorOr<void *> alloc_stack(size_t stacksize, size_t guardsize) {
+
+  // Guard needs to be mapped with PROT_NONE
+  int prot = guardsize ? PROT_NONE : PROT_READ | PROT_WRITE;
+  // TODO: Do we need to check for overflow?
+  auto size_or_err = add_no_overflow(stacksize, guardsize);
+  if (!size_or_err)
+    return Error{int(size_or_err.error())};
+  size_t size = size_or_err.value();
+
+  // TODO: Maybe add MAP_STACK? Currently unimplemented on linux but helps
+  // future-proof.
   long mmap_result =
       __llvm_libc::syscall_impl(MMAP_SYSCALL_NUMBER,
                                 0, // No special address
-                                size,
-                                PROT_READ | PROT_WRITE, // Read and write stack
-                                MAP_ANONYMOUS | MAP_PRIVATE, // Process private
+                                size, prot,
+                                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 - size))
     return Error{int(-mmap_result)};
+
+  if (guardsize) {
+    // TODO: We are assuming stack growsdown here.
+    // Give read/write permissions to actual stack.
+    long result =
+        __llvm_libc::syscall_impl(SYS_mprotect, mmap_result + guardsize,
+                                  stacksize, PROT_READ | PROT_WRITE);
+
+    if (result != 0)
+      return Error{int(-result)};
+  }
+  mmap_result += guardsize;
   return reinterpret_cast<void *>(mmap_result);
 }
 
-LIBC_INLINE void free_stack(void *stack, size_t size) {
-  __llvm_libc::syscall_impl(SYS_munmap, stack, size);
+LIBC_INLINE void free_stack(void *stack, size_t stacksize, size_t guardsize) {
+  uintptr_t stackaddr = reinterpret_cast<uintptr_t>(stack);
+  stackaddr -= guardsize;
+  stack = reinterpret_cast<void *>(stackaddr);
+  __llvm_libc::syscall_impl(SYS_munmap, stack, stacksize + guardsize);
 }
 
 struct Thread;
 
 // 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.
 struct alignas(STACK_ALIGNMENT) StartArgs {
   ThreadAttributes *thread_attrib;
   ThreadRunner runner;
   void *arg;
 };
 
 static void cleanup_thread_resources(ThreadAttributes *attrib) {
   // Cleanup the TLS before the stack as the TLS information is stored on
   // the stack.
   cleanup_tls(attrib->tls, attrib->tls_size);
   if (attrib->owned_stack)
-    free_stack(attrib->stack, attrib->stack_size);
+    free_stack(attrib->stack, attrib->stacksize, attrib->guardsize);
 }
 
 __attribute__((always_inline)) inline uintptr_t get_start_args_addr() {
 // NOTE: For __builtin_frame_address to work reliably across compilers,
 // architectures and various optimization levels, the TU including this file
 // should be compiled with -fno-omit-frame-pointer.
 #ifdef LIBC_TARGET_ARCH_IS_X86_64
   return reinterpret_cast<uintptr_t>(__builtin_frame_address(0))
if (attrib->style == ThreadStyle::POSIX) {
     attrib->retval.stdc_retval =
         start_args->runner.stdc_runner(start_args->arg);
     thread_exit(ThreadReturnValue(attrib->retval.stdc_retval),
                 ThreadStyle::STDC);
   }
 }
 
 int Thread::run(ThreadStyle style, ThreadRunner runner, void *arg, void *stack,
-                size_t size, bool detached) {
+                size_t stacksize, size_t guardsize, bool detached) {
   bool owned_stack = false;
   if (stack == nullptr) {
-    if (size == 0)
-      size = DEFAULT_STACK_SIZE;
-    auto alloc = alloc_stack(size);
+    // Roundup stacksize/guardsize to page size.
+    // TODO(1): Do we need to check for overflow?
+    // TODO(2): Should be also add sizeof(ThreadAttribute) and other internal
+    //          meta data?
+    auto round_or_err = round_to_page(guardsize);
+    if (!round_or_err)
+      return round_or_err.error();
+    guardsize = round_or_err.value();
+
+    round_or_err = round_to_page(stacksize);
+    if (!round_or_err)
+      return round_or_err.error();
+
+    stacksize = round_or_err.value();
+    auto alloc = alloc_stack(stacksize, guardsize);
     if (!alloc)
       return alloc.error();
     else
       stack = alloc.value();
     owned_stack = true;
   }
 
   TLSDescriptor tls;
   init_tls(tls);
 
   // When the new thread is spawned by the kernel, the new thread gets the
   // stack we pass to the clone syscall. However, this stack is empty and does
   // not have any local vars present in this function. Hence, one cannot
   // pass arguments to the thread start function, or use any local vars from
   // here. So, we pack them into the new stack from where the thread can sniff
   // them out.
   //
   // Likewise, the actual thread state information is also stored on the
   // stack memory.
-  uintptr_t adjusted_stack = reinterpret_cast<uintptr_t>(stack) + size -
-                             sizeof(StartArgs) - sizeof(ThreadAttributes) -
-                             sizeof(cpp::Atomic<FutexWordType>);
+
+  static constexpr size_t kInternalStackDataSize =
+      sizeof(StartArgs) + sizeof(ThreadAttributes) +
+
+  // This is pretty arbitrary, but at the moment we don't adjust user provided
+  // stacksize (or default) to account for this data as its assumed minimal. If
+  // this assert starts failing we probably should. Likewise if we can't bound
+  // this we may overflow when we subtract it from the top of the stack.
+  static_assert(kInternalStackDataSize < EXEC_PAGESIZE);
+
+  // TODO(1): We are assuming stack growsdown here.
+  // TODO(2): Do we need to check for overflow here?
+  auto adjusted_stack_or_err =
+      add_no_overflow(reinterpret_cast<uintptr_t>(stack), stacksize);
+  if (!adjusted_stack_or_err) {
+    cleanup_tls(tls.addr, tls.size);
+    if (owned_stack)
+      free_stack(stack, stacksize, guardsize);
+    return adjusted_stack_or_err.error();
+  }
+
+  uintptr_t adjusted_stack =
+      adjusted_stack_or_err.value() - kInternalStackDataSize;
   adjusted_stack &= ~(uintptr_t(STACK_ALIGNMENT) - 1);
 
   auto *start_args = reinterpret_cast<StartArgs *>(adjusted_stack);
 
   attrib =
       reinterpret_cast<ThreadAttributes *>(adjusted_stack + sizeof(StartArgs));
   attrib->style = style;
   attrib->detach_state =
       uint32_t(detached ? DetachState::DETACHED : DetachState::JOINABLE);
   attrib->stack = stack;
-  attrib->stack_size = size;
+  attrib->stacksize = stacksize;
+  attrib->guardsize = guardsize;
   attrib->owned_stack = owned_stack;
   attrib->tls = tls.addr;
   attrib->tls_size = tls.size;
 
   start_args->thread_attrib = attrib;
   start_args->runner = runner;
   start_args->arg = arg;
 
if (!attrib->detach_state.compare_exchange_strong(
     // Thread is detached so cleanup the resources.
     cleanup_thread_resources(attrib);
 
     // Set the CLEAR_TID address to nullptr to prevent the kernel
     // from signalling at a non-existent futex location.
     __llvm_libc::syscall_impl(SYS_set_tid_address, 0);
   }
 
+  // TODO: We may have deallocated the stack. Can we reference local variables
+  // that may have spilled?
   if (style == ThreadStyle::POSIX)
     __llvm_libc::syscall_impl(SYS_exit, retval.posix_retval);
   else
     __llvm_libc::syscall_impl(SYS_exit, retval.stdc_retval);
 }
 
 } // namespace __llvm_libc

libc/src/__support/threads/thread.h

struct alignas(STACK_ALIGNMENT) ThreadAttributes {
   //      (a) If the detach method sees the state as JOINABLE, then it will
   //          compare exchange to a state of DETACHED. The thread will clean
   //          itself up after it finishes.
   //      (b) If the detach method does not see JOINABLE in (a), then it will
   //          conclude that the thread is EXITING and will wait until the thread
   //          exits. It will clean up the thread resources once the thread
   //          exits.
   cpp::Atomic<uint32_t> detach_state;
-  void *stack;                   // Pointer to the thread stack
-  unsigned long long stack_size; // Size of the stack
-  uintptr_t tls;                 // Address to the thread TLS memory
-  uintptr_t tls_size;            // The size of area pointed to by |tls|.
+  void *stack;                  // Pointer to the thread stack
+  unsigned long long stacksize; // Size of the stack
+  unsigned long long guardsize; // Guard size on stack
+  uintptr_t tls;                // Address to the thread TLS memory
+  uintptr_t tls_size;           // The size of area pointed to by |tls|.
   unsigned char owned_stack; // Indicates if the thread owns this stack memory
   int tid;
   ThreadStyle style;
   ThreadReturnValue retval;
   ThreadAtExitCallbackMgr *atexit_callback_mgr;
   void *platform_data;
 
   constexpr ThreadAttributes()
       : detach_state(uint32_t(DetachState::DETACHED)), stack(nullptr),
-        stack_size(0), tls(0), tls_size(0), owned_stack(false), tid(-1),
-        style(ThreadStyle::POSIX), retval(), atexit_callback_mgr(nullptr),
-        platform_data(nullptr) {}
+        stacksize(0), guardsize(0), tls(0), tls_size(0), owned_stack(false),
+        tid(-1), style(ThreadStyle::POSIX), retval(),
+        atexit_callback_mgr(nullptr), platform_data(nullptr) {}
 };
 
 using TSSDtor = void(void *);
 
 // Create a new TSS key and associate the |dtor| as the corresponding
 // destructor. Can be used to implement public functions like
 // pthread_key_create.
 cpp::optional<unsigned int> new_tss_key(TSSDtor *dtor);

 bool set_tss_value(unsigned int key, void *value);
 
 // Return the value associated with |key| for the current thread. Return
 // nullptr if |key| is invalid. Can be used to implement public functions like
 // pthread_getspecific.
 void *get_tss_value(unsigned int key);
 
 struct Thread {
+  static constexpr size_t kDefaultStackSize = 1 << 16;
+  // TODO: default guardsize should be system pagesize
+  static constexpr size_t kDefaultGuardSize = 0;
+  static constexpr bool kDefaultDetached = false;
+
   ThreadAttributes *attrib;
 
   constexpr Thread() : attrib(nullptr) {}
   constexpr Thread(ThreadAttributes *attr) : attrib(attr) {}
 
-  int run(ThreadRunnerPosix *func, void *arg, void *stack, size_t size,
-          bool detached = false) {
+  int run(ThreadRunnerPosix *func, void *arg, void *stack = nullptr,
+          size_t stacksize = kDefaultStackSize,
+          size_t guardsize = kDefaultGuardSize,
+          bool detached = kDefaultDetached) {
     ThreadRunner runner;
     runner.posix_runner = func;
-    return run(ThreadStyle::POSIX, runner, arg, stack, size, detached);
+    return run(ThreadStyle::POSIX, runner, arg, stack, stacksize, guardsize,
+               detached);
   }
 
-  int run(ThreadRunnerStdc *func, void *arg, void *stack, size_t size,
-          bool detached = false) {
+  int run(ThreadRunnerStdc *func, void *arg, void *stack = nullptr,
+          size_t stacksize = kDefaultStackSize,
+          size_t guardsize = kDefaultGuardSize,
+          bool detached = kDefaultDetached) {
     ThreadRunner runner;
     runner.stdc_runner = func;
-    return run(ThreadStyle::STDC, runner, arg, stack, size, detached);
+    return run(ThreadStyle::STDC, runner, arg, stack, stacksize, guardsize,
+               detached);
   }
 
   int join(int *val) {
     ThreadReturnValue retval;
     int status = join(retval);
     if (status != 0)
       return status;
     *val = retval.stdc_retval;
     return 0;
   }
 
   int join(void **val) {
     ThreadReturnValue retval;
     int status = join(retval);
     if (status != 0)
       return status;
     *val = retval.posix_retval;
     return 0;
   }
 
   // Platform should implement the functions below.
 
   // Return 0 on success or an error value on failure.
   int run(ThreadStyle style, ThreadRunner runner, void *arg, void *stack,
-          size_t stack_size, bool detached);
+          size_t stacksize, size_t guardsize, bool detached);
 
   // Return 0 on success or an error value on failure.
   int join(ThreadReturnValue &retval);
 
   // Detach a joinable thread.
   //
   // This method does not have error return value. However, the type of detach
   // is returned to help with testing.

libc/src/pthread/CMakeLists.txt

 add_entrypoint_object(
   pthread_attr_getstack
   SRCS
     pthread_attr_getstack.cpp
   HDRS
     pthread_attr_getstack.h
   DEPENDS
     libc.include.pthread
+    libc.src.pthread.pthread_attr_getstacksize
 )
 
 add_entrypoint_object(
   pthread_attr_setstack
   SRCS
     pthread_attr_setstack.cpp
   HDRS
     pthread_attr_setstack.h
   DEPENDS
     libc.include.pthread
+    libc.src.pthread.pthread_attr_setstacksize
 )
 
 add_header_library(
   pthread_mutexattr
   HDRS
     pthread_mutexattr.h
   DEPENDS
     libc.src.__support.common
add_entrypoint_object(
   SRCS
     pthread_create.cpp
   HDRS
     pthread_create.h
   DEPENDS
     libc.include.errno
     libc.include.pthread
     libc.src.__support.threads.thread
+    libc.src.pthread.pthread_attr_destroy
+    libc.src.pthread.pthread_attr_init
+    libc.src.pthread.pthread_attr_getdetachstate
+    libc.src.pthread.pthread_attr_getguardsize
+    libc.src.pthread.pthread_attr_getstack
   COMPILE_OPTIONS
     -O3
     -fno-omit-frame-pointer
 )
 
 add_entrypoint_object(
   pthread_join
   SRCS

libc/src/pthread/pthread_attr_getstack.cpp

 //===-- Implementation of the pthread_attr_getstack -----------------===//
 //
 // 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 "pthread_attr_getstack.h"
+#include "pthread_attr_getstacksize.h"
 
 #include "src/__support/common.h"
 
 #include <pthread.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, pthread_attr_getstack,
                    (const pthread_attr_t *__restrict attr,
                     void **__restrict stack, size_t *__restrict stacksize)) {
+
+  // We are suppose to return EINVAL if __stacksize < PTHREAD_STACK_MIN.
+  // Probably unnecessary as we throw error if user tries to set invalid
+  // stacksize.
+  if (int result = __llvm_libc::pthread_attr_getstacksize(attr, stacksize))
+    return result;
   *stack = attr->__stack;
-  *stacksize = attr->__stacksize;
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/pthread/pthread_attr_getstacksize.cpp

 //===-- Implementation of the pthread_attr_getstacksize -----------------===//
 //
 // 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 "pthread_attr_getstacksize.h"
 
 #include "src/__support/common.h"
 
+#include <errno.h>
 #include <pthread.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, pthread_attr_getstacksize,
                    (const pthread_attr_t *__restrict attr,
                     size_t *__restrict stacksize)) {
+  // We are suppose to return EINVAL if __stacksize < PTHREAD_STACK_MIN.
+  // Probably unnecessary as we throw error if user tries to set invalid
+  // stacksize.
+  if (attr->__stacksize < PTHREAD_STACK_MIN)
+    return EINVAL;
   *stacksize = attr->__stacksize;
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/pthread/pthread_attr_init.cpp

 #include "src/__support/common.h"
 
 #include <linux/param.h> // For EXEC_PAGESIZE.
 #include <pthread.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, pthread_attr_init, (pthread_attr_t * attr)) {
+  // NB: This is exceedingly small compared to the 2MB norm and will break many
+  // programs expecting the full 2MB.
+  static constexpr size_t DEFAULT_STACK_SIZE = 1 << 16;
+
   *attr = pthread_attr_t{
-      false,         // Not detached
-      nullptr,       // Let the thread manage its stack
-      1 << 16,       // 64KB stack size
-      EXEC_PAGESIZE, // Default page size for the guard size.
+      PTHREAD_CREATE_JOINABLE, // Not detached
+      nullptr,                 // Let the thread manage its stack
+      DEFAULT_STACK_SIZE,      // stack size.
+      EXEC_PAGESIZE,           // Default page size for the guard size.
   };
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/pthread/pthread_attr_setstack.cpp

 //===-- Implementation of the pthread_attr_setstack -----------------===//
 //
 // 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 "pthread_attr_setstack.h"
+#include "pthread_attr_setstacksize.h"
 
 #include "src/__support/common.h"
 
 #include <errno.h>
-#include <linux/param.h> // For EXEC_PAGESIZE.
 #include <pthread.h>
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, pthread_attr_setstack,
                    (pthread_attr_t *__restrict attr, void *stack,
                     size_t stacksize)) {
-  if (stacksize < PTHREAD_STACK_MIN)
-    return EINVAL;
   uintptr_t stackaddr = reinterpret_cast<uintptr_t>(stack);
+
+  // TODO(1): '16' (stack alignment) should be in an target specific enum.
+  // TODO(2): Do we need to check for overflow on stackaddr + stacksize?
   if ((stackaddr % 16 != 0) || ((stackaddr + stacksize) % 16 != 0))
     return EINVAL;
+  if (int result = __llvm_libc::pthread_attr_setstacksize(attr, stacksize))
+    return result;
   attr->__stack = stack;
-  attr->__stacksize = stacksize;
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/pthread/pthread_attr_setstacksize.cpp

 //===-- Implementation of the pthread_attr_setstacksize -----------------===//
 //
 // 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 "pthread_attr_setstacksize.h"
 
 #include "src/__support/common.h"
 
 #include <errno.h>
-#include <linux/param.h> // For EXEC_PAGESIZE.
 #include <pthread.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, pthread_attr_setstacksize,
                    (pthread_attr_t *__restrict attr, size_t stacksize)) {
+  // TODO: Should we also ensure stacksize % EXEC_PAGESIZE == 0?
   if (stacksize < PTHREAD_STACK_MIN)
     return EINVAL;
   attr->__stack = nullptr;
   attr->__stacksize = stacksize;
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/pthread/pthread_create.cpp

 //===-- Linux implementation of the pthread_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 "pthread_create.h"
 
+#include "pthread_attr_destroy.h"
+#include "pthread_attr_init.h"
+
+#include "pthread_attr_getdetachstate.h"
+#include "pthread_attr_getguardsize.h"
+#include "pthread_attr_getstack.h"
+
 #include "src/__support/common.h"
 #include "src/__support/threads/thread.h"
 
 #include <errno.h>
 #include <pthread.h> // For pthread_* type definitions.
 
 namespace __llvm_libc {
 
 static_assert(sizeof(pthread_t) == sizeof(__llvm_libc::Thread),
               "Mismatch between pthread_t and internal Thread.");
 
 LLVM_LIBC_FUNCTION(int, pthread_create,
-                   (pthread_t *__restrict th, const pthread_attr_t *__restrict,
+                   (pthread_t *__restrict th,
+                    const pthread_attr_t *__restrict attr,
                     __pthread_start_t func, void *arg)) {
+  pthread_attr_t default_attr;
+  if (attr == nullptr) {
+    // We failed to initialize attributes (should be impossible)
+    if (__llvm_libc::pthread_attr_init(&default_attr))
+      return EINVAL;
+
+    attr = &default_attr;
+  }
+
+  void *stack;
+  size_t stacksize, guardsize;
+  int detached;
+
+  if (__llvm_libc::pthread_attr_getstack(attr, &stack, &stacksize))
+    return EINVAL;
+
+  if (__llvm_libc::pthread_attr_getguardsize(attr, &guardsize))
+    return EINVAL;
+
+  if (__llvm_libc::pthread_attr_getdetachstate(attr, &detached))
+    return EINVAL;
+
+  if (attr == &default_attr)
+    // Should we fail here? Its non-issue as the moment as pthread_attr_destroy
+    // can only succeed.
+    if (__llvm_libc::pthread_attr_destroy(&default_attr))
+      return EINVAL;
+
   auto *thread = reinterpret_cast<__llvm_libc::Thread *>(th);
-  // TODO: Use the attributes parameter to set up thread properties.
-  int result = thread->run(func, arg, nullptr, 0);
-  if (result != 0 && result != EPERM)
+  int result = thread->run(func, arg, stack, stacksize, guardsize,
+                           detached == PTHREAD_CREATE_DETACHED);
+  if (result != 0 && result != EPERM && result != EINVAL)
     return EAGAIN;
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/threads/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 "src/threads/thrd_create.h"
 #include "src/__support/common.h"
 #include "src/__support/threads/thread.h"
 
 #include <errno.h>
-#include <threads.h> // For thrd_* type definitions.
+#include <linux/param.h> // For EXEC_PAGESIZE.
+#include <threads.h>     // For thrd_* type definitions.
 
 namespace __llvm_libc {
 
 static_assert(sizeof(thrd_t) == sizeof(__llvm_libc::Thread),
               "Mismatch between thrd_t and internal Thread.");
 
 LLVM_LIBC_FUNCTION(int, thrd_create,
                    (thrd_t * th, thrd_start_t func, void *arg)) {
   auto *thread = reinterpret_cast<__llvm_libc::Thread *>(th);
-  int result = thread->run(func, arg, nullptr, 0);
+  int result = thread->run(func, arg);
   if (result == 0)
     return thrd_success;
   else if (result == ENOMEM)
     return thrd_nomem;
   else
     return thrd_error;
 }
 
 } // namespace __llvm_libc

libc/test/integration/src/__support/threads/thread_detach_test.cpp

void detach_simple_test() {
 
   // We will release |mutex| now to let the thread finish an cleanup itself.
   mutex.unlock();
 }
 
 void detach_cleanup_test() {
   mutex.lock();
   __llvm_libc::Thread th;
-  ASSERT_EQ(0, th.run(func, nullptr, nullptr, 0));
+  ASSERT_EQ(0, th.run(func, nullptr));
 
   // Since |mutex| is held by the current thread, we will release it
   // to let |th| run.
   mutex.unlock();
 
   // We will wait for |th| to finish. Since it is a joinable thread,
   // we can wait on it safely.
   th.wait();

libc/test/integration/src/pthread/CMakeLists.txt

DEPENDS
     libc.src.pthread.pthread_mutex_destroy
     libc.src.pthread.pthread_mutex_init
     libc.src.pthread.pthread_mutex_lock
     libc.src.pthread.pthread_mutex_unlock
     libc.src.pthread.pthread_create
     libc.src.pthread.pthread_join
     libc.src.__support.CPP.atomic
 )
+
+add_integration_test(
+  pthread_create_test
+  SUITE
+    libc-pthread-integration-tests
+  SRCS
+    pthread_create_test.cpp
+  DEPENDS
+    libc.include.pthread
+    libc.include.errno
+    libc.src.pthread.pthread_create
+    libc.src.pthread.pthread_join
+    libc.src.pthread.pthread_attr_getdetachstate
+    libc.src.pthread.pthread_attr_getguardsize
+    libc.src.pthread.pthread_attr_getstack
+    libc.src.pthread.pthread_attr_getstacksize
+    libc.src.pthread.pthread_attr_setdetachstate
+    libc.src.pthread.pthread_attr_setguardsize
+    libc.src.pthread.pthread_attr_setstack
+    libc.src.pthread.pthread_attr_setstacksize
+    libc.src.pthread.pthread_attr_init
+    libc.src.pthread.pthread_attr_destroy
+    libc.src.pthread.pthread_self
+    libc.src.sys.mman.mmap
+    libc.src.sys.mman.munmap
+    libc.src.sys.random.getrandom
+    libc.src.__support.threads.thread
+    libc.src.__support.CPP.atomic
+    libc.src.__support.CPP.array
+    libc.src.__support.CPP.new
+)

libc/test/integration/src/pthread/pthread_create_test.cpp

+//===-- Tests for pthread_create ------------------------------------------===//
+//
+// 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 "src/pthread/pthread_attr_destroy.h"
+#include "src/pthread/pthread_attr_getdetachstate.h"
+#include "src/pthread/pthread_attr_getguardsize.h"
+#include "src/pthread/pthread_attr_getstack.h"
+#include "src/pthread/pthread_attr_getstacksize.h"
+#include "src/pthread/pthread_attr_init.h"
+#include "src/pthread/pthread_attr_setdetachstate.h"
+#include "src/pthread/pthread_attr_setguardsize.h"
+#include "src/pthread/pthread_attr_setstack.h"
+#include "src/pthread/pthread_attr_setstacksize.h"
+#include "src/pthread/pthread_create.h"
+#include "src/pthread/pthread_join.h"
+#include "src/pthread/pthread_self.h"
+
+#include "src/sys/mman/mmap.h"
+#include "src/sys/mman/munmap.h"
+#include "src/sys/random/getrandom.h"
+
+#include "src/__support/CPP/array.h"
+#include "src/__support/CPP/atomic.h"
+#include "src/__support/CPP/new.h"
+#include "src/__support/threads/thread.h"
+#include "src/errno/libc_errno.h"
+
+#include "test/IntegrationTest/test.h"
+
+#include <linux/param.h> // For EXEC_PAGESIZE.
+#include <pthread.h>
+
+struct test_thread_args {
+  pthread_attr_t attrs;
+  void *ret;
+};
+static __llvm_libc::AllocChecker ac;
+static __llvm_libc::cpp::Atomic<long> thr_count = 0;
+
+static void *success_thread(void *arg) {
+  pthread_t th = __llvm_libc::pthread_self();
+  auto *thread = reinterpret_cast<__llvm_libc::Thread *>(&th);
+
+  ASSERT_EQ(libc_errno, 0);
+  ASSERT_TRUE(thread);
+  ASSERT_TRUE(thread->attrib);
+
+  test_thread_args *th_arg = reinterpret_cast<test_thread_args *>(arg);
+  pthread_attr_t *expec_attrs = &(th_arg->attrs);
+  void *ret = th_arg->ret;
+
+  void *expec_stack;
+  size_t expec_stacksize, expec_guardsize, expec_stacksize2;
+  int expec_detached;
+
+  ASSERT_FALSE(__llvm_libc::pthread_attr_getstack(expec_attrs, &expec_stack,
+                                                  &expec_stacksize));
+  ASSERT_EQ(libc_errno, 0);
+
+  ASSERT_FALSE(
+      __llvm_libc::pthread_attr_getstacksize(expec_attrs, &expec_stacksize2));
+  ASSERT_EQ(libc_errno, 0);
+
+  ASSERT_FALSE(
+      __llvm_libc::pthread_attr_getguardsize(expec_attrs, &expec_guardsize));
+  ASSERT_EQ(libc_errno, 0);
+
+  ASSERT_FALSE(
+      __llvm_libc::pthread_attr_getdetachstate(expec_attrs, &expec_detached));
+  ASSERT_EQ(libc_errno, 0);
+
+  ASSERT_EQ(expec_stacksize, expec_stacksize2);
+
+  ASSERT_TRUE(thread->attrib->stack);
+  if (expec_stack != nullptr) {
+    ASSERT_EQ(thread->attrib->stack, expec_stack);
+  } else {
+    ASSERT_EQ(reinterpret_cast<uintptr_t>(thread->attrib->stack) %
+                  EXEC_PAGESIZE,
+              static_cast<uintptr_t>(0));
+    expec_stacksize = (expec_stacksize + EXEC_PAGESIZE - 1) & (-EXEC_PAGESIZE);
+  }
+
+  ASSERT_TRUE(expec_stacksize);
+  ASSERT_EQ(thread->attrib->stacksize, expec_stacksize);
+  ASSERT_EQ(thread->attrib->guardsize, expec_guardsize);
+
+  ASSERT_EQ(expec_detached == PTHREAD_CREATE_JOINABLE,
+            thread->attrib->detach_state.load() ==
+                static_cast<uint32_t>(__llvm_libc::DetachState::JOINABLE));
+  ASSERT_EQ(expec_detached == PTHREAD_CREATE_DETACHED,
+            thread->attrib->detach_state.load() ==
+                static_cast<uint32_t>(__llvm_libc::DetachState::DETACHED));
+
+  {
+    // Allocate some bytes on the stack on most of the stack and make sure we
+    // have read/write permissions on the memory. -EXEC_PAGESIZE / 2 just as a
+    // buffer so we don't go beyond our limits (no nested function calls / not
+    // much other data on the stack so should be enough).
+    size_t test_stacksize = expec_stacksize - EXEC_PAGESIZE / 2;
+    volatile uint8_t *bytes_on_stack =
+        (volatile uint8_t *)__builtin_alloca(test_stacksize);
+
+    for (size_t i = 0; i < test_stacksize; ++i) {
+      // Write permissions
+      bytes_on_stack[i] = static_cast<uint8_t>(i);
+    }
+
+    for (size_t i = 0; i < test_stacksize; ++i) {
+      // Read/write permissions
+      bytes_on_stack[i] += static_cast<uint8_t>(i);
+    }
+  }
+
+  // TODO: If guardsize != 0 && expec_stack == nullptr we should confirm that
+  // [stack - expec_guardsize, stack) is both mapped and has PROT_NONE
+  // permissions. Only way I can think of is to read from /proc/{self}/map.
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_destroy(expec_attrs), 0);
+  ASSERT_EQ(libc_errno, 0);
+
+  // Arg is malloced, so free.
+  delete th_arg;
+  thr_count.fetch_sub(1);
+  return ret;
+}
+
+static void run_success_config(int detachstate, size_t guardsize,
+                               size_t stacksize, bool customstack) {
+
+  test_thread_args *th_arg = new (ac) test_thread_args{};
+  pthread_attr_t *attr = &(th_arg->attrs);
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_init(attr), 0);
+  ASSERT_EQ(libc_errno, 0);
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_setdetachstate(attr, detachstate), 0);
+  ASSERT_EQ(libc_errno, 0);
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_setguardsize(attr, guardsize), 0);
+  ASSERT_EQ(libc_errno, 0);
+
+  void *stack = nullptr;
+  if (customstack) {
+    stack = __llvm_libc::mmap(nullptr, stacksize, PROT_READ | PROT_WRITE,
+                              MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    ASSERT_NE(stack, MAP_FAILED);
+    ASSERT_NE(stack, static_cast<void *>(nullptr));
+    ASSERT_EQ(libc_errno, 0);
+
+    ASSERT_EQ(__llvm_libc::pthread_attr_setstack(attr, stack, stacksize), 0);
+    ASSERT_EQ(libc_errno, 0);
+  } else {
+    ASSERT_EQ(__llvm_libc::pthread_attr_setstacksize(attr, stacksize), 0);
+    ASSERT_EQ(libc_errno, 0);
+  }
+
+  void *expec_ret = nullptr;
+  if (detachstate == PTHREAD_CREATE_JOINABLE) {
+    ASSERT_EQ(__llvm_libc::getrandom(&expec_ret, sizeof(expec_ret), 0),
+              static_cast<ssize_t>(sizeof(expec_ret)));
+    ASSERT_EQ(libc_errno, 0);
+  }
+
+  th_arg->ret = expec_ret;
+  thr_count.fetch_add(1);
+
+  pthread_t tid;
+  // th_arg and attr are cleanup by the thread.
+  ASSERT_EQ(__llvm_libc::pthread_create(&tid, attr, success_thread,
+                                        reinterpret_cast<void *>(th_arg)),
+            0);
+  ASSERT_EQ(libc_errno, 0);
+
+  if (detachstate == PTHREAD_CREATE_JOINABLE) {
+    void *th_ret;
+    ASSERT_EQ(__llvm_libc::pthread_join(tid, &th_ret), 0);
+    ASSERT_EQ(libc_errno, 0);
+    ASSERT_EQ(th_ret, expec_ret);
+
+    if (customstack) {
+      ASSERT_EQ(__llvm_libc::munmap(stack, stacksize), 0);
+      ASSERT_EQ(libc_errno, 0);
+    }
+  } else {
+    ASSERT_FALSE(customstack);
+  }
+}
+
+static void run_success_tests() {
+
+  // Test parameters
+  using __llvm_libc::cpp::array;
+
+  array<int, 2> detachstates = {PTHREAD_CREATE_DETACHED,
+                                PTHREAD_CREATE_JOINABLE};
+  array<size_t, 4> guardsizes = {0, EXEC_PAGESIZE, 2 * EXEC_PAGESIZE,
+                                 123 * EXEC_PAGESIZE};
+  array<size_t, 6> stacksizes = {PTHREAD_STACK_MIN,
+                                 PTHREAD_STACK_MIN + 16,
+                                 (1 << 16) - EXEC_PAGESIZE / 2,
+                                 (1 << 16) + EXEC_PAGESIZE / 2,
+                                 1234560,
+                                 1234560 * 2};
+  array<bool, 2> customstacks = {true, false};
+
+  for (int detachstate : detachstates) {
+    for (size_t guardsize : guardsizes) {
+      for (size_t stacksize : stacksizes) {
+        for (bool customstack : customstacks) {
+          if (customstack) {
+
+            // TODO: I can't figure out how to test a user allocated stack along
+            // with detached pthread safely. We can't let the thread deallocate
+            // it owns stack for obvious reasons. And there doesn't appear to be
+            // a good way to check if a detached thread has exited.
+            if (detachstate == PTHREAD_CREATE_DETACHED)
+              continue;
+
+            // guardsize has no meaning with user provided stack.
+            if (guardsize)
+              continue;
+
+            run_success_config(detachstate, guardsize, stacksize, customstack);
+          }
+        }
+      }
+    }
+  }
+
+  // Wait for detached threads to finish testing (this is not gurantee they will
+  // have cleaned up)
+  while (thr_count.load())
+    ;
+}
+
+static void *failure_thread(void *) {
+  // Should be unreachable;
+  ASSERT_TRUE(false);
+  return nullptr;
+}
+static void run_failure_config(size_t guardsize, size_t stacksize) {
+  pthread_attr_t attr;
+  guardsize &= -EXEC_PAGESIZE;
+  ASSERT_EQ(__llvm_libc::pthread_attr_init(&attr), 0);
+  ASSERT_EQ(libc_errno, 0);
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_setguardsize(&attr, guardsize), 0);
+  ASSERT_EQ(libc_errno, 0);
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_setstacksize(&attr, stacksize), 0);
+  ASSERT_EQ(libc_errno, 0);
+
+  pthread_t tid;
+  int result =
+      __llvm_libc::pthread_create(&tid, &attr, failure_thread, nullptr);
+  // EINVAL if we caught on overflow or something of that nature. EAGAIN if it
+  // was just really larger we failed mmap.
+  ASSERT_TRUE(result == EINVAL || result == EAGAIN);
+  // pthread_create should NOT set errno on error
+  ASSERT_EQ(libc_errno, 0);
+
+  ASSERT_EQ(__llvm_libc::pthread_attr_destroy(&attr), 0);
+  ASSERT_EQ(libc_errno, 0);
+}
+
+static void run_failure_tests() {
+  // Just some tests where the user sets "valid" parameters but they fail
+  // (overflow or too large to allocate).
+  run_failure_config(SIZE_MAX, PTHREAD_STACK_MIN);
+  run_failure_config(SIZE_MAX - PTHREAD_STACK_MIN, PTHREAD_STACK_MIN * 2);
+  run_failure_config(PTHREAD_STACK_MIN, SIZE_MAX);
+  run_failure_config(PTHREAD_STACK_MIN, SIZE_MAX - PTHREAD_STACK_MIN);
+  run_failure_config(SIZE_MAX / 2, SIZE_MAX / 2);
+  run_failure_config(SIZE_MAX / 4, SIZE_MAX / 4);
+  run_failure_config(SIZE_MAX / 2 + 1234, SIZE_MAX / 2);
+
+  // TODO: Should we add some tests where the user sets invalid values in the
+  // attr field (i.e a stacksize < PTHREAD_STACK_MIN)? The pthread_attr_set* API
+  // should guard against that, but people might accidentaly use uninitialized
+  // memory or w.e)
+}
+
+TEST_MAIN() {
+  libc_errno = 0;
+  run_success_tests();
+  run_failure_tests();
+  return 0;
+}