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