1 /*===- InstrProfilingUtil.c - Support library for PGO instrumentation -----===*\
2 |*
3 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 |* See https://llvm.org/LICENSE.txt for license information.
5 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 |*
7 \*===----------------------------------------------------------------------===*/
8
9 #ifdef _WIN32
10 #include <direct.h>
11 #include <process.h>
12 #include <windows.h>
13 #include "WindowsMMap.h"
14 #else
15 #include <errno.h>
16 #include <fcntl.h>
17 #include <sys/file.h>
18 #include <sys/mman.h>
19 #include <sys/stat.h>
20 #include <sys/types.h>
21 #include <unistd.h>
22 #endif
23
24 #ifdef COMPILER_RT_HAS_UNAME
25 #include <sys/utsname.h>
26 #endif
27
28 #include <stdlib.h>
29 #include <string.h>
30
31 #if defined(__linux__)
32 #include <signal.h>
33 #include <sys/prctl.h>
34 #endif
35
36 #if defined(__Fuchsia__)
37 #include <zircon/syscalls.h>
38 #endif
39
40 #include "InstrProfiling.h"
41 #include "InstrProfilingUtil.h"
42
43 COMPILER_RT_WEAK unsigned lprofDirMode = 0755;
44
45 COMPILER_RT_VISIBILITY
__llvm_profile_recursive_mkdir(char * path)46 void __llvm_profile_recursive_mkdir(char *path) {
47 int i;
48 int start = 1;
49
50 #if defined(__ANDROID__) && defined(__ANDROID_API__) && \
51 defined(__ANDROID_API_FUTURE__) && \
52 __ANDROID_API__ == __ANDROID_API_FUTURE__
53 // Avoid spammy selinux denial messages in Android by not attempting to
54 // create directories in GCOV_PREFIX. These denials occur when creating (or
55 // even attempting to stat()) top-level directories like "/data".
56 //
57 // Do so by ignoring ${GCOV_PREFIX} when invoking mkdir().
58 const char *gcov_prefix = getenv("GCOV_PREFIX");
59 if (gcov_prefix != NULL) {
60 const int gcov_prefix_len = strlen(gcov_prefix);
61 if (strncmp(path, gcov_prefix, gcov_prefix_len) == 0)
62 start = gcov_prefix_len;
63 }
64 #endif
65
66 for (i = start; path[i] != '\0'; ++i) {
67 char save = path[i];
68 if (!IS_DIR_SEPARATOR(path[i]))
69 continue;
70 path[i] = '\0';
71 #ifdef _WIN32
72 _mkdir(path);
73 #else
74 /* Some of these will fail, ignore it. */
75 mkdir(path, __llvm_profile_get_dir_mode());
76 #endif
77 path[i] = save;
78 }
79 }
80
81 COMPILER_RT_VISIBILITY
__llvm_profile_set_dir_mode(unsigned Mode)82 void __llvm_profile_set_dir_mode(unsigned Mode) { lprofDirMode = Mode; }
83
84 COMPILER_RT_VISIBILITY
__llvm_profile_get_dir_mode(void)85 unsigned __llvm_profile_get_dir_mode(void) { return lprofDirMode; }
86
87 #if COMPILER_RT_HAS_ATOMICS != 1
88 COMPILER_RT_VISIBILITY
lprofBoolCmpXchg(void ** Ptr,void * OldV,void * NewV)89 uint32_t lprofBoolCmpXchg(void **Ptr, void *OldV, void *NewV) {
90 void *R = *Ptr;
91 if (R == OldV) {
92 *Ptr = NewV;
93 return 1;
94 }
95 return 0;
96 }
97 COMPILER_RT_VISIBILITY
lprofPtrFetchAdd(void ** Mem,long ByteIncr)98 void *lprofPtrFetchAdd(void **Mem, long ByteIncr) {
99 void *Old = *Mem;
100 *((char **)Mem) += ByteIncr;
101 return Old;
102 }
103
104 #endif
105
106 #ifdef _WIN32
lprofGetHostName(char * Name,int Len)107 COMPILER_RT_VISIBILITY int lprofGetHostName(char *Name, int Len) {
108 WCHAR Buffer[COMPILER_RT_MAX_HOSTLEN];
109 DWORD BufferSize = sizeof(Buffer);
110 BOOL Result =
111 GetComputerNameExW(ComputerNameDnsFullyQualified, Buffer, &BufferSize);
112 if (!Result)
113 return -1;
114 if (WideCharToMultiByte(CP_UTF8, 0, Buffer, -1, Name, Len, NULL, NULL) == 0)
115 return -1;
116 return 0;
117 }
118 #elif defined(COMPILER_RT_HAS_UNAME)
lprofGetHostName(char * Name,int Len)119 COMPILER_RT_VISIBILITY int lprofGetHostName(char *Name, int Len) {
120 struct utsname N;
121 int R = uname(&N);
122 if (R >= 0) {
123 strncpy(Name, N.nodename, Len);
124 return 0;
125 }
126 return R;
127 }
128 #endif
129
lprofLockFd(int fd)130 COMPILER_RT_VISIBILITY int lprofLockFd(int fd) {
131 #ifdef COMPILER_RT_HAS_FCNTL_LCK
132 struct flock s_flock;
133
134 s_flock.l_whence = SEEK_SET;
135 s_flock.l_start = 0;
136 s_flock.l_len = 0; /* Until EOF. */
137 s_flock.l_pid = getpid();
138 s_flock.l_type = F_WRLCK;
139
140 while (fcntl(fd, F_SETLKW, &s_flock) == -1) {
141 if (errno != EINTR) {
142 if (errno == ENOLCK) {
143 return -1;
144 }
145 break;
146 }
147 }
148 return 0;
149 #else
150 flock(fd, LOCK_EX);
151 return 0;
152 #endif
153 }
154
lprofUnlockFd(int fd)155 COMPILER_RT_VISIBILITY int lprofUnlockFd(int fd) {
156 #ifdef COMPILER_RT_HAS_FCNTL_LCK
157 struct flock s_flock;
158
159 s_flock.l_whence = SEEK_SET;
160 s_flock.l_start = 0;
161 s_flock.l_len = 0; /* Until EOF. */
162 s_flock.l_pid = getpid();
163 s_flock.l_type = F_UNLCK;
164
165 while (fcntl(fd, F_SETLKW, &s_flock) == -1) {
166 if (errno != EINTR) {
167 if (errno == ENOLCK) {
168 return -1;
169 }
170 break;
171 }
172 }
173 return 0;
174 #else
175 flock(fd, LOCK_UN);
176 return 0;
177 #endif
178 }
179
lprofLockFileHandle(FILE * F)180 COMPILER_RT_VISIBILITY int lprofLockFileHandle(FILE *F) {
181 int fd;
182 #if defined(_WIN32)
183 fd = _fileno(F);
184 #else
185 fd = fileno(F);
186 #endif
187 return lprofLockFd(fd);
188 }
189
lprofUnlockFileHandle(FILE * F)190 COMPILER_RT_VISIBILITY int lprofUnlockFileHandle(FILE *F) {
191 int fd;
192 #if defined(_WIN32)
193 fd = _fileno(F);
194 #else
195 fd = fileno(F);
196 #endif
197 return lprofUnlockFd(fd);
198 }
199
lprofOpenFileEx(const char * ProfileName)200 COMPILER_RT_VISIBILITY FILE *lprofOpenFileEx(const char *ProfileName) {
201 FILE *f;
202 int fd;
203 #ifdef COMPILER_RT_HAS_FCNTL_LCK
204 fd = open(ProfileName, O_RDWR | O_CREAT, 0666);
205 if (fd < 0)
206 return NULL;
207
208 if (lprofLockFd(fd) != 0)
209 PROF_WARN("Data may be corrupted during profile merging : %s\n",
210 "Fail to obtain file lock due to system limit.");
211
212 f = fdopen(fd, "r+b");
213 #elif defined(_WIN32)
214 // FIXME: Use the wide variants to handle Unicode filenames.
215 HANDLE h = CreateFileA(ProfileName, GENERIC_READ | GENERIC_WRITE,
216 FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_ALWAYS,
217 FILE_ATTRIBUTE_NORMAL, 0);
218 if (h == INVALID_HANDLE_VALUE)
219 return NULL;
220
221 fd = _open_osfhandle((intptr_t)h, 0);
222 if (fd == -1) {
223 CloseHandle(h);
224 return NULL;
225 }
226
227 if (lprofLockFd(fd) != 0)
228 PROF_WARN("Data may be corrupted during profile merging : %s\n",
229 "Fail to obtain file lock due to system limit.");
230
231 f = _fdopen(fd, "r+b");
232 if (f == 0) {
233 CloseHandle(h);
234 return NULL;
235 }
236 #else
237 /* Worst case no locking applied. */
238 PROF_WARN("Concurrent file access is not supported : %s\n",
239 "lack file locking");
240 fd = open(ProfileName, O_RDWR | O_CREAT, 0666);
241 if (fd < 0)
242 return NULL;
243 f = fdopen(fd, "r+b");
244 #endif
245
246 return f;
247 }
248
lprofGetPathPrefix(int * PrefixStrip,size_t * PrefixLen)249 COMPILER_RT_VISIBILITY const char *lprofGetPathPrefix(int *PrefixStrip,
250 size_t *PrefixLen) {
251 const char *Prefix = getenv("GCOV_PREFIX");
252 const char *PrefixStripStr = getenv("GCOV_PREFIX_STRIP");
253
254 *PrefixLen = 0;
255 *PrefixStrip = 0;
256 if (Prefix == NULL || Prefix[0] == '\0')
257 return NULL;
258
259 if (PrefixStripStr) {
260 *PrefixStrip = atoi(PrefixStripStr);
261
262 /* Negative GCOV_PREFIX_STRIP values are ignored */
263 if (*PrefixStrip < 0)
264 *PrefixStrip = 0;
265 } else {
266 *PrefixStrip = 0;
267 }
268 *PrefixLen = strlen(Prefix);
269
270 return Prefix;
271 }
272
273 COMPILER_RT_VISIBILITY void
lprofApplyPathPrefix(char * Dest,const char * PathStr,const char * Prefix,size_t PrefixLen,int PrefixStrip)274 lprofApplyPathPrefix(char *Dest, const char *PathStr, const char *Prefix,
275 size_t PrefixLen, int PrefixStrip) {
276
277 const char *Ptr;
278 int Level;
279 const char *StrippedPathStr = PathStr;
280
281 for (Level = 0, Ptr = PathStr + 1; Level < PrefixStrip; ++Ptr) {
282 if (*Ptr == '\0')
283 break;
284
285 if (!IS_DIR_SEPARATOR(*Ptr))
286 continue;
287
288 StrippedPathStr = Ptr;
289 ++Level;
290 }
291
292 memcpy(Dest, Prefix, PrefixLen);
293
294 if (!IS_DIR_SEPARATOR(Prefix[PrefixLen - 1]))
295 Dest[PrefixLen++] = DIR_SEPARATOR;
296
297 memcpy(Dest + PrefixLen, StrippedPathStr, strlen(StrippedPathStr) + 1);
298 }
299
300 COMPILER_RT_VISIBILITY const char *
lprofFindFirstDirSeparator(const char * Path)301 lprofFindFirstDirSeparator(const char *Path) {
302 const char *Sep = strchr(Path, DIR_SEPARATOR);
303 #if defined(DIR_SEPARATOR_2)
304 const char *Sep2 = strchr(Path, DIR_SEPARATOR_2);
305 if (Sep2 && (!Sep || Sep2 < Sep))
306 Sep = Sep2;
307 #endif
308 return Sep;
309 }
310
lprofFindLastDirSeparator(const char * Path)311 COMPILER_RT_VISIBILITY const char *lprofFindLastDirSeparator(const char *Path) {
312 const char *Sep = strrchr(Path, DIR_SEPARATOR);
313 #if defined(DIR_SEPARATOR_2)
314 const char *Sep2 = strrchr(Path, DIR_SEPARATOR_2);
315 if (Sep2 && (!Sep || Sep2 > Sep))
316 Sep = Sep2;
317 #endif
318 return Sep;
319 }
320
lprofSuspendSigKill()321 COMPILER_RT_VISIBILITY int lprofSuspendSigKill() {
322 #if defined(__linux__)
323 int PDeachSig = 0;
324 /* Temporarily suspend getting SIGKILL upon exit of the parent process. */
325 if (prctl(PR_GET_PDEATHSIG, &PDeachSig) == 0 && PDeachSig == SIGKILL)
326 prctl(PR_SET_PDEATHSIG, 0);
327 return (PDeachSig == SIGKILL);
328 #else
329 return 0;
330 #endif
331 }
332
lprofRestoreSigKill()333 COMPILER_RT_VISIBILITY void lprofRestoreSigKill() {
334 #if defined(__linux__)
335 prctl(PR_SET_PDEATHSIG, SIGKILL);
336 #endif
337 }
338
lprofReleaseMemoryPagesToOS(uintptr_t Begin,uintptr_t End)339 COMPILER_RT_VISIBILITY int lprofReleaseMemoryPagesToOS(uintptr_t Begin,
340 uintptr_t End) {
341 size_t PageSize = getpagesize();
342 uintptr_t BeginAligned = lprofRoundUpTo((uintptr_t)Begin, PageSize);
343 uintptr_t EndAligned = lprofRoundDownTo((uintptr_t)End, PageSize);
344 if (BeginAligned < EndAligned) {
345 #if defined(__Fuchsia__)
346 return _zx_vmar_op_range(_zx_vmar_root_self(), ZX_VMAR_OP_DECOMMIT,
347 (zx_vaddr_t)BeginAligned,
348 EndAligned - BeginAligned, NULL, 0);
349 #else
350 return madvise((void *)BeginAligned, EndAligned - BeginAligned,
351 MADV_DONTNEED);
352 #endif
353 }
354 return 0;
355 }
356