Replace "tail -n +2" with "sed 1d", as Solaris doesn't understand the former
[ghc.git] / 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