[libc] Add GNU extension functions pthread_setname_np and pthread_getname_np.

[michaelrj]

libc/spec/spec.td

110

would it be reasonable to make the gnu extensions depend on the posix extensions instead of moving this to the global types?

[sivachandra]

libc/spec/spec.td

110

I suppose you mean that we should include posix.td in gnu.td? I think that is a fair concern in this particular case as this particular GNU extension is actually an extension of the POSIX standard. But, that is not the case in general. Also, the .td files are like the header files. So, say posix.td includes stdc.td and gnu_ext.td also includes stdc.td, then a config including posix,td, gnu_ext.td and stdc.td will get duplicate/triplicate definitions. Even if we have something like a header-guard to avoid such duplicates, what will happen is that a config wanting, say only the GNU extensions, will also see the POSIX extensions.

[michaelrj]

LGTM

libc/spec/spec.td

110

I see, in that case this is fine.

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     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_create
     libc.src.pthread.pthread_detach
     libc.src.pthread.pthread_equal
+    libc.src.pthread.pthread_getname_np
     libc.src.pthread.pthread_join
     libc.src.pthread.pthread_self
+    libc.src.pthread.pthread_setname_np
     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_mutexattr_destroy
     libc.src.pthread.pthread_mutexattr_init
     libc.src.pthread.pthread_mutexattr_getpshared
     libc.src.pthread.pthread_mutexattr_getrobust

libc/spec/gnu_ext.td

HeaderSpec StdIO = HeaderSpec<
               [ArgSpec<ConstVoidRestrictedPtr>,
                ArgSpec<SizeTType>,
                ArgSpec<SizeTType>,
                ArgSpec<FILERestrictedPtr>]
           >,
       ]
   >;
 
+  HeaderSpec PThread = HeaderSpec<
+      "pthread.h",
+      [], // Macros
+      [], // Types
+      [], // Enumerations
+      [
+          FunctionSpec<
+              "pthread_setname_np",
+              RetValSpec<IntType>,
+              [ArgSpec<PThreadTType>, ArgSpec<ConstCharPtr>]
+          >,
+          FunctionSpec<
+              "pthread_getname_np",
+              RetValSpec<IntType>,
+              [ArgSpec<PThreadTType>, ArgSpec<CharPtr>, ArgSpec<SizeTType>]
+          >,
+      ]
+  >;
+
   let Headers = [
     CType,
     FEnv,
     Math,
+    PThread,
     StdIO,
     String,
   ];
 }

libc/spec/posix.td

def POSIX : StandardSpec<"POSIX"> {
   ConstType ConstRestrictedPThreadMutexAttrTPtr = ConstType<RestrictedPThreadMutexAttrTPtr>;
 
   NamedType PThreadMutexTType = NamedType<"pthread_mutex_t">;
   PtrType PThreadMutexTPtr = PtrType<PThreadMutexTType>;
   RestrictedPtrType RestrictedPThreadMutexTPtr = RestrictedPtrType<PThreadMutexTType>;
   ConstType ConstPThreadMutexTPtr = ConstType<PThreadMutexTPtr>;
   ConstType ConstRestrictedPThreadMutexTPtr = ConstType<RestrictedPThreadMutexTPtr>;
 
-  NamedType PThreadTType = NamedType<"pthread_t">;
   PtrType PThreadTPtr = PtrType<PThreadTType>;
   RestrictedPtrType RestrictedPThreadTPtr = RestrictedPtrType<PThreadTType>;
 
   HeaderSpec Errno = HeaderSpec<
       "errno.h",
       [
         Macro<"E2BIG">,
         Macro<"EACCES">,

libc/spec/spec.td

 def QSortCompareT : NamedType<"__qsortcompare_t">;
 
 def AtexitHandlerT : NamedType<"__atexithandler_t">;
 
 def FILE : NamedType<"FILE">;
 def FILEPtr : PtrType<FILE>;
 def FILERestrictedPtr : RestrictedPtrType<FILE>;
 
+def PThreadTType : NamedType<"pthread_t">;
+
 //added because __assert_fail needs it.
 def UnsignedType : NamedType<"unsigned">;
 
 class Macro<string name> {
   string Name = name;
 }
 
 class EnumeratedNameValue<string name, string value = "__default__"> {

libc/src/__support/CPP/stringstream.h

public:
   // Write a single character.
   StringStream &operator<<(char a) {
     write(&a, 1);
     return *this;
   }
 
   // Return true if any write operation(s) failed due to insufficient size.
   bool overflow() const { return err; }
+
+  size_t bufsize() const { return data.size(); }
 };
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_STRINGSTREAM_H

libc/src/__support/threads/CMakeLists.txt

 
 add_header_library(
   thread_common
   HDRS
     thread.h
   DEPENDS
     libc.src.__support.common
     libc.src.__support.CPP.atomic
+    libc.src.__support.CPP.string_view
+    libc.src.__support.CPP.stringstream
 )
 
 if(TARGET libc.src.__support.threads.${LIBC_TARGET_OS}.thread)
   add_object_library(
     thread
     SRCS
       thread.cpp
     DEPENDS
       .${LIBC_TARGET_OS}.thread
   )
 endif()

libc/src/__support/threads/linux/CMakeLists.txt

add_object_library(
   SRCS
     thread.cpp
   DEPENDS
     .futex_word_type
     libc.config.linux.app_h
     libc.include.sys_syscall
     libc.src.__support.CPP.atomic
     libc.src.__support.CPP.error
+    libc.src.__support.CPP.stringstream
+    libc.src.__support.CPP.string_view
     libc.src.__support.threads.thread_common
   COMPILE_OPTIONS
     -O3
     -fno-omit-frame-pointer # This allows us to sniff out the thread args from
                             # the new thread's stack reliably.
 )

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

 //===--- Implementation of a Linux thread class -----------------*- C++ -*-===//
 //
 // 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/__support/threads/thread.h"
 #include "config/linux/app.h"
+#include "src/__support/CPP/StringView.h"
 #include "src/__support/CPP/atomic.h"
 #include "src/__support/CPP/error.h"
+#include "src/__support/CPP/stringstream.h"
 #include "src/__support/OSUtil/syscall.h"           // For syscall functions.
 #include "src/__support/threads/linux/futex_word.h" // For FutexWordType
 
 #ifdef LLVM_LIBC_ARCH_AARCH64
 #include <arm_acle.h>
 #endif
 
+#include <errno.h>
+#include <fcntl.h>
 #include <linux/futex.h>
+#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.
__llvm_libc::syscall(SYS_futex, &clear_tid->val, FUTEX_WAIT,
                          CLEAR_TID_VALUE, nullptr);
   }
 }
 
 bool Thread::operator==(const Thread &thread) const {
   return attrib->tid == thread.attrib->tid;
 }
 
