X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Frts%2FRtsUtils.c;h=ef7cbb72e2d06329161e8e7da4f892aa9b593fc4;hb=7f24ae51ed36c5c0308a2d0de23e243f32a0043c;hp=775735986e4352db182e5d69e5307aa1d3a8104b;hpb=95371b03d1e5310f3b344cc2ecf29982e2bc9f5d;p=ghc-hetmet.git diff --git a/ghc/rts/RtsUtils.c b/ghc/rts/RtsUtils.c index 7757359..ef7cbb7 100644 --- a/ghc/rts/RtsUtils.c +++ b/ghc/rts/RtsUtils.c @@ -1,7 +1,6 @@ /* ----------------------------------------------------------------------------- - * $Id: RtsUtils.c,v 1.27 2002/08/16 13:29:07 simonmar Exp $ * - * (c) The GHC Team, 1998-1999 + * (c) The GHC Team, 1998-2004 * * General utility functions used in the RTS. * @@ -11,11 +10,8 @@ /* #include "PosixSource.h" */ #include "Rts.h" -#include "RtsTypes.h" #include "RtsAPI.h" #include "RtsFlags.h" -#include "Hooks.h" -#include "Main.h" #include "RtsUtils.h" #include "Ticky.h" @@ -34,50 +30,37 @@ #include #include #include +#include -/* variable-argument error function. */ +#ifdef HAVE_SIGNAL_H +#include +#endif -void barf(char *s, ...) -{ - va_list ap; - va_start(ap,s); - /* don't fflush(stdout); WORKAROUND bug in Linux glibc */ - if (prog_argv != NULL && prog_argv[0] != NULL) { - fprintf(stderr, "%s: fatal error: ", prog_argv[0]); - } else { - fprintf(stderr, "fatal error: "); - } - vfprintf(stderr, s, ap); - fprintf(stderr, "\n"); - fflush(stderr); - stg_exit(EXIT_INTERNAL_ERROR); - va_end(ap); -} +#if defined(THREADED_RTS) && defined(openbsd_HOST_OS) && defined(HAVE_PTHREAD_H) +#include +#endif -void prog_belch(char *s, ...) -{ - va_list ap; - va_start(ap,s); - /* don't fflush(stdout); WORKAROUND bug in Linux glibc */ - if (prog_argv != NULL && prog_argv[0] != NULL) { - fprintf(stderr, "%s: ", prog_argv[0]); - } - vfprintf(stderr, s, ap); - fprintf(stderr, "\n"); - va_end(ap); -} +#if defined(openbsd_HOST_OS) || defined(linux_HOST_OS) +#include +#include +#include -void belch(char *s, ...) -{ - va_list ap; - va_start(ap,s); - /* don't fflush(stdout); WORKAROUND bug in Linux glibc */ - vfprintf(stderr, s, ap); - fprintf(stderr, "\n"); - va_end(ap); -} +/* no C99 header stdint.h on OpenBSD? */ +#if defined(openbsd_HOST_OS) +typedef unsigned long my_uintptr_t; +#else +#include +typedef uintptr_t my_uintptr_t; +#endif +#endif -/* result-checking malloc wrappers. */ +#if defined(_WIN32) +#include +#endif + +/* ----------------------------------------------------------------------------- + Result-checking malloc wrappers. + -------------------------------------------------------------------------- */ void * stgMallocBytes (int n, char *msg) @@ -106,34 +89,25 @@ stgReallocBytes (void *p, int n, char *msg) } void * -stgMallocWords (int n, char *msg) -{ - return(stgMallocBytes(n * sizeof(W_), msg)); -} - -void * -stgReallocWords (void *p, int n, char *msg) -{ - return(stgReallocBytes(p, n * sizeof(W_), msg)); -} - -void * stgCallocBytes (int n, int m, char *msg) { - int i; - int sz = n * m; - char* p = stgMallocBytes(sz, msg); - for (i = 0; i < sz; i++) p[i] = 0; - return p; + char *space; + + if ((space = (char *) calloc((size_t) n, (size_t) m)) == NULL) { + /* don't fflush(stdout); WORKAROUND bug in Linux glibc */ + MallocFailHook((W_) n*m, msg); /*msg*/ + stg_exit(EXIT_INTERNAL_ERROR); + } + return space; } -void -_stgAssert (char *filename, unsigned int linenum) +/* To simplify changing the underlying allocator used + * by stgMallocBytes(), provide stgFree() as well. + */ +void +stgFree(void* p) { - fflush(stdout); - fprintf(stderr, "ASSERTION FAILED: file %s, line %u\n", filename, linenum); - fflush(stderr); - abort(); + free(p); } /* ----------------------------------------------------------------------------- @@ -215,9 +189,13 @@ time_str(void) if (now == 0) { time(&now); +#if HAVE_CTIME_R + ctime_r(&now, nowstr); +#else strcpy(nowstr, ctime(&now)); - strcpy(nowstr+16,nowstr+19); - nowstr[21] = '\0'; +#endif + memmove(nowstr+16,nowstr+19,7); + nowstr[21] = '\0'; // removes the \n } return nowstr; } @@ -229,7 +207,7 @@ time_str(void) * clean up for us. * -------------------------------------------------------------------------- */ -#if !defined(mingw32_TARGET_OS) +#if !defined(mingw32_HOST_OS) void resetNonBlockingFd(int fd) { @@ -249,21 +227,26 @@ setNonBlockingFd(int fd) /* clear the non-blocking flag on this file descriptor */ fd_flags = fcntl(fd, F_GETFL); - fcntl(fd, F_SETFL, fd_flags | O_NONBLOCK); + if (!(fd_flags & O_NONBLOCK)) { + fcntl(fd, F_SETFL, fd_flags | O_NONBLOCK); + } } #else -/* Don't support non-blocking FDs (yet) on mingw */ +/* Stub defns -- async / non-blocking IO is not done + * via O_NONBLOCK and select() under Win32. + */ void resetNonBlockingFd(int fd STG_UNUSED) {} void setNonBlockingFd(int fd STG_UNUSED) {} #endif +#ifdef PAR static ullong startTime = 0; /* used in a parallel setup */ ullong msTime(void) { -# if defined(HAVE_GETCLOCK) && !defined(alpha_TARGET_ARCH) && !defined(hppa1_1_TARGET_ARCH) +# if defined(HAVE_GETCLOCK) && !defined(alpha_HOST_ARCH) && !defined(hppa1_1_HOST_ARCH) struct timespec tv; if (getclock(TIMEOFDAY, &tv) != 0) { @@ -272,7 +255,7 @@ msTime(void) stg_exit(EXIT_FAILURE); } return tv.tv_sec * LL(1000) + tv.tv_nsec / LL(1000000) - startTime; -# elif HAVE_GETTIMEOFDAY && !defined(alpha_TARGET_ARCH) +# elif HAVE_GETTIMEOFDAY && !defined(alpha_HOST_ARCH) struct timeval tv; if (gettimeofday(&tv, NULL) != 0) { @@ -291,6 +274,7 @@ msTime(void) return t * LL(1000) - startTime; # endif } +#endif /* PAR */ /* ----------------------------------------------------------------------------- Print large numbers, with punctuation. @@ -300,21 +284,84 @@ char * ullong_format_string(ullong x, char *s, rtsBool with_commas) { if (x < (ullong)1000) - sprintf(s, "%d", (nat)x); + sprintf(s, "%lu", (lnat)x); else if (x < (ullong)1000000) - sprintf(s, (with_commas) ? "%ld,%3.3ld" : "%ld%3.3ld", - (nat)((x)/(ullong)1000), - (nat)((x)%(ullong)1000)); + sprintf(s, (with_commas) ? "%lu,%3.3lu" : "%lu%3.3lu", + (lnat)((x)/(ullong)1000), + (lnat)((x)%(ullong)1000)); else if (x < (ullong)1000000000) - sprintf(s, (with_commas) ? "%ld,%3.3ld,%3.3ld" : "%ld%3.3ld%3.3ld", - (nat)((x)/(ullong)1000000), - (nat)((x)/(ullong)1000%(ullong)1000), - (nat)((x)%(ullong)1000)); + sprintf(s, (with_commas) ? "%lu,%3.3lu,%3.3lu" : "%lu%3.3lu%3.3lu", + (lnat)((x)/(ullong)1000000), + (lnat)((x)/(ullong)1000%(ullong)1000), + (lnat)((x)%(ullong)1000)); else - sprintf(s, (with_commas) ? "%ld,%3.3ld,%3.3ld,%3.3ld" : "%ld%3.3ld%3.3ld%3.3ld", - (nat)((x)/(ullong)1000000000), - (nat)((x)/(ullong)1000000%(ullong)1000), - (nat)((x)/(ullong)1000%(ullong)1000), - (nat)((x)%(ullong)1000)); + sprintf(s, (with_commas) ? "%lu,%3.3lu,%3.3lu,%3.3lu" : "%lu%3.3lu%3.3lu%3.3lu", + (lnat)((x)/(ullong)1000000000), + (lnat)((x)/(ullong)1000000%(ullong)1000), + (lnat)((x)/(ullong)1000%(ullong)1000), + (lnat)((x)%(ullong)1000)); return s; } + + +// Can be used as a breakpoint to set on every heap check failure. +#ifdef DEBUG +void +heapCheckFail( void ) +{ +} +#endif + +/* + * It seems that pthreads and signals interact oddly in OpenBSD & FreeBSD + * pthreads (and possibly others). When linking with -lpthreads, we + * have to use pthread_kill to send blockable signals. So use that + * when we have a threaded rts. So System.Posix.Signals will call + * genericRaise(), rather than raise(3). + */ +int genericRaise(int sig) { +#if defined(THREADED_RTS) && (defined(openbsd_HOST_OS) || defined(freebsd_HOST_OS)) + return pthread_kill(pthread_self(), sig); +#else + return raise(sig); +#endif +} + +/* ----------------------------------------------------------------------------- + Allocating executable memory + -------------------------------------------------------------------------- */ + +/* Heavily arch-specific, I'm afraid.. */ + +/* + * Allocate len bytes which are readable, writable, and executable. + * + * ToDo: If this turns out to be a performance bottleneck, one could + * e.g. cache the last VirtualProtect/mprotect-ed region and do + * nothing in case of a cache hit. + */ +void* +stgMallocBytesRWX(int len) +{ + void *addr = stgMallocBytes(len, "mallocBytesRWX"); +#if defined(i386_HOST_ARCH) && defined(_WIN32) + /* This could be necessary for processors which distinguish between READ and + EXECUTE memory accesses, e.g. Itaniums. */ + DWORD dwOldProtect = 0; + if (VirtualProtect (addr, len, PAGE_EXECUTE_READWRITE, &dwOldProtect) == 0) { + barf("mallocBytesRWX: failed to protect 0x%p; error=%lu; old protection: %lu\n", + addr, (unsigned long)GetLastError(), (unsigned long)dwOldProtect); + } +#elif defined(openbsd_HOST_OS) || defined(linux_HOST_OS) + /* malloced memory isn't executable by default on OpenBSD */ + my_uintptr_t pageSize = sysconf(_SC_PAGESIZE); + my_uintptr_t mask = ~(pageSize - 1); + my_uintptr_t startOfFirstPage = ((my_uintptr_t)addr ) & mask; + my_uintptr_t startOfLastPage = ((my_uintptr_t)addr + len - 1) & mask; + my_uintptr_t size = startOfLastPage - startOfFirstPage + pageSize; + if (mprotect((void*)startOfFirstPage, (size_t)size, PROT_EXEC | PROT_READ | PROT_WRITE) != 0) { + barf("mallocBytesRWX: failed to protect 0x%p\n", addr); + } +#endif + return addr; +}