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 #include "PosixSource.h"
  10
  11 #include "Rts.h"
  12 #include "RtsAPI.h"
  13 #include "RtsFlags.h"
  14 #include "RtsUtils.h"
  15 #include "Ticky.h"
  16
  17 #ifdef HAVE_TIME_H
  18 #include <time.h>
  19 #endif
  20
  21 /* HACK: On Mac OS X 10.4 (at least), time.h doesn't declare ctime_r with
  22  *       _POSIX_C_SOURCE. If this is the case, we declare it ourselves.
  23  */
  24 #if HAVE_CTIME_R && !HAVE_DECL_CTIME_R
  25 extern char *ctime_r(const time_t *, char *);
  26 #endif
  27
  28 #ifdef HAVE_FCNTL_H
  29 #include <fcntl.h>
  30 #endif
  31
  32 #ifdef HAVE_GETTIMEOFDAY
  33 #include <sys/time.h>
  34 #endif
  35
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <stdarg.h>
  39 #include <stdio.h>
  40
  41 #ifdef HAVE_SIGNAL_H
  42 #include <signal.h>
  43 #endif
  44
  45 #if defined(THREADED_RTS) && defined(openbsd_HOST_OS) && defined(HAVE_PTHREAD_H)
  46 #include <pthread.h>
  47 #endif
  48
  49
  50 #if defined(_WIN32)
  51 #include <windows.h>
  52 #endif
  53
  54 /* -----------------------------------------------------------------------------
  55    Debugging allocator
  56    -------------------------------------------------------------------------- */
  57
  58 #if defined(DEBUG)
  59
  60 typedef struct Allocated_ {
  61     void *addr;
  62     size_t len;
  63     struct Allocated_ *next;
  64 } Allocated;
  65
  66 static Allocated *allocs = NULL;
  67
  68 #ifdef THREADED_RTS
  69 static Mutex allocator_mutex;
  70 #endif
  71
  72 void
  73 initAllocator(void)
  74 {
  75     Allocated *a;
  76     size_t alloc_size;
  77
  78 #ifdef THREADED_RTS
  79     initMutex(&allocator_mutex);
  80 #endif
  81     alloc_size = sizeof(Allocated);
  82     if ((a = (Allocated *) malloc(alloc_size)) == NULL) {
  83       /* don't fflush(stdout); WORKAROUND bug in Linux glibc */
  84       MallocFailHook((W_) alloc_size, "initialising debugging allocator");
  85       stg_exit(EXIT_INTERNAL_ERROR);
  86     }
  87     a->addr = NULL;
  88     a->len = 0;
  89     a->next = NULL;
  90     allocs = a;
  91 }
  92
  93 void
  94 shutdownAllocator(void)
  95 {
  96     Allocated *prev, *a;
  97
  98     if (allocs == NULL) {
  99         barf("Allocator shutdown requested, but not initialised!");
 100     }
 101
 102 #ifdef THREADED_RTS
 103     closeMutex(&allocator_mutex);
 104 #endif
 105
 106     prev = allocs;
 107     while (1) {
 108         a = prev->next;
 109         free(prev);
 110         if (a == NULL) return;
 111         IF_DEBUG(sanity,
 112                  debugBelch("Warning: %p still allocated at shutdown\n",
 113                             a->addr);)
 114         prev = a;
 115     }
 116 }
 117
 118 static void addAllocation(void *addr, size_t len) {
 119     Allocated *a;
 120     size_t alloc_size;
 121
 122     if (allocs != NULL) {
 123         alloc_size = sizeof(Allocated);
 124         if ((a = (Allocated *) malloc(alloc_size)) == NULL) {
 125           /* don't fflush(stdout); WORKAROUND bug in Linux glibc */
 126           MallocFailHook((W_) alloc_size,
 127                          "creating info for debugging allocator");
 128           stg_exit(EXIT_INTERNAL_ERROR);
 129         }
 130         a->addr = addr;
 131         a->len = len;
 132         ACQUIRE_LOCK(&allocator_mutex);
 133         a->next = allocs->next;
 134         allocs->next = a;
 135         RELEASE_LOCK(&allocator_mutex);
 136     }
 137     else {
 138         /* This doesn't actually help as we haven't looked at the flags
 139          * at the time that it matters (while running constructors) */
 140         IF_DEBUG(sanity,
 141                  debugBelch("Ignoring allocation %p %zd as allocs is NULL\n",
 142                             addr, len);)
 143     }
 144 }
 145
 146 static void removeAllocation(void *addr, int overwrite_with_aa) {
 147     Allocated *prev, *a;
 148
 149     if (addr == NULL) {
 150         barf("Freeing NULL!");
 151     }
 152
 153     if (allocs != NULL) {
 154         ACQUIRE_LOCK(&allocator_mutex);
 155         prev = allocs;
 156         a = prev->next;
 157         while (a != NULL) {
 158             if (a->addr == addr) {
 159                 prev->next = a->next;
 160                 if (overwrite_with_aa) {
 161                     memset(addr, 0xaa, a->len);
 162                 }
 163                 free(a);
 164                 RELEASE_LOCK(&allocator_mutex);
 165                 return;
 166             }
 167             prev = a;
 168             a = a->next;
 169         }
 170         /* We would like to barf here, but we can't as conc021
 171          * allocates some stuff in a constructor which then gets freed
 172          * during hs_exit */
 173         /* barf("Freeing non-allocated memory at %p", addr); */
 174         IF_DEBUG(sanity,
 175                  debugBelch("Warning: Freeing non-allocated memory at %p\n",
 176                             addr);)
 177         RELEASE_LOCK(&allocator_mutex);
 178     }
 179     else {
 180         IF_DEBUG(sanity,
 181                  debugBelch("Ignoring free of %p as allocs is NULL\n",
 182                             addr);)
 183     }
 184 }
 185 #endif
 186
 187 /* -----------------------------------------------------------------------------
 188    Result-checking malloc wrappers.
 189    -------------------------------------------------------------------------- */
 190
 191 void *
 192 stgMallocBytes (int n, char *msg)
 193 {
 194     char *space;
 195     size_t n2;
 196
 197     n2 = (size_t) n;
 198     if ((space = (char *) malloc(n2)) == NULL) {
 199       /* don't fflush(stdout); WORKAROUND bug in Linux glibc */
 200       MallocFailHook((W_) n, msg); /*msg*/
 201       stg_exit(EXIT_INTERNAL_ERROR);
 202     }
 203 #if defined(DEBUG)
 204     addAllocation(space, n2);
 205 #endif
 206     return space;
 207 }
 208
 209 void *
 210 stgReallocBytes (void *p, int n, char *msg)
 211 {
 212     char *space;
 213     size_t n2;
 214
 215     n2 = (size_t) n;
 216     if ((space = (char *) realloc(p, (size_t) n2)) == NULL) {
 217       /* don't fflush(stdout); WORKAROUND bug in Linux glibc */
 218       MallocFailHook((W_) n, msg); /*msg*/
 219       stg_exit(EXIT_INTERNAL_ERROR);
 220     }
 221 #if defined(DEBUG)
 222     removeAllocation(p, 0);
 223     addAllocation(space, n2);
 224 #endif
 225     return space;
 226 }
 227
 228 void *
 229 stgCallocBytes (int n, int m, char *msg)
 230 {
 231     char *space;
 232
 233     if ((space = (char *) calloc((size_t) n, (size_t) m)) == NULL) {
 234       /* don't fflush(stdout); WORKAROUND bug in Linux glibc */
 235       MallocFailHook((W_) n*m, msg); /*msg*/
 236       stg_exit(EXIT_INTERNAL_ERROR);
 237     }
 238 #if defined(DEBUG)
 239     addAllocation(space, (size_t) n * (size_t) m);
 240 #endif
 241     return space;
 242 }
 243
 244 /* To simplify changing the underlying allocator used
 245  * by stgMallocBytes(), provide stgFree() as well.
 246  */
 247 void
 248 stgFree(void* p)
 249 {
 250 #if defined(DEBUG)
 251   removeAllocation(p, 1);
 252 #endif
 253   free(p);
 254 }
 255
 256 /* -----------------------------------------------------------------------------
 257    Stack overflow
 258
 259    Not sure if this belongs here.
 260    -------------------------------------------------------------------------- */
 261
 262 void
 263 stackOverflow(void)
 264 {
 265   StackOverflowHook(RtsFlags.GcFlags.maxStkSize * sizeof(W_));
 266
 267 #if defined(TICKY_TICKY)
 268   if (RtsFlags.TickyFlags.showTickyStats) PrintTickyInfo();
 269 #endif
 270 }
 271
 272 void
 273 heapOverflow(void)
 274 {
 275   /* don't fflush(stdout); WORKAROUND bug in Linux glibc */
 276   OutOfHeapHook(0/*unknown request size*/,
 277                 RtsFlags.GcFlags.maxHeapSize * BLOCK_SIZE);
 278
 279 #if defined(TICKY_TICKY)
 280   if (RtsFlags.TickyFlags.showTickyStats) PrintTickyInfo();
 281 #endif
 282
 283   stg_exit(EXIT_HEAPOVERFLOW);
 284 }
 285
 286 /* -----------------------------------------------------------------------------
 287    Out-of-line strlen.
 288
 289    Used in addr2Integer because the C compiler on x86 chokes on
 290    strlen, trying to inline it with not enough registers available.
 291    -------------------------------------------------------------------------- */
 292
 293 nat stg_strlen(char *s)
 294 {
 295    char *p = s;
 296
 297    while (*p) p++;
 298    return p-s;
 299 }
 300
 301
 302 /* -----------------------------------------------------------------------------
 303    genSym stuff, used by GHC itself for its splitting unique supply.
 304
 305    ToDo: put this somewhere sensible.
 306    -------------------------------------------------------------------------  */
 307
 308 static HsInt __GenSymCounter = 0;
 309
 310 HsInt
 311 genSymZh(void)
 312 {
 313     return(__GenSymCounter++);
 314 }
 315 HsInt
 316 resetGenSymZh(void) /* it's your funeral */
 317 {
 318     __GenSymCounter=0;
 319     return(__GenSymCounter);
 320 }
 321
 322 /* -----------------------------------------------------------------------------
 323    Get the current time as a string.  Used in profiling reports.
 324    -------------------------------------------------------------------------- */
 325
 326 char *
 327 time_str(void)
 328 {
 329     static time_t now = 0;
 330     static char nowstr[26];
 331
 332     if (now == 0) {
 333         time(&now);
 334 #if HAVE_CTIME_R
 335         ctime_r(&now, nowstr);
 336 #else
 337         strcpy(nowstr, ctime(&now));
 338 #endif
 339         memmove(nowstr+16,nowstr+19,7);
 340         nowstr[21] = '\0';  // removes the \n
 341     }
 342     return nowstr;
 343 }
 344
 345 /* -----------------------------------------------------------------------------
 346  * Reset a file handle to blocking mode.  We do this for the standard
 347  * file descriptors before exiting, because the shell doesn't always
 348  * clean up for us.
 349  * -------------------------------------------------------------------------- */
 350
 351 #if !defined(mingw32_HOST_OS)
 352 void
 353 resetNonBlockingFd(int fd)
 354 {
 355   long fd_flags;
 356
 357   /* clear the non-blocking flag on this file descriptor */
 358   fd_flags = fcntl(fd, F_GETFL);
 359   if (fd_flags & O_NONBLOCK) {
 360     fcntl(fd, F_SETFL, fd_flags & ~O_NONBLOCK);
 361   }
 362 }
 363
 364 void
 365 setNonBlockingFd(int fd)
 366 {
 367   long fd_flags;
 368
 369   /* clear the non-blocking flag on this file descriptor */
 370   fd_flags = fcntl(fd, F_GETFL);
 371   if (!(fd_flags & O_NONBLOCK)) {
 372     fcntl(fd, F_SETFL, fd_flags | O_NONBLOCK);
 373   }
 374 }
 375 #else
 376 /* Stub defns -- async / non-blocking IO is not done
 377  * via O_NONBLOCK and select() under Win32.
 378  */
 379 void resetNonBlockingFd(int fd STG_UNUSED) {}
 380 void setNonBlockingFd(int fd STG_UNUSED) {}
 381 #endif
 382
 383 #ifdef PAR
 384 static ullong startTime = 0;
 385
 386 /* used in a parallel setup */
 387 ullong
 388 msTime(void)
 389 {
 390 # if defined(HAVE_GETCLOCK) && !defined(alpha_HOST_ARCH) && !defined(hppa1_1_HOST_ARCH)
 391     struct timespec tv;
 392
 393     if (getclock(TIMEOFDAY, &tv) != 0) {
 394         fflush(stdout);
 395         fprintf(stderr, "Clock failed\n");
 396         stg_exit(EXIT_FAILURE);
 397     }
 398     return tv.tv_sec * LL(1000) + tv.tv_nsec / LL(1000000) - startTime;
 399 # elif HAVE_GETTIMEOFDAY && !defined(alpha_HOST_ARCH)
 400     struct timeval tv;
 401
 402     if (gettimeofday(&tv, NULL) != 0) {
 403         fflush(stdout);
 404         fprintf(stderr, "Clock failed\n");
 405         stg_exit(EXIT_FAILURE);
 406     }
 407     return tv.tv_sec * LL(1000) + tv.tv_usec / LL(1000) - startTime;
 408 # else
 409     time_t t;
 410     if ((t = time(NULL)) == (time_t) -1) {
 411         fflush(stdout);
 412         fprintf(stderr, "Clock failed\n");
 413         stg_exit(EXIT_FAILURE);
 414     }
 415     return t * LL(1000) - startTime;
 416 # endif
 417 }
 418 #endif /* PAR */
 419
 420 /* -----------------------------------------------------------------------------
 421    Print large numbers, with punctuation.
 422    -------------------------------------------------------------------------- */
 423
 424 char *
 425 ullong_format_string(ullong x, char *s, rtsBool with_commas)
 426 {
 427     if (x < (ullong)1000)
 428         sprintf(s, "%lu", (lnat)x);
 429     else if (x < (ullong)1000000)
 430         sprintf(s, (with_commas) ? "%lu,%3.3lu" : "%lu%3.3lu",
 431                 (lnat)((x)/(ullong)1000),
 432                 (lnat)((x)%(ullong)1000));
 433     else if (x < (ullong)1000000000)
 434         sprintf(s, (with_commas) ? "%lu,%3.3lu,%3.3lu" :  "%lu%3.3lu%3.3lu",
 435                 (lnat)((x)/(ullong)1000000),
 436                 (lnat)((x)/(ullong)1000%(ullong)1000),
 437                 (lnat)((x)%(ullong)1000));
 438     else
 439         sprintf(s, (with_commas) ? "%lu,%3.3lu,%3.3lu,%3.3lu" : "%lu%3.3lu%3.3lu%3.3lu",
 440                 (lnat)((x)/(ullong)1000000000),
 441                 (lnat)((x)/(ullong)1000000%(ullong)1000),
 442                 (lnat)((x)/(ullong)1000%(ullong)1000),
 443                 (lnat)((x)%(ullong)1000));
 444     return s;
 445 }
 446
 447
 448 // Can be used as a breakpoint to set on every heap check failure.
 449 #ifdef DEBUG
 450 void
 451 heapCheckFail( void )
 452 {
 453 }
 454 #endif
 455
 456 /*
 457  * It seems that pthreads and signals interact oddly in OpenBSD & FreeBSD
 458  * pthreads (and possibly others). When linking with -lpthreads, we
 459  * have to use pthread_kill to send blockable signals. So use that
 460  * when we have a threaded rts. So System.Posix.Signals will call
 461  * genericRaise(), rather than raise(3).
 462  */
 463 int genericRaise(int sig) {
 464 #if defined(THREADED_RTS) && (defined(openbsd_HOST_OS) || defined(freebsd_HOST_OS))
 465         return pthread_kill(pthread_self(), sig);
 466 #else
 467         return raise(sig);
 468 #endif
 469 }
 470
 471 static void mkRtsInfoPair(char *key, char *val) {
 472     /* XXX should check for "s, \s etc in key and val */
 473     printf(" ,(\"%s\", \"%s\")\n", key, val);
 474 }
 475
 476 void printRtsInfo(void) {
 477     /* The first entry is just a hack to make it easy to get the
 478      * commas right */
 479     printf(" [(\"GHC RTS\", \"Yes\")\n");
 480     mkRtsInfoPair("GHC version",             ProjectVersion);
 481     mkRtsInfoPair("RTS way",                 RtsWay);
 482     mkRtsInfoPair("Host platform",           HostPlatform);
 483     mkRtsInfoPair("Build platform",          BuildPlatform);
 484     mkRtsInfoPair("Target platform",         TargetPlatform);
 485     mkRtsInfoPair("Compiler unregisterised", GhcUnregisterised);
 486     mkRtsInfoPair("Tables next to code",     GhcEnableTablesNextToCode);
 487     printf(" ]\n");
 488 }
 489