compiler-rt/lib/profile/InstrProfilingUtil.c

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