Line data Source code
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 4830 : static void *ExecuteOnThread_Dispatch(void *Arg) {
52 : ThreadInfo *TI = reinterpret_cast<ThreadInfo*>(Arg);
53 4830 : TI->UserFn(TI->UserData);
54 4830 : return nullptr;
55 : }
56 :
57 4830 : void llvm::llvm_execute_on_thread(void(*Fn)(void*), void *UserData,
58 : unsigned RequestedStackSize) {
59 4830 : ThreadInfo Info = { Fn, UserData };
60 : pthread_attr_t Attr;
61 : pthread_t Thread;
62 :
63 : // Construct the attributes object.
64 4830 : if (::pthread_attr_init(&Attr) != 0)
65 0 : return;
66 :
67 : // Set the requested stack size, if given.
68 4830 : if (RequestedStackSize != 0) {
69 3776 : if (::pthread_attr_setstacksize(&Attr, RequestedStackSize) != 0)
70 : goto error;
71 : }
72 :
73 : // Construct and execute the thread.
74 4830 : if (::pthread_create(&Thread, &Attr, ExecuteOnThread_Dispatch, &Info) != 0)
75 : goto error;
76 :
77 : // Wait for the thread and clean up.
78 4830 : ::pthread_join(Thread, nullptr);
79 :
80 4830 : error:
81 4830 : ::pthread_attr_destroy(&Attr);
82 : }
83 :
84 :
85 44 : 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 44 : 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 78 : uint32_t llvm::get_max_thread_name_length() {
128 78 : return get_max_thread_name_length_impl();
129 : }
130 :
131 39 : void llvm::set_thread_name(const Twine &Name) {
132 : // Make sure the input is null terminated.
133 : SmallString<64> Storage;
134 39 : 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 39 : if (get_max_thread_name_length() > 0)
143 78 : 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 39 : ::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 39 : }
160 :
161 1 : 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(__linux__)
207 : #if HAVE_PTHREAD_GETNAME_NP
208 : constexpr uint32_t len = get_max_thread_name_length_impl();
209 1 : char Buffer[len] = {'\0'}; // FIXME: working around MSan false positive.
210 1 : if (0 == ::pthread_getname_np(::pthread_self(), Buffer, len))
211 1 : Name.append(Buffer, Buffer + strlen(Buffer));
212 : #endif
213 : #endif
214 1 : }
|