+static constexpr cpp::StringView THREAD_NAME_PATH_PREFIX("/proc/self/task/");
+static constexpr size_t THREAD_NAME_PATH_SIZE =
+    THREAD_NAME_PATH_PREFIX.size() +
+    IntegerToString<int>::BUFSIZE + // Size of tid
+    1 +                             // For '/' character
+    5; // For the file name "comm" and the nullterminator.
+
+static void construct_thread_name_file_path(cpp::StringStream &stream,
+                                            int tid) {
+  stream << THREAD_NAME_PATH_PREFIX << tid << '/' << cpp::StringView("comm")
+         << cpp::StringStream::ENDS;
+}
+
+int Thread::set_name(const cpp::StringView &name) {
+  if (name.size() >= NAME_SIZE_MAX)
+    return ERANGE;
+
+  if (*this == self) {
+    // If we are setting the name of the current thread, then we can
+    // use the syscall to set the name.
+    int retval = __llvm_libc::syscall(SYS_prctl, PR_SET_NAME, name.data());
+    if (retval < 0)
+      return -retval;
+    else
+      return 0;
+  }
+
+  char path_name_buffer[THREAD_NAME_PATH_SIZE];
+  cpp::StringStream path_stream(path_name_buffer);
+  construct_thread_name_file_path(path_stream, attrib->tid);
+#ifdef SYS_open
+  int fd = __llvm_libc::syscall(SYS_open, path_name_buffer, O_RDWR);
+#else
+  int fd = __llvm_libc::syscall(SYS_openat, AT_FDCWD, path_name_buffer, O_RDWR);
+#endif
+  if (fd < 0)
+    return -fd;
+
+  int retval = __llvm_libc::syscall(SYS_write, fd, name.data(), name.size());
+  __llvm_libc::syscall(SYS_close, fd);
+
+  if (retval < 0)
+    return -retval;
+  else if (retval != int(name.size()))
+    return EIO;
+  else
+    return 0;
+}
+
+int Thread::get_name(cpp::StringStream &name) const {
+  if (name.bufsize() < NAME_SIZE_MAX)
+    return ERANGE;
+
+  char name_buffer[NAME_SIZE_MAX];
+
+  if (*this == self) {
+    // If we are getting the name of the current thread, then we can
+    // use the syscall to get the name.
+    int retval = __llvm_libc::syscall(SYS_prctl, PR_GET_NAME, name_buffer);
+    if (retval < 0)
+      return -retval;
+    name << name_buffer;
+    return 0;
+  }
+
+  char path_name_buffer[THREAD_NAME_PATH_SIZE];
+  cpp::StringStream path_stream(path_name_buffer);
+  construct_thread_name_file_path(path_stream, attrib->tid);
+#ifdef SYS_open
+  int fd = __llvm_libc::syscall(SYS_open, path_name_buffer, O_RDONLY);
+#else
+  int fd =
+      __llvm_libc::syscall(SYS_openat, AT_FDCWD, path_name_buffer, O_RDONLY);
+#endif
+  if (fd < 0)
+    return -fd;
+
+  int retval = __llvm_libc::syscall(SYS_read, fd, name_buffer, NAME_SIZE_MAX);
+  __llvm_libc::syscall(SYS_close, fd);
+  if (retval < 0)
+    return -retval;
+  if (retval == NAME_SIZE_MAX)
+    return ERANGE;
+  if (name_buffer[retval - 1] == '\n')
+    name_buffer[retval - 1] = '\0';
+  else
+    name_buffer[retval] = '\0';
+  name << name_buffer;
+  return 0;
+}
+
 } // namespace __llvm_libc

