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