contrib/llvm/lib/Support/Unix/Threading.inc

   1 //===- Unix/Threading.inc - Unix Threading Implementation ----- -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file provides the Unix specific implementation of Threading functions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/ADT/SmallString.h"
  15 #include "llvm/ADT/Twine.h"
  16
  17 #if defined(__APPLE__)
  18 #include <mach/mach_init.h>
  19 #include <mach/mach_port.h>
  20 #endif
  21
  22 #include <pthread.h>
  23
  24 #if defined(__FreeBSD__) || defined(__OpenBSD__)
  25 #include <pthread_np.h> // For pthread_getthreadid_np() / pthread_set_name_np()
  26 #endif
  27
  28 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
  29 #include <errno.h>
  30 #include <sys/sysctl.h>
  31 #include <sys/user.h>
  32 #include <unistd.h>
  33 #endif
  34
  35 #if defined(__NetBSD__)
  36 #include <lwp.h> // For _lwp_self()
  37 #endif
  38
  39 #if defined(__linux__)
  40 #include <sys/syscall.h> // For syscall codes
  41 #include <unistd.h>      // For syscall()
  42 #endif
  43
  44 namespace {
  45   struct ThreadInfo {
  46     void(*UserFn)(void *);
  47     void *UserData;
  48   };
  49 }
  50
  51 static void *ExecuteOnThread_Dispatch(void *Arg) {
  52   ThreadInfo *TI = reinterpret_cast<ThreadInfo*>(Arg);
  53   TI->UserFn(TI->UserData);
  54   return nullptr;
  55 }
  56
  57 void llvm::llvm_execute_on_thread(void(*Fn)(void*), void *UserData,
  58   unsigned RequestedStackSize) {
  59   ThreadInfo Info = { Fn, UserData };
  60   pthread_attr_t Attr;
  61   pthread_t Thread;
  62
  63   // Construct the attributes object.
  64   if (::pthread_attr_init(&Attr) != 0)
  65     return;
  66
  67   // Set the requested stack size, if given.
  68   if (RequestedStackSize != 0) {
  69     if (::pthread_attr_setstacksize(&Attr, RequestedStackSize) != 0)
  70       goto error;
  71   }
  72
  73   // Construct and execute the thread.
  74   if (::pthread_create(&Thread, &Attr, ExecuteOnThread_Dispatch, &Info) != 0)
  75     goto error;
  76
  77   // Wait for the thread and clean up.
  78   ::pthread_join(Thread, nullptr);
  79
  80 error:
  81   ::pthread_attr_destroy(&Attr);
  82 }
  83
  84
  85 uint64_t llvm::get_threadid() {
  86 #if defined(__APPLE__)
  87   // Calling "mach_thread_self()" bumps the reference count on the thread
  88   // port, so we need to deallocate it. mach_task_self() doesn't bump the ref
  89   // count.
  90   thread_port_t Self = mach_thread_self();
  91   mach_port_deallocate(mach_task_self(), Self);
  92   return Self;
  93 #elif defined(__FreeBSD__)
  94   return uint64_t(pthread_getthreadid_np());
  95 #elif defined(__NetBSD__)
  96   return uint64_t(_lwp_self());
  97 #elif defined(__ANDROID__)
  98   return uint64_t(gettid());
  99 #elif defined(__linux__)
 100   return uint64_t(syscall(SYS_gettid));
 101 #else
 102   return uint64_t(pthread_self());
 103 #endif
 104 }
 105
 106
 107 static constexpr uint32_t get_max_thread_name_length_impl() {
 108 #if defined(__NetBSD__)
 109   return PTHREAD_MAX_NAMELEN_NP;
 110 #elif defined(__APPLE__)
 111   return 64;
 112 #elif defined(__linux__)
 113 #if HAVE_PTHREAD_SETNAME_NP
 114   return 16;
 115 #else
 116   return 0;
 117 #endif
 118 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 119   return 16;
 120 #elif defined(__OpenBSD__)
 121   return 32;
 122 #else
 123   return 0;
 124 #endif
 125 }
 126
 127 uint32_t llvm::get_max_thread_name_length() {
 128   return get_max_thread_name_length_impl();
 129 }
 130
 131 void llvm::set_thread_name(const Twine &Name) {
 132   // Make sure the input is null terminated.
 133   SmallString<64> Storage;
 134   StringRef NameStr = Name.toNullTerminatedStringRef(Storage);
 135
 136   // Truncate from the beginning, not the end, if the specified name is too
 137   // long.  For one, this ensures that the resulting string is still null
 138   // terminated, but additionally the end of a long thread name will usually
 139   // be more unique than the beginning, since a common pattern is for similar
 140   // threads to share a common prefix.
 141   // Note that the name length includes the null terminator.
 142   if (get_max_thread_name_length() > 0)
 143     NameStr = NameStr.take_back(get_max_thread_name_length() - 1);
 144   (void)NameStr;
 145 #if defined(__linux__)
 146 #if (defined(__GLIBC__) && defined(_GNU_SOURCE)) || defined(__ANDROID__)
 147 #if HAVE_PTHREAD_SETNAME_NP
 148   ::pthread_setname_np(::pthread_self(), NameStr.data());
 149 #endif
 150 #endif
 151 #elif defined(__FreeBSD__) || defined(__OpenBSD__)
 152   ::pthread_set_name_np(::pthread_self(), NameStr.data());
 153 #elif defined(__NetBSD__)
 154   ::pthread_setname_np(::pthread_self(), "%s",
 155     const_cast<char *>(NameStr.data()));
 156 #elif defined(__APPLE__)
 157   ::pthread_setname_np(NameStr.data());
 158 #endif
 159 }
 160
 161 void llvm::get_thread_name(SmallVectorImpl<char> &Name) {
 162   Name.clear();
 163
 164 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 165   int pid = ::getpid();
 166   uint64_t tid = get_threadid();
 167
 168   struct kinfo_proc *kp = nullptr, *nkp;
 169   size_t len = 0;
 170   int error;
 171   int ctl[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD,
 172     (int)pid };
 173
 174   while (1) {
 175     error = sysctl(ctl, 4, kp, &len, nullptr, 0);
 176     if (kp == nullptr || (error != 0 && errno == ENOMEM)) {
 177       // Add extra space in case threads are added before next call.
 178       len += sizeof(*kp) + len / 10;
 179       nkp = (struct kinfo_proc *)::realloc(kp, len);
 180       if (nkp == nullptr) {
 181         free(kp);
 182         return;
 183       }
 184       kp = nkp;
 185       continue;
 186     }
 187     if (error != 0)
 188       len = 0;
 189     break;
 190   }
 191
 192   for (size_t i = 0; i < len / sizeof(*kp); i++) {
 193     if (kp[i].ki_tid == (lwpid_t)tid) {
 194       Name.append(kp[i].ki_tdname, kp[i].ki_tdname + strlen(kp[i].ki_tdname));
 195       break;
 196     }
 197   }
 198   free(kp);
 199   return;
 200 #elif defined(__NetBSD__)
 201   constexpr uint32_t len = get_max_thread_name_length_impl();
 202   char buf[len];
 203   ::pthread_getname_np(::pthread_self(), buf, len);
 204
 205   Name.append(buf, buf + strlen(buf));
 206 #elif defined(__OpenBSD__)
 207   constexpr uint32_t len = get_max_thread_name_length_impl();
 208   char buf[len];
 209   ::pthread_get_name_np(::pthread_self(), buf, len);
 210
 211   Name.append(buf, buf + strlen(buf));
 212 #elif defined(__linux__)
 213 #if HAVE_PTHREAD_GETNAME_NP
 214   constexpr uint32_t len = get_max_thread_name_length_impl();
 215   char Buffer[len] = {'\0'};  // FIXME: working around MSan false positive.
 216   if (0 == ::pthread_getname_np(::pthread_self(), Buffer, len))
 217     Name.append(Buffer, Buffer + strlen(Buffer));
 218 #endif
 219 #endif
 220 }