libc/src/__support/threads/thread.h

 //===--- A platform independent indirection for a thread class --*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_THREADS_THREAD_H
 #define LLVM_LIBC_SRC_SUPPORT_THREADS_THREAD_H
 
+#include "src/__support/CPP/StringView.h"
 #include "src/__support/CPP/atomic.h"
+#include "src/__support/CPP/stringstream.h"
 #include "src/__support/architectures.h"
 
 #include <stddef.h> // For size_t
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 using ThreadRunnerPosix = void *(void *);
struct Thread {
   // finishes.
   //
   // NOTE: This function is to be used for testing only. There is no standard
   // which requires exposing it via a public API.
   void wait();
 
   // Return true if this thread is equal to the other thread.
   bool operator==(const Thread &other) const;
+
+  // Set the name of the thread. Return the error number on error.
+  int set_name(const cpp::StringView &name);
+
+  // Return the name of the thread in |name|. Return the error number of error.
+  int get_name(cpp::StringStream &name) const;
 };
 
 extern thread_local Thread self;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_THREADS_THREAD_H

libc/src/pthread/CMakeLists.txt

add_entrypoint_object(
   SRCS
     pthread_self.cpp
   HDRS
     pthread_self.h
   DEPENDS
     libc.include.pthread
     libc.src.__support.threads.thread
 )
+
+add_entrypoint_object(
+  pthread_setname_np
+  SRCS
+    pthread_setname_np.cpp
+  HDRS
+    pthread_setname_np.h
+  DEPENDS
+    libc.include.pthread
+    libc.src.__support.CPP.array_ref
+    libc.src.__support.CPP.string_view
+    libc.src.__support.threads.thread
+)
+
+add_entrypoint_object(
+  pthread_getname_np
+  SRCS
+    pthread_getname_np.cpp
+  HDRS
+    pthread_getname_np.h
+  DEPENDS
+    libc.include.pthread
+    libc.src.__support.CPP.array_ref
+    libc.src.__support.CPP.stringstream
+    libc.src.__support.threads.thread
+)

libc/src/pthread/pthread_getname_np.h

+//===-- Implementation header for pthread_getname_np function ---*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETNAME_NP_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETNAME_NP_H
+
+#include <pthread.h>
+#include <stddef.h>
+
+namespace __llvm_libc {
+
+int pthread_getname_np(pthread_t, char *, size_t);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETNAME_NP_H

libc/src/pthread/pthread_getname_np.cpp

+//===-- Linux implementation of the pthread_setname_np 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_getname_np.h"
+
+#include "src/__support/CPP/ArrayRef.h"
+#include "src/__support/CPP/StringView.h"
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <pthread.h>
+#include <stddef.h>
+
+namespace __llvm_libc {
+
+static_assert(sizeof(pthread_t) == sizeof(__llvm_libc::Thread),
+              "Mismatch between pthread_t and internal Thread.");
+
+LLVM_LIBC_FUNCTION(int, pthread_getname_np,
+                   (pthread_t th, char *buf, size_t len)) {
+  auto *thread = reinterpret_cast<__llvm_libc::Thread *>(&th);
+  cpp::MutableArrayRef<char> name_buf(buf, len);
+  cpp::StringStream name_stream(name_buf);
+  return thread->get_name(name_stream);
+}
+
+} // namespace __llvm_libc

libc/src/pthread/pthread_setname_np.h

+//===-- Implementation header for pthread_setname_np function ---*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETNAME_NP_H
+#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETNAME_NP_H
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+int pthread_setname_np(pthread_t, const char *name);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETNAME_NP_H

libc/src/pthread/pthread_setname_np.cpp

+//===-- Linux implementation of the pthread_setname_np 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_setname_np.h"
+
+#include "src/__support/CPP/StringView.h"
+#include "src/__support/CPP/error.h"
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <pthread.h>
+
+namespace __llvm_libc {
+
+static_assert(sizeof(pthread_t) == sizeof(__llvm_libc::Thread),
+              "Mismatch between pthread_t and internal Thread.");
+
+LLVM_LIBC_FUNCTION(int, pthread_setname_np, (pthread_t th, const char *name)) {
+  auto *thread = reinterpret_cast<__llvm_libc::Thread *>(&th);
+  return thread->set_name(cpp::StringView(name));
+}
+
+} // namespace __llvm_libc

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

DEPENDS
     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_equal
     libc.src.pthread.pthread_join
     libc.src.pthread.pthread_self
 )
