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
44namespace {
45  struct ThreadInfo {
46    void(*UserFn)(void *);
47    void *UserData;
48  };
49}
50
51static void *ExecuteOnThread_Dispatch(void *Arg) {
52  ThreadInfo *TI = reinterpret_cast<ThreadInfo*>(Arg);
53  TI->UserFn(TI->UserData);
54  return nullptr;
55}
56
57void 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
80error:
81  ::pthread_attr_destroy(&Attr);
82}
83
84
85uint64_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
107static 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
127uint32_t llvm::get_max_thread_name_length() {
128  return get_max_thread_name_length_impl();
129}
130
131void 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
161void 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(__linux__)
207#if HAVE_PTHREAD_GETNAME_NP
208  constexpr uint32_t len = get_max_thread_name_length_impl();
209  char Buffer[len] = {'\0'};  // FIXME: working around MSan false positive.
210  if (0 == ::pthread_getname_np(::pthread_self(), Buffer, len))
211    Name.append(Buffer, Buffer + strlen(Buffer));
212#endif
213#endif
214}
215