forked from ivmai/bdwgc
-
Notifications
You must be signed in to change notification settings - Fork 0
/
os_dep.c
4822 lines (4333 loc) · 169 KB
/
os_dep.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
* Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved.
* Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved.
* Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved.
*
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
*
* Permission is hereby granted to use or copy this program
* for any purpose, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*/
#include "private/gc_priv.h"
#if !defined(OS2) && !defined(PCR) && !defined(AMIGA) && !defined(MACOS) \
&& !defined(MSWINCE) && !defined(SN_TARGET_ORBIS) \
&& !defined(SN_TARGET_PSP2) && !defined(__CC_ARM)
# include <sys/types.h>
# if !defined(MSWIN32) && !defined(MSWIN_XBOX1)
# include <unistd.h>
# endif
#endif
#include <stdio.h>
#if defined(MSWINCE) || defined(SN_TARGET_PS3)
# define SIGSEGV 0 /* value is irrelevant */
#else
# include <signal.h>
#endif
#if defined(UNIX_LIKE) || defined(CYGWIN32) || defined(NACL) \
|| defined(SYMBIAN)
# include <fcntl.h>
#endif
#if defined(LINUX) || defined(LINUX_STACKBOTTOM)
# include <ctype.h>
#endif
/* Blatantly OS dependent routines, except for those that are related */
/* to dynamic loading. */
#ifdef AMIGA
# define GC_AMIGA_DEF
# include "extra/AmigaOS.c"
# undef GC_AMIGA_DEF
#endif
#if defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32)
# ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN 1
# endif
# define NOSERVICE
# include <windows.h>
/* It's not clear this is completely kosher under Cygwin. But it */
/* allows us to get a working GC_get_stack_base. */
#endif
#ifdef MACOS
# include <Processes.h>
#endif
#ifdef IRIX5
# include <sys/uio.h>
# include <malloc.h> /* for locking */
#endif
#if defined(MMAP_SUPPORTED) || defined(ADD_HEAP_GUARD_PAGES)
# if defined(USE_MUNMAP) && !defined(USE_MMAP) && !defined(CPPCHECK)
# error Invalid config: USE_MUNMAP requires USE_MMAP
# endif
# include <sys/types.h>
# include <sys/mman.h>
# include <sys/stat.h>
# include <errno.h>
#endif
#ifdef DARWIN
/* for get_etext and friends */
# include <mach-o/getsect.h>
#endif
#ifdef DJGPP
/* Apparently necessary for djgpp 2.01. May cause problems with */
/* other versions. */
typedef long unsigned int caddr_t;
#endif
#ifdef PCR
# include "il/PCR_IL.h"
# include "th/PCR_ThCtl.h"
# include "mm/PCR_MM.h"
#endif
#if defined(GC_DARWIN_THREADS) && defined(MPROTECT_VDB)
/* Declare GC_mprotect_stop and GC_mprotect_resume as extern "C". */
# include "private/darwin_stop_world.h"
#endif
#if !defined(NO_EXECUTE_PERMISSION)
STATIC GC_bool GC_pages_executable = TRUE;
#else
STATIC GC_bool GC_pages_executable = FALSE;
#endif
#define IGNORE_PAGES_EXECUTABLE 1
/* Undefined on GC_pages_executable real use. */
#ifdef NEED_PROC_MAPS
/* We need to parse /proc/self/maps, either to find dynamic libraries, */
/* and/or to find the register backing store base (IA64). Do it once */
/* here. */
/* Repeatedly perform a read call until the buffer is filled or */
/* we encounter EOF. */
STATIC ssize_t GC_repeat_read(int fd, char *buf, size_t count)
{
# define READ read
size_t num_read = 0;
ASSERT_CANCEL_DISABLED();
while (num_read < count) {
ssize_t result = READ(fd, buf + num_read, count - num_read);
if (result < 0) return result;
if (result == 0) break;
num_read += result;
}
# undef READ
return num_read;
}
#ifdef THREADS
/* Determine the length of a file by incrementally reading it into a */
/* buffer. This would be silly to use it on a file supporting lseek, */
/* but Linux /proc files usually do not. */
STATIC size_t GC_get_file_len(int f)
{
size_t total = 0;
ssize_t result;
# define GET_FILE_LEN_BUF_SZ 500
char buf[GET_FILE_LEN_BUF_SZ];
do {
result = read(f, buf, GET_FILE_LEN_BUF_SZ);
if (result == -1) return 0;
total += result;
} while (result > 0);
return total;
}
STATIC size_t GC_get_maps_len(void)
{
int f = open("/proc/self/maps", O_RDONLY);
size_t result;
if (f < 0) return 0; /* treat missing file as empty */
result = GC_get_file_len(f);
close(f);
return result;
}
#endif /* THREADS */
/* Copy the contents of /proc/self/maps to a buffer in our address */
/* space. Return the address of the buffer, or zero on failure. */
/* This code could be simplified if we could determine its size ahead */
/* of time. */
GC_INNER char * GC_get_maps(void)
{
ssize_t result;
static char *maps_buf = NULL;
static size_t maps_buf_sz = 1;
size_t maps_size;
# ifdef THREADS
size_t old_maps_size = 0;
# endif
/* The buffer is essentially static, so there must be a single client. */
GC_ASSERT(I_HOLD_LOCK());
/* Note that in the presence of threads, the maps file can */
/* essentially shrink asynchronously and unexpectedly as */
/* threads that we already think of as dead release their */
/* stacks. And there is no easy way to read the entire */
/* file atomically. This is arguably a misfeature of the */
/* /proc/.../maps interface. */
/* Since we expect the file can grow asynchronously in rare */
/* cases, it should suffice to first determine */
/* the size (using lseek or read), and then to reread the */
/* file. If the size is inconsistent we have to retry. */
/* This only matters with threads enabled, and if we use */
/* this to locate roots (not the default). */
# ifdef THREADS
/* Determine the initial size of /proc/self/maps. */
/* Note that lseek doesn't work, at least as of 2.6.15. */
maps_size = GC_get_maps_len();
if (0 == maps_size) return 0;
# else
maps_size = 4000; /* Guess */
# endif
/* Read /proc/self/maps, growing maps_buf as necessary. */
/* Note that we may not allocate conventionally, and */
/* thus can't use stdio. */
do {
int f;
while (maps_size >= maps_buf_sz) {
GC_scratch_recycle_no_gww(maps_buf, maps_buf_sz);
/* Grow only by powers of 2, since we leak "too small" buffers.*/
while (maps_size >= maps_buf_sz) maps_buf_sz *= 2;
maps_buf = GC_scratch_alloc(maps_buf_sz);
# ifdef THREADS
/* Recompute initial length, since we allocated. */
/* This can only happen a few times per program */
/* execution. */
maps_size = GC_get_maps_len();
if (0 == maps_size) return 0;
# endif
if (maps_buf == 0) return 0;
}
GC_ASSERT(maps_buf_sz >= maps_size + 1);
f = open("/proc/self/maps", O_RDONLY);
if (-1 == f) return 0;
# ifdef THREADS
old_maps_size = maps_size;
# endif
maps_size = 0;
do {
result = GC_repeat_read(f, maps_buf, maps_buf_sz-1);
if (result <= 0)
break;
maps_size += result;
} while ((size_t)result == maps_buf_sz-1);
close(f);
if (result <= 0)
return 0;
# ifdef THREADS
if (maps_size > old_maps_size) {
/* This might be caused by e.g. thread creation. */
WARN("Unexpected asynchronous /proc/self/maps growth"
" (to %" WARN_PRIdPTR " bytes)\n", maps_size);
}
# endif
} while (maps_size >= maps_buf_sz
# ifdef THREADS
|| maps_size < old_maps_size
# endif
);
maps_buf[maps_size] = '\0';
return maps_buf;
}
/*
* GC_parse_map_entry parses an entry from /proc/self/maps so we can
* locate all writable data segments that belong to shared libraries.
* The format of one of these entries and the fields we care about
* is as follows:
* XXXXXXXX-XXXXXXXX r-xp 00000000 30:05 260537 name of mapping...\n
* ^^^^^^^^ ^^^^^^^^ ^^^^ ^^
* start end prot maj_dev
*
* Note that since about august 2003 kernels, the columns no longer have
* fixed offsets on 64-bit kernels. Hence we no longer rely on fixed offsets
* anywhere, which is safer anyway.
*/
/* Assign various fields of the first line in buf_ptr to (*start), */
/* (*end), (*prot), (*maj_dev) and (*mapping_name). mapping_name may */
/* be NULL. (*prot) and (*mapping_name) are assigned pointers into the */
/* original buffer. */
#if (defined(DYNAMIC_LOADING) && defined(USE_PROC_FOR_LIBRARIES)) \
|| defined(IA64) || defined(INCLUDE_LINUX_THREAD_DESCR) \
|| defined(REDIRECT_MALLOC)
GC_INNER char *GC_parse_map_entry(char *buf_ptr, ptr_t *start, ptr_t *end,
char **prot, unsigned int *maj_dev,
char **mapping_name)
{
unsigned char *start_start, *end_start, *maj_dev_start;
unsigned char *p; /* unsigned for isspace, isxdigit */
if (buf_ptr == NULL || *buf_ptr == '\0') {
return NULL;
}
p = (unsigned char *)buf_ptr;
while (isspace(*p)) ++p;
start_start = p;
GC_ASSERT(isxdigit(*start_start));
*start = (ptr_t)strtoul((char *)start_start, (char **)&p, 16);
GC_ASSERT(*p=='-');
++p;
end_start = p;
GC_ASSERT(isxdigit(*end_start));
*end = (ptr_t)strtoul((char *)end_start, (char **)&p, 16);
GC_ASSERT(isspace(*p));
while (isspace(*p)) ++p;
GC_ASSERT(*p == 'r' || *p == '-');
*prot = (char *)p;
/* Skip past protection field to offset field */
while (!isspace(*p)) ++p; while (isspace(*p)) ++p;
GC_ASSERT(isxdigit(*p));
/* Skip past offset field, which we ignore */
while (!isspace(*p)) ++p; while (isspace(*p)) ++p;
maj_dev_start = p;
GC_ASSERT(isxdigit(*maj_dev_start));
*maj_dev = strtoul((char *)maj_dev_start, NULL, 16);
if (mapping_name == 0) {
while (*p && *p++ != '\n');
} else {
while (*p && *p != '\n' && *p != '/' && *p != '[') p++;
*mapping_name = (char *)p;
while (*p && *p++ != '\n');
}
return (char *)p;
}
#endif /* REDIRECT_MALLOC || DYNAMIC_LOADING || IA64 || ... */
#if defined(IA64) || defined(INCLUDE_LINUX_THREAD_DESCR)
/* Try to read the backing store base from /proc/self/maps. */
/* Return the bounds of the writable mapping with a 0 major device, */
/* which includes the address passed as data. */
/* Return FALSE if there is no such mapping. */
GC_INNER GC_bool GC_enclosing_mapping(ptr_t addr, ptr_t *startp,
ptr_t *endp)
{
char *prot;
ptr_t my_start, my_end;
unsigned int maj_dev;
char *maps = GC_get_maps();
char *buf_ptr = maps;
if (0 == maps) return(FALSE);
for (;;) {
buf_ptr = GC_parse_map_entry(buf_ptr, &my_start, &my_end,
&prot, &maj_dev, 0);
if (buf_ptr == NULL) return FALSE;
if (prot[1] == 'w' && maj_dev == 0) {
if ((word)my_end > (word)addr && (word)my_start <= (word)addr) {
*startp = my_start;
*endp = my_end;
return TRUE;
}
}
}
return FALSE;
}
#endif /* IA64 || INCLUDE_LINUX_THREAD_DESCR */
#if defined(REDIRECT_MALLOC)
/* Find the text(code) mapping for the library whose name, after */
/* stripping the directory part, starts with nm. */
GC_INNER GC_bool GC_text_mapping(char *nm, ptr_t *startp, ptr_t *endp)
{
size_t nm_len = strlen(nm);
char *prot;
char *map_path;
ptr_t my_start, my_end;
unsigned int maj_dev;
char *maps = GC_get_maps();
char *buf_ptr = maps;
if (0 == maps) return(FALSE);
for (;;) {
buf_ptr = GC_parse_map_entry(buf_ptr, &my_start, &my_end,
&prot, &maj_dev, &map_path);
if (buf_ptr == NULL) return FALSE;
if (prot[0] == 'r' && prot[1] == '-' && prot[2] == 'x') {
char *p = map_path;
/* Set p to point just past last slash, if any. */
while (*p != '\0' && *p != '\n' && *p != ' ' && *p != '\t') ++p;
while (*p != '/' && (word)p >= (word)map_path) --p;
++p;
if (strncmp(nm, p, nm_len) == 0) {
*startp = my_start;
*endp = my_end;
return TRUE;
}
}
}
return FALSE;
}
#endif /* REDIRECT_MALLOC */
#ifdef IA64
static ptr_t backing_store_base_from_proc(void)
{
ptr_t my_start, my_end;
if (!GC_enclosing_mapping(GC_save_regs_in_stack(), &my_start, &my_end)) {
GC_COND_LOG_PRINTF("Failed to find backing store base from /proc\n");
return 0;
}
return my_start;
}
#endif
#endif /* NEED_PROC_MAPS */
#if defined(SEARCH_FOR_DATA_START)
/* The I386 case can be handled without a search. The Alpha case */
/* used to be handled differently as well, but the rules changed */
/* for recent Linux versions. This seems to be the easiest way to */
/* cover all versions. */
# if defined(LINUX) || defined(HURD)
/* Some Linux distributions arrange to define __data_start. Some */
/* define data_start as a weak symbol. The latter is technically */
/* broken, since the user program may define data_start, in which */
/* case we lose. Nonetheless, we try both, preferring __data_start.*/
/* We assume gcc-compatible pragmas. */
EXTERN_C_BEGIN
# pragma weak __data_start
# pragma weak data_start
extern int __data_start[], data_start[];
EXTERN_C_END
# endif /* LINUX */
ptr_t GC_data_start = NULL;
GC_INNER void GC_init_linux_data_start(void)
{
ptr_t data_end = DATAEND;
# if (defined(LINUX) || defined(HURD)) && !defined(IGNORE_PROG_DATA_START)
/* Try the easy approaches first: */
if (COVERT_DATAFLOW(__data_start) != 0) {
GC_data_start = (ptr_t)(__data_start);
} else {
GC_data_start = (ptr_t)(data_start);
}
if (COVERT_DATAFLOW(GC_data_start) != 0) {
if ((word)GC_data_start > (word)data_end)
ABORT_ARG2("Wrong __data_start/_end pair",
": %p .. %p", (void *)GC_data_start, (void *)data_end);
return;
}
# ifdef DEBUG_ADD_DEL_ROOTS
GC_log_printf("__data_start not provided\n");
# endif
# endif /* LINUX */
if (GC_no_dls) {
/* Not needed, avoids the SIGSEGV caused by */
/* GC_find_limit which complicates debugging. */
GC_data_start = data_end; /* set data root size to 0 */
return;
}
GC_data_start = (ptr_t)GC_find_limit(data_end, FALSE);
}
#endif /* SEARCH_FOR_DATA_START */
#ifdef ECOS
# ifndef ECOS_GC_MEMORY_SIZE
# define ECOS_GC_MEMORY_SIZE (448 * 1024)
# endif /* ECOS_GC_MEMORY_SIZE */
/* TODO: This is a simple way of allocating memory which is */
/* compatible with ECOS early releases. Later releases use a more */
/* sophisticated means of allocating memory than this simple static */
/* allocator, but this method is at least bound to work. */
static char ecos_gc_memory[ECOS_GC_MEMORY_SIZE];
static char *ecos_gc_brk = ecos_gc_memory;
static void *tiny_sbrk(ptrdiff_t increment)
{
void *p = ecos_gc_brk;
ecos_gc_brk += increment;
if ((word)ecos_gc_brk > (word)(ecos_gc_memory + sizeof(ecos_gc_memory))) {
ecos_gc_brk -= increment;
return NULL;
}
return p;
}
# define sbrk tiny_sbrk
#endif /* ECOS */
#if defined(NETBSD) && defined(__ELF__)
ptr_t GC_data_start = NULL;
EXTERN_C_BEGIN
extern char **environ;
EXTERN_C_END
GC_INNER void GC_init_netbsd_elf(void)
{
/* This may need to be environ, without the underscore, for */
/* some versions. */
GC_data_start = (ptr_t)GC_find_limit(&environ, FALSE);
}
#endif /* NETBSD */
#if defined(ADDRESS_SANITIZER) && (defined(UNIX_LIKE) \
|| defined(NEED_FIND_LIMIT) || defined(MPROTECT_VDB)) \
&& !defined(CUSTOM_ASAN_DEF_OPTIONS)
/* To tell ASan to allow GC to use its own SIGBUS/SEGV handlers. */
/* The function is exported just to be visible to ASan library. */
GC_API const char *__asan_default_options(void)
{
return "allow_user_segv_handler=1";
}
#endif
#ifdef OPENBSD
static struct sigaction old_segv_act;
STATIC JMP_BUF GC_jmp_buf_openbsd;
# ifdef THREADS
# include <sys/syscall.h>
EXTERN_C_BEGIN
extern sigset_t __syscall(quad_t, ...);
EXTERN_C_END
# endif
/* Don't use GC_find_limit() because siglongjmp() outside of the */
/* signal handler by-passes our userland pthreads lib, leaving */
/* SIGSEGV and SIGPROF masked. Instead, use this custom one that */
/* works-around the issues. */
STATIC void GC_fault_handler_openbsd(int sig GC_ATTR_UNUSED)
{
LONGJMP(GC_jmp_buf_openbsd, 1);
}
/* Return the first non-addressable location > p or bound. */
/* Requires the allocation lock. */
STATIC ptr_t GC_find_limit_openbsd(ptr_t p, ptr_t bound)
{
static volatile ptr_t result;
/* Safer if static, since otherwise it may not be */
/* preserved across the longjmp. Can safely be */
/* static since it's only called with the */
/* allocation lock held. */
struct sigaction act;
word pgsz = (word)sysconf(_SC_PAGESIZE);
GC_ASSERT((word)bound >= pgsz);
GC_ASSERT(I_HOLD_LOCK());
act.sa_handler = GC_fault_handler_openbsd;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_NODEFER | SA_RESTART;
/* act.sa_restorer is deprecated and should not be initialized. */
sigaction(SIGSEGV, &act, &old_segv_act);
if (SETJMP(GC_jmp_buf_openbsd) == 0) {
result = (ptr_t)((word)p & ~(pgsz-1));
for (;;) {
if ((word)result >= (word)bound - pgsz) {
result = bound;
break;
}
result += pgsz; /* no overflow expected */
GC_noop1((word)(*result));
}
}
# ifdef THREADS
/* Due to the siglongjump we need to manually unmask SIGPROF. */
__syscall(SYS_sigprocmask, SIG_UNBLOCK, sigmask(SIGPROF));
# endif
sigaction(SIGSEGV, &old_segv_act, 0);
return(result);
}
/* Return first addressable location > p or bound. */
/* Requires the allocation lock. */
STATIC ptr_t GC_skip_hole_openbsd(ptr_t p, ptr_t bound)
{
static volatile ptr_t result;
static volatile int firstpass;
struct sigaction act;
word pgsz = (word)sysconf(_SC_PAGESIZE);
GC_ASSERT((word)bound >= pgsz);
GC_ASSERT(I_HOLD_LOCK());
act.sa_handler = GC_fault_handler_openbsd;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_NODEFER | SA_RESTART;
/* act.sa_restorer is deprecated and should not be initialized. */
sigaction(SIGSEGV, &act, &old_segv_act);
firstpass = 1;
result = (ptr_t)((word)p & ~(pgsz-1));
if (SETJMP(GC_jmp_buf_openbsd) != 0 || firstpass) {
firstpass = 0;
if ((word)result >= (word)bound - pgsz) {
result = bound;
} else {
result += pgsz; /* no overflow expected */
GC_noop1((word)(*result));
}
}
sigaction(SIGSEGV, &old_segv_act, 0);
return(result);
}
#endif /* OPENBSD */
# ifdef OS2
# include <stddef.h>
# if !defined(__IBMC__) && !defined(__WATCOMC__) /* e.g. EMX */
struct exe_hdr {
unsigned short magic_number;
unsigned short padding[29];
long new_exe_offset;
};
#define E_MAGIC(x) (x).magic_number
#define EMAGIC 0x5A4D
#define E_LFANEW(x) (x).new_exe_offset
struct e32_exe {
unsigned char magic_number[2];
unsigned char byte_order;
unsigned char word_order;
unsigned long exe_format_level;
unsigned short cpu;
unsigned short os;
unsigned long padding1[13];
unsigned long object_table_offset;
unsigned long object_count;
unsigned long padding2[31];
};
#define E32_MAGIC1(x) (x).magic_number[0]
#define E32MAGIC1 'L'
#define E32_MAGIC2(x) (x).magic_number[1]
#define E32MAGIC2 'X'
#define E32_BORDER(x) (x).byte_order
#define E32LEBO 0
#define E32_WORDER(x) (x).word_order
#define E32LEWO 0
#define E32_CPU(x) (x).cpu
#define E32CPU286 1
#define E32_OBJTAB(x) (x).object_table_offset
#define E32_OBJCNT(x) (x).object_count
struct o32_obj {
unsigned long size;
unsigned long base;
unsigned long flags;
unsigned long pagemap;
unsigned long mapsize;
unsigned long reserved;
};
#define O32_FLAGS(x) (x).flags
#define OBJREAD 0x0001L
#define OBJWRITE 0x0002L
#define OBJINVALID 0x0080L
#define O32_SIZE(x) (x).size
#define O32_BASE(x) (x).base
# else /* IBM's compiler */
/* A kludge to get around what appears to be a header file bug */
# ifndef WORD
# define WORD unsigned short
# endif
# ifndef DWORD
# define DWORD unsigned long
# endif
# define EXE386 1
# include <newexe.h>
# include <exe386.h>
# endif /* __IBMC__ */
# define INCL_DOSEXCEPTIONS
# define INCL_DOSPROCESS
# define INCL_DOSERRORS
# define INCL_DOSMODULEMGR
# define INCL_DOSMEMMGR
# include <os2.h>
# endif /* OS/2 */
/* Find the page size */
GC_INNER size_t GC_page_size = 0;
#if defined(MSWIN32) || defined(MSWINCE) || defined(CYGWIN32)
# ifndef VER_PLATFORM_WIN32_CE
# define VER_PLATFORM_WIN32_CE 3
# endif
# if defined(MSWINCE) && defined(THREADS)
GC_INNER GC_bool GC_dont_query_stack_min = FALSE;
# endif
GC_INNER SYSTEM_INFO GC_sysinfo;
GC_INNER void GC_setpagesize(void)
{
GetSystemInfo(&GC_sysinfo);
# if defined(CYGWIN32) && (defined(MPROTECT_VDB) || defined(USE_MUNMAP))
/* Allocations made with mmap() are aligned to the allocation */
/* granularity, which (at least on 64-bit Windows OS) is not the */
/* same as the page size. Probably a separate variable could */
/* be added to distinguish the allocation granularity from the */
/* actual page size, but in practice there is no good reason to */
/* make allocations smaller than dwAllocationGranularity, so we */
/* just use it instead of the actual page size here (as Cygwin */
/* itself does in many cases). */
GC_page_size = (size_t)GC_sysinfo.dwAllocationGranularity;
GC_ASSERT(GC_page_size >= (size_t)GC_sysinfo.dwPageSize);
# else
GC_page_size = (size_t)GC_sysinfo.dwPageSize;
# endif
# if defined(MSWINCE) && !defined(_WIN32_WCE_EMULATION)
{
OSVERSIONINFO verInfo;
/* Check the current WinCE version. */
verInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if (!GetVersionEx(&verInfo))
ABORT("GetVersionEx failed");
if (verInfo.dwPlatformId == VER_PLATFORM_WIN32_CE &&
verInfo.dwMajorVersion < 6) {
/* Only the first 32 MB of address space belongs to the */
/* current process (unless WinCE 6.0+ or emulation). */
GC_sysinfo.lpMaximumApplicationAddress = (LPVOID)((word)32 << 20);
# ifdef THREADS
/* On some old WinCE versions, it's observed that */
/* VirtualQuery calls don't work properly when used to */
/* get thread current stack committed minimum. */
if (verInfo.dwMajorVersion < 5)
GC_dont_query_stack_min = TRUE;
# endif
}
}
# endif
}
# ifndef CYGWIN32
# define is_writable(prot) ((prot) == PAGE_READWRITE \
|| (prot) == PAGE_WRITECOPY \
|| (prot) == PAGE_EXECUTE_READWRITE \
|| (prot) == PAGE_EXECUTE_WRITECOPY)
/* Return the number of bytes that are writable starting at p. */
/* The pointer p is assumed to be page aligned. */
/* If base is not 0, *base becomes the beginning of the */
/* allocation region containing p. */
STATIC word GC_get_writable_length(ptr_t p, ptr_t *base)
{
MEMORY_BASIC_INFORMATION buf;
word result;
word protect;
result = VirtualQuery(p, &buf, sizeof(buf));
if (result != sizeof(buf)) ABORT("Weird VirtualQuery result");
if (base != 0) *base = (ptr_t)(buf.AllocationBase);
protect = (buf.Protect & ~(PAGE_GUARD | PAGE_NOCACHE));
if (!is_writable(protect)) {
return(0);
}
if (buf.State != MEM_COMMIT) return(0);
return(buf.RegionSize);
}
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *sb)
{
ptr_t trunc_sp;
word size;
/* Set page size if it is not ready (so client can use this */
/* function even before GC is initialized). */
if (!GC_page_size) GC_setpagesize();
trunc_sp = (ptr_t)((word)GC_approx_sp() & ~(GC_page_size - 1));
/* FIXME: This won't work if called from a deeply recursive */
/* client code (and the committed stack space has grown). */
size = GC_get_writable_length(trunc_sp, 0);
GC_ASSERT(size != 0);
sb -> mem_base = trunc_sp + size;
return GC_SUCCESS;
}
# else /* CYGWIN32 */
/* An alternate version for Cygwin (adapted from Dave Korn's */
/* gcc version of boehm-gc). */
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *sb)
{
# ifdef X86_64
sb -> mem_base = ((NT_TIB*)NtCurrentTeb())->StackBase;
# else
void * _tlsbase;
__asm__ ("movl %%fs:4, %0"
: "=r" (_tlsbase));
sb -> mem_base = _tlsbase;
# endif
return GC_SUCCESS;
}
# endif /* CYGWIN32 */
# define HAVE_GET_STACK_BASE
#else /* !MSWIN32 */
GC_INNER void GC_setpagesize(void)
{
# if defined(MPROTECT_VDB) || defined(PROC_VDB) || defined(USE_MMAP)
GC_page_size = (size_t)GETPAGESIZE();
# if !defined(CPPCHECK)
if (0 == GC_page_size)
ABORT("getpagesize failed");
# endif
# else
/* It's acceptable to fake it. */
GC_page_size = HBLKSIZE;
# endif
}
#endif /* !MSWIN32 */
#ifdef HAIKU
# include <kernel/OS.h>
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *sb)
{
thread_info th;
get_thread_info(find_thread(NULL),&th);
sb->mem_base = th.stack_end;
return GC_SUCCESS;
}
# define HAVE_GET_STACK_BASE
#endif /* HAIKU */
#ifdef OS2
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *sb)
{
PTIB ptib; /* thread information block */
PPIB ppib;
if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) {
WARN("DosGetInfoBlocks failed\n", 0);
return GC_UNIMPLEMENTED;
}
sb->mem_base = ptib->tib_pstacklimit;
return GC_SUCCESS;
}
# define HAVE_GET_STACK_BASE
#endif /* OS2 */
# ifdef AMIGA
# define GC_AMIGA_SB
# include "extra/AmigaOS.c"
# undef GC_AMIGA_SB
# define GET_MAIN_STACKBASE_SPECIAL
# endif /* AMIGA */
# if defined(NEED_FIND_LIMIT) || defined(UNIX_LIKE)
typedef void (*GC_fault_handler_t)(int);
# if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1) \
|| defined(HAIKU) || defined(HURD) || defined(FREEBSD) \
|| defined(NETBSD)
static struct sigaction old_segv_act;
# if defined(_sigargs) /* !Irix6.x */ \
|| defined(HURD) || defined(NETBSD) || defined(FREEBSD)
static struct sigaction old_bus_act;
# endif
# else
static GC_fault_handler_t old_segv_handler;
# ifdef HAVE_SIGBUS
static GC_fault_handler_t old_bus_handler;
# endif
# endif
GC_INNER void GC_set_and_save_fault_handler(GC_fault_handler_t h)
{
# if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1) \
|| defined(HAIKU) || defined(HURD) || defined(FREEBSD) \
|| defined(NETBSD)
struct sigaction act;
act.sa_handler = h;
# ifdef SIGACTION_FLAGS_NODEFER_HACK
/* Was necessary for Solaris 2.3 and very temporary */
/* NetBSD bugs. */
act.sa_flags = SA_RESTART | SA_NODEFER;
# else
act.sa_flags = SA_RESTART;
# endif
(void) sigemptyset(&act.sa_mask);
/* act.sa_restorer is deprecated and should not be initialized. */
# ifdef GC_IRIX_THREADS
/* Older versions have a bug related to retrieving and */
/* and setting a handler at the same time. */
(void) sigaction(SIGSEGV, 0, &old_segv_act);
(void) sigaction(SIGSEGV, &act, 0);
# else
(void) sigaction(SIGSEGV, &act, &old_segv_act);
# if defined(IRIX5) && defined(_sigargs) /* Irix 5.x, not 6.x */ \
|| defined(HURD) || defined(NETBSD) || defined(FREEBSD)
/* Under Irix 5.x or HP/UX, we may get SIGBUS. */
/* Pthreads doesn't exist under Irix 5.x, so we */
/* don't have to worry in the threads case. */
(void) sigaction(SIGBUS, &act, &old_bus_act);
# endif
# endif /* !GC_IRIX_THREADS */
# else
old_segv_handler = signal(SIGSEGV, h);
# ifdef HAVE_SIGBUS
old_bus_handler = signal(SIGBUS, h);
# endif
# endif
# if defined(CPPCHECK) && defined(ADDRESS_SANITIZER)
GC_noop1((word)&__asan_default_options);
# endif
}
# endif /* NEED_FIND_LIMIT || UNIX_LIKE */
# if defined(NEED_FIND_LIMIT) \
|| (defined(USE_PROC_FOR_LIBRARIES) && defined(THREADS))
/* Some tools to implement HEURISTIC2 */
# define MIN_PAGE_SIZE 256 /* Smallest conceivable page size, bytes */
GC_INNER JMP_BUF GC_jmp_buf;
STATIC void GC_fault_handler(int sig GC_ATTR_UNUSED)
{
LONGJMP(GC_jmp_buf, 1);
}
GC_INNER void GC_setup_temporary_fault_handler(void)
{
/* Handler is process-wide, so this should only happen in */
/* one thread at a time. */
GC_ASSERT(I_HOLD_LOCK());
GC_set_and_save_fault_handler(GC_fault_handler);
}
GC_INNER void GC_reset_fault_handler(void)
{
# if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1) \
|| defined(HAIKU) || defined(HURD) || defined(FREEBSD) \
|| defined(NETBSD)
(void) sigaction(SIGSEGV, &old_segv_act, 0);
# if defined(IRIX5) && defined(_sigargs) /* Irix 5.x, not 6.x */ \
|| defined(HURD) || defined(NETBSD)
(void) sigaction(SIGBUS, &old_bus_act, 0);
# endif
# else
(void) signal(SIGSEGV, old_segv_handler);
# ifdef HAVE_SIGBUS
(void) signal(SIGBUS, old_bus_handler);
# endif
# endif
}
/* Return the first non-addressable location > p (up) or */
/* the smallest location q s.t. [q,p) is addressable (!up). */
/* We assume that p (up) or p-1 (!up) is addressable. */
/* Requires allocation lock. */
STATIC ptr_t GC_find_limit_with_bound(ptr_t p, GC_bool up, ptr_t bound)
{
static volatile ptr_t result;
/* Safer if static, since otherwise it may not be */
/* preserved across the longjmp. Can safely be */
/* static since it's only called with the */
/* allocation lock held. */
GC_ASSERT(up ? (word)bound >= MIN_PAGE_SIZE
: (word)bound <= ~(word)MIN_PAGE_SIZE);
GC_ASSERT(I_HOLD_LOCK());
GC_setup_temporary_fault_handler();
if (SETJMP(GC_jmp_buf) == 0) {
result = (ptr_t)(((word)(p))
& ~(MIN_PAGE_SIZE-1));
for (;;) {
if (up) {
if ((word)result >= (word)bound - MIN_PAGE_SIZE) {
result = bound;
break;
}
result += MIN_PAGE_SIZE; /* no overflow expected */
} else {
if ((word)result <= (word)bound + MIN_PAGE_SIZE) {
result = bound - MIN_PAGE_SIZE;
/* This is to compensate */
/* further result increment (we */
/* do not modify "up" variable */
/* since it might be clobbered */
/* by setjmp otherwise). */
break;