+
+add_integration_test(
+  pthread_name_test
+  SUITE
+    libc-pthread-integration-tests
+  SRCS
+    pthread_name_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc.include.errno
+    libc.include.pthread
+    libc.src.errno.errno
+    libc.src.pthread.pthread_create
+    libc.src.pthread.pthread_getname_np
+    libc.src.pthread.pthread_join
+    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_self
+    libc.src.pthread.pthread_setname_np
+)

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

+//===-- Tests for pthread_equal -------------------------------------------===//
+//
+// 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/__support/CPP/StringView.h"
+#include "src/pthread/pthread_create.h"
+#include "src/pthread/pthread_getname_np.h"
+#include "src/pthread/pthread_join.h"
+#include "src/pthread/pthread_mutex_destroy.h"
+#include "src/pthread/pthread_mutex_init.h"
+#include "src/pthread/pthread_mutex_lock.h"
+#include "src/pthread/pthread_mutex_unlock.h"
+#include "src/pthread/pthread_self.h"
+#include "src/pthread/pthread_setname_np.h"
+
+#include "utils/IntegrationTest/test.h"
+
+#include <errno.h>
+#include <pthread.h>
+
+using StringView = __llvm_libc::cpp::StringView;
+
+char child_thread_name_buffer[16];
+pthread_mutex_t mutex;
+
+static void *child_func(void *) {
+  __llvm_libc::pthread_mutex_lock(&mutex);
+  auto self = __llvm_libc::pthread_self();
+  __llvm_libc::pthread_getname_np(self, child_thread_name_buffer, 16);
+  __llvm_libc::pthread_mutex_unlock(&mutex);
+  return nullptr;
+}
+
+TEST_MAIN() {
+  // We init and lock the mutex so that we guarantee that the child thread is
+  // waiting after startup.
+  ASSERT_EQ(__llvm_libc::pthread_mutex_init(&mutex, nullptr), 0);
+  ASSERT_EQ(__llvm_libc::pthread_mutex_lock(&mutex), 0);
+
+  auto main_thread = __llvm_libc::pthread_self();
+  const char MAIN_THREAD_NAME[] = "main_thread";
+  char thread_name_buffer[16];
+  ASSERT_EQ(__llvm_libc::pthread_setname_np(main_thread, MAIN_THREAD_NAME), 0);
+  ASSERT_EQ(
+      __llvm_libc::pthread_getname_np(main_thread, thread_name_buffer, 16), 0);
+  ASSERT_TRUE(StringView(MAIN_THREAD_NAME)
+                  .equals(StringView(
+                      reinterpret_cast<const char *>(thread_name_buffer))));
+
+  pthread_t th;
+  ASSERT_EQ(__llvm_libc::pthread_create(&th, nullptr, child_func, nullptr), 0);
+  // This new thread should of course not be equal to the main thread.
+  const char CHILD_THREAD_NAME[] = "child_thread";
+  ASSERT_EQ(__llvm_libc::pthread_setname_np(th, CHILD_THREAD_NAME), 0);
+  ASSERT_EQ(__llvm_libc::pthread_getname_np(th, thread_name_buffer, 16), 0);
+  ASSERT_TRUE(StringView(CHILD_THREAD_NAME)
+                  .equals(StringView(
+                      reinterpret_cast<const char *>(thread_name_buffer))));
+
+  ASSERT_EQ(__llvm_libc::pthread_mutex_unlock(&mutex), 0);
+
+  void *retval;
+  ASSERT_EQ(__llvm_libc::pthread_join(th, &retval), 0);
+  ASSERT_EQ(uintptr_t(retval), uintptr_t(nullptr));
+  // Make sure that the child thread saw it name correctly.
+  ASSERT_TRUE(StringView(CHILD_THREAD_NAME)
+                  .equals(StringView(reinterpret_cast<const char *>(
+                      child_thread_name_buffer))));
+
+  __llvm_libc::pthread_mutex_destroy(&mutex);
+
+  ASSERT_EQ(__llvm_libc::pthread_setname_np(main_thread,
+                                            "a really long name for a thread"),
+            ERANGE);
+  char smallbuf[1];
+  ASSERT_EQ(__llvm_libc::pthread_getname_np(main_thread, smallbuf, 1), ERANGE);
+
+  return 0;
+}