rts/RtsUtils.c

   1 /* -----------------------------------------------------------------------------
   2  *
   3  * (c) The GHC Team, 1998-2004
   4  *
   5  * General utility functions used in the RTS.
   6  *
   7  * ---------------------------------------------------------------------------*/
   8
   9 /* gettimeofday isn't POSIX */
  10 /* #include "PosixSource.h" */
  11
  12 #include "Rts.h"
  13 #include "RtsAPI.h"
  14 #include "RtsFlags.h"
  15 #include "RtsUtils.h"
  16 #include "Ticky.h"
  17
  18 #ifdef HAVE_TIME_H
  19 #include <time.h>
  20 #endif
  21
  22 #ifdef HAVE_FCNTL_H
  23 #include <fcntl.h>
  24 #endif
  25
  26 #ifdef HAVE_GETTIMEOFDAY
  27 #include <sys/time.h>
  28 #endif
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <stdarg.h>
  33 #include <stdio.h>
  34
  35 #ifdef HAVE_SIGNAL_H
  36 #include <signal.h>
  37 #endif
  38
  39 #if defined(THREADED_RTS) && defined(openbsd_HOST_OS) && defined(HAVE_PTHREAD_H)
  40 #include <pthread.h>
  41 #endif
  42
  43 #if defined(openbsd_HOST_OS) || defined(linux_HOST_OS) || defined(darwin_HOST_OS)
  44 #include <unistd.h>
  45 #include <sys/types.h>
  46 #include <sys/mman.h>
  47
  48 /* no C99 header stdint.h on OpenBSD? */
  49 #if defined(openbsd_HOST_OS)
  50 typedef unsigned long my_uintptr_t;
  51 #else
  52 #include <stdint.h>
  53 typedef uintptr_t my_uintptr_t;
  54 #endif
  55 #endif
  56
  57 #if defined(_WIN32)
  58 #include <windows.h>
  59 #endif
  60
  61 /* -----------------------------------------------------------------------------
  62    Result-checking malloc wrappers.
  63    -------------------------------------------------------------------------- */
  64
  65 void *
  66 stgMallocBytes (int n, char *msg)
  67 {
  68     char *space;
  69
  70     if ((space = (char *) malloc((size_t) n)) == NULL) {
  71       /* don't fflush(stdout); WORKAROUND bug in Linux glibc */
  72       MallocFailHook((W_) n, msg); /*msg*/
  73       stg_exit(EXIT_INTERNAL_ERROR);
  74     }
  75     return space;
  76 }
  77
  78 void *
  79 stgReallocBytes (void *p, int n, char *msg)
  80 {
  81     char *space;
  82
  83     if ((space = (char *) realloc(p, (size_t) n)) == NULL) {
  84       /* don't fflush(stdout); WORKAROUND bug in Linux glibc */
  85       MallocFailHook((W_) n, msg); /*msg*/
  86       stg_exit(EXIT_INTERNAL_ERROR);
  87     }
  88     return space;
  89 }
  90
  91 void *
  92 stgCallocBytes (int n, int m, char *msg)
  93 {
  94     char *space;
  95
  96     if ((space = (char *) calloc((size_t) n, (size_t) m)) == NULL) {
  97       /* don't fflush(stdout); WORKAROUND bug in Linux glibc */
  98       MallocFailHook((W_) n*m, msg); /*msg*/
  99       stg_exit(EXIT_INTERNAL_ERROR);
 100     }
 101     return space;
 102 }
 103
 104 /* To simplify changing the underlying allocator used
 105  * by stgMallocBytes(), provide stgFree() as well.
 106  */
 107 void
 108 stgFree(void* p)
 109 {
 110   free(p);
 111 }
 112
 113 /* -----------------------------------------------------------------------------
 114    Stack overflow
 115
 116    Not sure if this belongs here.
 117    -------------------------------------------------------------------------- */
 118
 119 void
 120 stackOverflow(void)
 121 {
 122   StackOverflowHook(RtsFlags.GcFlags.maxStkSize * sizeof(W_));
 123
 124 #if defined(TICKY_TICKY)
 125   if (RtsFlags.TickyFlags.showTickyStats) PrintTickyInfo();
 126 #endif
 127 }
 128
 129 void
 130 heapOverflow(void)
 131 {
 132   /* don't fflush(stdout); WORKAROUND bug in Linux glibc */
 133   OutOfHeapHook(0/*unknown request size*/,
 134                 RtsFlags.GcFlags.maxHeapSize * BLOCK_SIZE);
 135
 136 #if defined(TICKY_TICKY)
 137   if (RtsFlags.TickyFlags.showTickyStats) PrintTickyInfo();
 138 #endif
 139
 140   stg_exit(EXIT_HEAPOVERFLOW);
 141 }
 142
 143 /* -----------------------------------------------------------------------------
 144    Out-of-line strlen.
 145
 146    Used in addr2Integer because the C compiler on x86 chokes on
 147    strlen, trying to inline it with not enough registers available.
 148    -------------------------------------------------------------------------- */
 149
 150 nat stg_strlen(char *s)
 151 {
 152    char *p = s;
 153
 154    while (*p) p++;
 155    return p-s;
 156 }
 157
 158
 159 /* -----------------------------------------------------------------------------
 160    genSym stuff, used by GHC itself for its splitting unique supply.
 161
 162    ToDo: put this somewhere sensible.
 163    -------------------------------------------------------------------------  */
 164
 165 static I_ __GenSymCounter = 0;
 166
 167 I_
 168 genSymZh(void)
 169 {
 170     return(__GenSymCounter++);
 171 }
 172 I_
 173 resetGenSymZh(void) /* it's your funeral */
 174 {
 175     __GenSymCounter=0;
 176     return(__GenSymCounter);
 177 }
 178
 179 /* -----------------------------------------------------------------------------
 180    Get the current time as a string.  Used in profiling reports.
 181    -------------------------------------------------------------------------- */
 182
 183 #if defined(PROFILING) || defined(DEBUG) || defined(PAR) || defined(GRAN)
 184 char *
 185 time_str(void)
 186 {
 187     static time_t now = 0;
 188     static char nowstr[26];
 189
 190     if (now == 0) {
 191         time(&now);
 192 #if HAVE_CTIME_R
 193         ctime_r(&now, nowstr);
 194 #else
 195         strcpy(nowstr, ctime(&now));
 196 #endif
 197         memmove(nowstr+16,nowstr+19,7);
 198         nowstr[21] = '\0';  // removes the \n
 199     }
 200     return nowstr;
 201 }
 202 #endif
 203
 204 /* -----------------------------------------------------------------------------
 205  * Reset a file handle to blocking mode.  We do this for the standard
 206  * file descriptors before exiting, because the shell doesn't always
 207  * clean up for us.
 208  * -------------------------------------------------------------------------- */
 209
 210 #if !defined(mingw32_HOST_OS)
 211 void
 212 resetNonBlockingFd(int fd)
 213 {
 214   long fd_flags;
 215
 216   /* clear the non-blocking flag on this file descriptor */
 217   fd_flags = fcntl(fd, F_GETFL);
 218   if (fd_flags & O_NONBLOCK) {
 219     fcntl(fd, F_SETFL, fd_flags & ~O_NONBLOCK);
 220   }
 221 }
 222
 223 void
 224 setNonBlockingFd(int fd)
 225 {
 226   long fd_flags;
 227
 228   /* clear the non-blocking flag on this file descriptor */
 229   fd_flags = fcntl(fd, F_GETFL);
 230   if (!(fd_flags & O_NONBLOCK)) {
 231     fcntl(fd, F_SETFL, fd_flags | O_NONBLOCK);
 232   }
 233 }
 234 #else
 235 /* Stub defns -- async / non-blocking IO is not done
 236  * via O_NONBLOCK and select() under Win32.
 237  */
 238 void resetNonBlockingFd(int fd STG_UNUSED) {}
 239 void setNonBlockingFd(int fd STG_UNUSED) {}
 240 #endif
 241
 242 #ifdef PAR
 243 static ullong startTime = 0;
 244
 245 /* used in a parallel setup */
 246 ullong
 247 msTime(void)
 248 {
 249 # if defined(HAVE_GETCLOCK) && !defined(alpha_HOST_ARCH) && !defined(hppa1_1_HOST_ARCH)
 250     struct timespec tv;
 251
 252     if (getclock(TIMEOFDAY, &tv) != 0) {
 253         fflush(stdout);
 254         fprintf(stderr, "Clock failed\n");
 255         stg_exit(EXIT_FAILURE);
 256     }
 257     return tv.tv_sec * LL(1000) + tv.tv_nsec / LL(1000000) - startTime;
 258 # elif HAVE_GETTIMEOFDAY && !defined(alpha_HOST_ARCH)
 259     struct timeval tv;
 260
 261     if (gettimeofday(&tv, NULL) != 0) {
 262         fflush(stdout);
 263         fprintf(stderr, "Clock failed\n");
 264         stg_exit(EXIT_FAILURE);
 265     }
 266     return tv.tv_sec * LL(1000) + tv.tv_usec / LL(1000) - startTime;
 267 # else
 268     time_t t;
 269     if ((t = time(NULL)) == (time_t) -1) {
 270         fflush(stdout);
 271         fprintf(stderr, "Clock failed\n");
 272         stg_exit(EXIT_FAILURE);
 273     }
 274     return t * LL(1000) - startTime;
 275 # endif
 276 }
 277 #endif /* PAR */
 278
 279 /* -----------------------------------------------------------------------------
 280    Print large numbers, with punctuation.
 281    -------------------------------------------------------------------------- */
 282
 283 char *
 284 ullong_format_string(ullong x, char *s, rtsBool with_commas)
 285 {
 286     if (x < (ullong)1000)
 287         sprintf(s, "%lu", (lnat)x);
 288     else if (x < (ullong)1000000)
 289         sprintf(s, (with_commas) ? "%lu,%3.3lu" : "%lu%3.3lu",
 290                 (lnat)((x)/(ullong)1000),
 291                 (lnat)((x)%(ullong)1000));
 292     else if (x < (ullong)1000000000)
 293         sprintf(s, (with_commas) ? "%lu,%3.3lu,%3.3lu" :  "%lu%3.3lu%3.3lu",
 294                 (lnat)((x)/(ullong)1000000),
 295                 (lnat)((x)/(ullong)1000%(ullong)1000),
 296                 (lnat)((x)%(ullong)1000));
 297     else
 298         sprintf(s, (with_commas) ? "%lu,%3.3lu,%3.3lu,%3.3lu" : "%lu%3.3lu%3.3lu%3.3lu",
 299                 (lnat)((x)/(ullong)1000000000),
 300                 (lnat)((x)/(ullong)1000000%(ullong)1000),
 301                 (lnat)((x)/(ullong)1000%(ullong)1000),
 302                 (lnat)((x)%(ullong)1000));
 303     return s;
 304 }
 305
 306
 307 // Can be used as a breakpoint to set on every heap check failure.
 308 #ifdef DEBUG
 309 void
 310 heapCheckFail( void )
 311 {
 312 }
 313 #endif
 314
 315 /*
 316  * It seems that pthreads and signals interact oddly in OpenBSD & FreeBSD
 317  * pthreads (and possibly others). When linking with -lpthreads, we
 318  * have to use pthread_kill to send blockable signals. So use that
 319  * when we have a threaded rts. So System.Posix.Signals will call
 320  * genericRaise(), rather than raise(3).
 321  */
 322 int genericRaise(int sig) {
 323 #if defined(THREADED_RTS) && (defined(openbsd_HOST_OS) || defined(freebsd_HOST_OS))
 324         return pthread_kill(pthread_self(), sig);
 325 #else
 326         return raise(sig);
 327 #endif
 328 }
 329
 330 /* -----------------------------------------------------------------------------
 331    Allocating executable memory
 332    -------------------------------------------------------------------------- */
 333
 334 /* Heavily arch-specific, I'm afraid.. */
 335
 336 /*
 337  * Allocate len bytes which are readable, writable, and executable.
 338  *
 339  * ToDo: If this turns out to be a performance bottleneck, one could
 340  * e.g. cache the last VirtualProtect/mprotect-ed region and do
 341  * nothing in case of a cache hit.
 342  */
 343 void*
 344 stgMallocBytesRWX(int len)
 345 {
 346   void *addr = stgMallocBytes(len, "mallocBytesRWX");
 347 #if defined(i386_HOST_ARCH) && defined(_WIN32)
 348   /* This could be necessary for processors which distinguish between READ and
 349      EXECUTE memory accesses, e.g. Itaniums. */
 350   DWORD dwOldProtect = 0;
 351   if (VirtualProtect (addr, len, PAGE_EXECUTE_READWRITE, &dwOldProtect) == 0) {
 352     barf("mallocBytesRWX: failed to protect 0x%p; error=%lu; old protection: %lu\n",
 353          addr, (unsigned long)GetLastError(), (unsigned long)dwOldProtect);
 354   }
 355 #elif defined(openbsd_HOST_OS) || defined(linux_HOST_OS) || defined(darwin_HOST_OS)
 356   /* malloced memory isn't executable by default on OpenBSD */
 357   my_uintptr_t pageSize         = sysconf(_SC_PAGESIZE);
 358   my_uintptr_t mask             = ~(pageSize - 1);
 359   my_uintptr_t startOfFirstPage = ((my_uintptr_t)addr          ) & mask;
 360   my_uintptr_t startOfLastPage  = ((my_uintptr_t)addr + len - 1) & mask;
 361   my_uintptr_t size             = startOfLastPage - startOfFirstPage + pageSize;
 362   if (mprotect((void*)startOfFirstPage, (size_t)size, PROT_EXEC | PROT_READ | PROT_WRITE) != 0) {
 363     barf("mallocBytesRWX: failed to protect 0x%p\n", addr);
 364   }
 365 #endif
 366   return addr;
 367 }