2 * A saved SBCL system is a .core file; the code here helps us accept
3 * such a file as input.
7 * This software is part of the SBCL system. See the README file for
10 * This software is derived from the CMU CL system, which was
11 * written at Carnegie Mellon University and released into the
12 * public domain. The software is in the public domain and is
13 * provided with absolutely no warranty. See the COPYING and CREDITS
14 * files for more information.
19 #ifndef LISP_FEATURE_WIN32
20 #ifdef LISP_FEATURE_LINUX
34 #include <sys/types.h>
48 #include "gc-internal.h"
49 #include "runtime-options.h"
53 #ifdef LISP_FEATURE_SB_CORE_COMPRESSION
57 unsigned char build_id
[] =
58 #include "../../output/build-id.tmp"
62 open_binary(char *filename
, int mode
)
64 #ifdef LISP_FEATURE_WIN32
68 return open(filename
, mode
);
72 static struct runtime_options
*
73 read_runtime_options(int fd
)
75 os_vm_size_t optarray
[RUNTIME_OPTIONS_WORDS
];
76 struct runtime_options
*options
= NULL
;
78 if (read(fd
, optarray
, RUNTIME_OPTIONS_WORDS
* sizeof(os_vm_size_t
)) !=
79 RUNTIME_OPTIONS_WORDS
* sizeof(size_t)) {
83 if ((RUNTIME_OPTIONS_MAGIC
!= optarray
[0]) || (0 == optarray
[1])) {
87 options
= successful_malloc(sizeof(struct runtime_options
));
89 options
->dynamic_space_size
= optarray
[2];
90 options
->thread_control_stack_size
= optarray
[3];
96 maybe_initialize_runtime_options(int fd
)
98 struct runtime_options
*new_runtime_options
;
99 off_t end_offset
= sizeof(lispobj
) +
100 sizeof(os_vm_offset_t
) +
101 (RUNTIME_OPTIONS_WORDS
* sizeof(size_t));
103 lseek(fd
, -end_offset
, SEEK_END
);
105 if ((new_runtime_options
= read_runtime_options(fd
))) {
106 runtime_options
= new_runtime_options
;
110 /* Search 'filename' for an embedded core. An SBCL core has, at the
111 * end of the file, a trailer containing optional saved runtime
112 * options, the start of the core (an os_vm_offset_t), and a final
113 * signature word (the lispobj CORE_MAGIC). If this trailer is found
114 * at the end of the file, the start of the core can be determined
115 * from the core size.
117 * If an embedded core is present, this returns the offset into the
118 * file to load the core from, or -1 if no core is present. */
120 search_for_embedded_core(char *filename
)
123 os_vm_offset_t lispobj_size
= sizeof(lispobj
);
124 os_vm_offset_t trailer_size
= lispobj_size
+ sizeof(os_vm_offset_t
);
125 os_vm_offset_t core_start
, pos
;
128 if ((fd
= open_binary(filename
, O_RDONLY
)) < 0)
131 if (read(fd
, &header
, (size_t)lispobj_size
) < lispobj_size
)
133 if (header
== CORE_MAGIC
) {
134 /* This file is a real core, not an embedded core. Return 0 to
135 * indicate where the core starts, and do not look for runtime
136 * options in this case. */
140 if (lseek(fd
, -lispobj_size
, SEEK_END
) < 0)
142 if (read(fd
, &header
, (size_t)lispobj_size
) < lispobj_size
)
145 if (header
== CORE_MAGIC
) {
146 if (lseek(fd
, -trailer_size
, SEEK_END
) < 0)
148 if (read(fd
, &core_start
, sizeof(os_vm_offset_t
)) < 0)
151 if (lseek(fd
, core_start
, SEEK_SET
) < 0)
153 pos
= lseek(fd
, 0, SEEK_CUR
);
155 if (read(fd
, &header
, (size_t)lispobj_size
) < lispobj_size
)
158 if (header
!= CORE_MAGIC
)
161 maybe_initialize_runtime_options(fd
);
174 /* If more platforms doesn't support overlapping mmap rename this
175 * def to something like ifdef nommapoverlap */
176 /* currently hpux only */
177 #ifdef LISP_FEATURE_HPUX
178 os_vm_address_t
copy_core_bytes(int fd
, os_vm_offset_t offset
,
179 os_vm_address_t addr
, int len
)
181 unsigned char buf
[4096];
183 int old_fd
= lseek(fd
, 0, SEEK_CUR
);
186 fprintf(stderr
, "cant copy a slice of core because slice-length is not of page size(4096)\n");
190 fprintf(stderr
, "cant perform lseek() on corefile\n");
192 lseek(fd
, offset
, SEEK_SET
);
194 fprintf(stderr
, "cant perform lseek(%u,%lu,SEEK_SET) on corefile\n", fd
, offset
);
196 for(x
= 0; x
< len
; x
+= 4096){
197 c
= read(fd
, buf
, 4096);
199 fprintf(stderr
, "cant read memory area from corefile at position %lu, got %d\n", offset
+ x
, c
);
202 memcpy(addr
+x
, buf
, 4096);
204 os_flush_icache(addr
, len
);
209 #ifdef LISP_FEATURE_SB_CORE_COMPRESSION
210 # define ZLIB_BUFFER_SIZE (1u<<16)
211 os_vm_address_t
inflate_core_bytes(int fd
, os_vm_offset_t offset
,
212 os_vm_address_t addr
, int len
)
215 unsigned char buf
[ZLIB_BUFFER_SIZE
];
218 # ifdef LISP_FEATURE_WIN32
219 /* Ensure the memory is committed so zlib doesn't segfault trying to
221 os_validate_recommit(addr
, len
);
224 if (-1 == lseek(fd
, offset
, SEEK_SET
)) {
225 lose("Unable to lseek() on corefile\n");
228 stream
.zalloc
= NULL
;
230 stream
.opaque
= NULL
;
232 stream
.next_in
= buf
;
234 ret
= inflateInit(&stream
);
236 lose("zlib error %i\n", ret
);
238 stream
.next_out
= (void*)addr
;
239 stream
.avail_out
= len
;
241 ssize_t count
= read(fd
, buf
, sizeof(buf
));
243 lose("unable to read core file (errno = %i)\n", errno
);
244 stream
.next_in
= buf
;
245 stream
.avail_in
= count
;
246 if (count
== 0) break;
247 ret
= inflate(&stream
, Z_NO_FLUSH
);
252 if (stream
.avail_out
== 0)
253 lose("Runaway gzipped core directory... aborting\n");
254 if (stream
.avail_in
> 0)
255 lose("zlib inflate returned without fully"
256 "using up input buffer... aborting\n");
259 lose("zlib inflate error: %i\n", ret
);
262 } while (ret
!= Z_STREAM_END
);
264 if (stream
.avail_out
> 0) {
265 if (stream
.avail_out
>= os_vm_page_size
)
266 fprintf(stderr
, "Warning: gzipped core directory significantly"
267 "shorter than expected (%lu bytes)", (unsigned long)stream
.avail_out
);
268 /* Is this needed? */
269 memset(stream
.next_out
, 0, stream
.avail_out
);
275 # undef ZLIB_BUFFER_SIZE
278 int merge_core_pages
= -1;
281 process_directory(int fd
, lispobj
*ptr
, int count
, os_vm_offset_t file_offset
)
283 extern void immobile_space_coreparse(uword_t
,uword_t
);
284 struct ndir_entry
*entry
;
287 FSHOW((stderr
, "/process_directory(..), count=%d\n", count
));
289 for (entry
= (struct ndir_entry
*) ptr
; --count
>= 0; ++entry
) {
292 sword_t id
= entry
->identifier
;
293 if (id
<= (MAX_CORE_SPACE_ID
| DEFLATED_CORE_SPACE_ID_FLAG
)) {
294 if (id
& DEFLATED_CORE_SPACE_ID_FLAG
)
296 id
&= ~(DEFLATED_CORE_SPACE_ID_FLAG
);
298 sword_t offset
= os_vm_page_size
* (1 + entry
->data_page
);
299 os_vm_address_t addr
=
300 (os_vm_address_t
) (os_vm_page_size
* entry
->address
);
301 lispobj
*free_pointer
= (lispobj
*) addr
+ entry
->nwords
;
302 uword_t len
= os_vm_page_size
* entry
->page_count
;
304 os_vm_address_t real_addr
;
305 FSHOW((stderr
, "/mapping %ld(0x%lx) bytes at 0x%lx\n",
306 len
, len
, (uword_t
)addr
));
308 #ifdef LISP_FEATURE_SB_CORE_COMPRESSION
309 real_addr
= inflate_core_bytes(fd
, offset
+ file_offset
, addr
, len
);
311 lose("This runtime was not built with zlib-compressed core support... aborting\n");
314 #ifdef LISP_FEATURE_HPUX
315 real_addr
= copy_core_bytes(fd
, offset
+ file_offset
, addr
, len
);
317 real_addr
= os_map(fd
, offset
+ file_offset
, addr
, len
);
320 if (real_addr
!= addr
) {
321 lose("file mapped in wrong place! "
322 "(0x%08x != 0x%08lx)\n",
328 #ifdef MADV_MERGEABLE
329 if ((merge_core_pages
== 1)
330 || ((merge_core_pages
== -1) && compressed
)) {
331 madvise(addr
, len
, MADV_MERGEABLE
);
334 FSHOW((stderr
, "/space id = %ld, free pointer = %p\n",
335 id
, (uword_t
)free_pointer
));
338 case DYNAMIC_CORE_SPACE_ID
:
339 if (len
> dynamic_space_size
) {
341 "dynamic space too small for core: %luKiB required, %luKiB available.\n",
342 (unsigned long)len
>> 10,
343 (unsigned long)dynamic_space_size
>> 10);
346 #ifdef LISP_FEATURE_GENCGC
347 if (addr
!= (os_vm_address_t
)DYNAMIC_SPACE_START
) {
348 fprintf(stderr
, "in core: %p; in runtime: %p \n",
349 (void*)addr
, (void*)DYNAMIC_SPACE_START
);
350 lose("core/runtime address mismatch: DYNAMIC_SPACE_START\n");
353 if ((addr
!= (os_vm_address_t
)DYNAMIC_0_SPACE_START
) &&
354 (addr
!= (os_vm_address_t
)DYNAMIC_1_SPACE_START
)) {
355 fprintf(stderr
, "in core: %p; in runtime: %p or %p\n",
357 (void*)DYNAMIC_0_SPACE_START
,
358 (void*)DYNAMIC_1_SPACE_START
);
359 lose("warning: core/runtime address mismatch: DYNAMIC_SPACE_START\n");
362 #if defined(ALLOCATION_POINTER)
363 SetSymbolValue(ALLOCATION_POINTER
, (lispobj
)free_pointer
,0);
365 dynamic_space_free_pointer
= free_pointer
;
367 /* For stop-and-copy GC, this will be whatever the GC was
368 * using at the time. With GENCGC, this will always be
369 * space 0. (We checked above that for GENCGC,
370 * addr==DYNAMIC_SPACE_START.) */
371 current_dynamic_space
= (lispobj
*)addr
;
373 case STATIC_CORE_SPACE_ID
:
374 if (addr
!= (os_vm_address_t
)STATIC_SPACE_START
) {
375 fprintf(stderr
, "in core: %p - in runtime: %p\n",
376 (void*)addr
, (void*)STATIC_SPACE_START
);
377 lose("core/runtime address mismatch: STATIC_SPACE_START\n");
380 case READ_ONLY_CORE_SPACE_ID
:
381 if (addr
!= (os_vm_address_t
)READ_ONLY_SPACE_START
) {
382 fprintf(stderr
, "in core: %p - in runtime: %p\n",
383 (void*)addr
, (void*)READ_ONLY_SPACE_START
);
384 lose("core/runtime address mismatch: READ_ONLY_SPACE_START\n");
387 #ifdef LISP_FEATURE_IMMOBILE_SPACE
388 // Immobile space is subdivided into fixed-size and variable-size.
389 // There is no margin between the two, though for efficiency
390 // they are written separately to eliminate waste in the core file.
391 case IMMOBILE_FIXEDOBJ_CORE_SPACE_ID
:
392 if (addr
!= (os_vm_address_t
)IMMOBILE_SPACE_START
) {
393 fprintf(stderr
, "in core: %p - in runtime: %p\n",
394 (void*)addr
, (void*)IMMOBILE_SPACE_START
);
395 lose("core/runtime address mismatch: IMMOBILE_SPACE_START\n");
397 immobile_space_coreparse(IMMOBILE_SPACE_START
, len
);
399 case IMMOBILE_VARYOBJ_CORE_SPACE_ID
:
400 if (addr
!= (os_vm_address_t
)IMMOBILE_VARYOBJ_SUBSPACE_START
) {
401 fprintf(stderr
, "in core: %p - in runtime: %p\n",
402 (void*)addr
, (void*)IMMOBILE_VARYOBJ_SUBSPACE_START
);
403 lose("core/runtime address mismatch: IMMOBILE_VARYOBJ_SUBSPACE_START\n");
405 immobile_space_coreparse(IMMOBILE_VARYOBJ_SUBSPACE_START
, len
);
409 lose("unknown space ID %ld addr %p\n", id
, addr
);
415 load_core_file(char *file
, os_vm_offset_t file_offset
)
418 #ifndef LISP_FEATURE_ALPHA
423 os_vm_size_t len
, remaining_len
;
424 int fd
= open_binary(file
, O_RDONLY
);
426 lispobj initial_function
= NIL
;
428 FSHOW((stderr
, "/entering load_core_file(%s)\n", file
));
430 fprintf(stderr
, "could not open file \"%s\"\n", file
);
435 lseek(fd
, file_offset
, SEEK_SET
);
436 header
= calloc(os_vm_page_size
, 1);
438 count
= read(fd
, header
, os_vm_page_size
);
439 if (count
< (ssize_t
) os_vm_page_size
) {
440 lose("premature end of core file\n");
442 SHOW("successfully read first page of core");
447 if (val
!= CORE_MAGIC
) {
448 lose("invalid magic number in core: 0x%lx should have been 0x%x.\n",
452 SHOW("found CORE_MAGIC");
454 while (val
!= END_CORE_ENTRY_TYPE_CODE
) {
457 remaining_len
= len
- 2; /* (-2 to cancel the two ++ operations) */
458 FSHOW((stderr
, "/val=0x%"WORD_FMTX
", remaining_len=0x%"WORD_FMTX
"\n",
459 val
, remaining_len
));
463 case END_CORE_ENTRY_TYPE_CODE
:
464 SHOW("END_CORE_ENTRY_TYPE_CODE case");
467 case BUILD_ID_CORE_ENTRY_TYPE_CODE
:
468 SHOW("BUILD_ID_CORE_ENTRY_TYPE_CODE case");
472 FSHOW((stderr
, "build_id[]=\"%s\"\n", build_id
));
473 FSHOW((stderr
, "remaining_len = %d\n", remaining_len
));
474 if (remaining_len
!= strlen((const char *)build_id
))
475 goto losing_build_id
;
476 for (i
= 0; i
< remaining_len
; ++i
) {
477 FSHOW((stderr
, "ptr[%d] = char = %d, expected=%d\n",
478 i
, ptr
[i
], build_id
[i
]));
479 if (ptr
[i
] != build_id
[i
])
480 goto losing_build_id
;
484 /* .core files are not binary-compatible between
485 * builds because we can't easily detect whether the
486 * sources were patched between the time the
487 * dumping-the-.core runtime was built and the time
488 * that the loading-the-.core runtime was built.
490 * (We could easily detect whether version.lisp-expr
491 * was changed, but people experimenting with patches
492 * don't necessarily update version.lisp-expr.) */
494 lose("can't load .core for different runtime, sorry\n");
497 case NEW_DIRECTORY_CORE_ENTRY_TYPE_CODE
:
498 SHOW("NEW_DIRECTORY_CORE_ENTRY_TYPE_CODE case");
499 process_directory(fd
,
501 #ifndef LISP_FEATURE_ALPHA
502 remaining_len
/ (sizeof(struct ndir_entry
) /
505 remaining_len
/ (sizeof(struct ndir_entry
) /
511 case INITIAL_FUN_CORE_ENTRY_TYPE_CODE
:
512 SHOW("INITIAL_FUN_CORE_ENTRY_TYPE_CODE case");
513 initial_function
= (lispobj
)*ptr
;
516 #ifdef LISP_FEATURE_GENCGC
517 case PAGE_TABLE_CORE_ENTRY_TYPE_CODE
:
519 os_vm_size_t size
= *ptr
;
520 os_vm_size_t fdoffset
= (*(ptr
+1) + 1) * (os_vm_page_size
);
521 page_index_t offset
= 0;
525 lseek(fd
, fdoffset
+ file_offset
, SEEK_SET
);
526 while ((bytes_read
= read(fd
, data
, (size
< 4096 ? size
: 4096 )))
532 bytes_read
-= sizeof(word_t
);
533 /* Ignore all zeroes. The size of the page table
534 * core entry was rounded up to os_vm_page_size
535 * during the save, and might now have more
536 * elements than the page table.
538 * The low bits of each word are allocation flags.
540 if ((word
=data
[i
])) {
541 page_table
[offset
].scan_start_offset
= word
& ~0x03;
542 page_table
[offset
].allocated
= word
& 0x03;
549 gencgc_partial_pickup
= 1;
554 lose("unknown core file entry: 0x%"WORD_FMTX
"\n", val
);
557 ptr
+= remaining_len
;
558 FSHOW((stderr
, "/new ptr=0x%"WORD_FMTX
"\n", ptr
));
560 SHOW("about to free(header)");
563 SHOW("returning from load_core_file(..)");
564 return initial_function
;
567 #include "genesis/hash-table.h"
568 #include "genesis/vector.h"
569 os_vm_address_t
get_asm_routine_by_name(const char* name
)
571 lispobj routines
= SYMBOL(ASSEMBLER_ROUTINES
)->value
;
572 if (lowtag_of(routines
) == INSTANCE_POINTER_LOWTAG
) {
573 struct hash_table
* ht
= (struct hash_table
*)native_pointer(routines
);
574 struct vector
* table
= (struct vector
*)native_pointer(ht
->table
);
577 for (i
=2 ; i
< fixnum_value(table
->length
) ; i
+= 2) {
578 sym
= table
->data
[i
];
579 if (lowtag_of(sym
) == OTHER_POINTER_LOWTAG
580 && widetag_of(SYMBOL(sym
)->header
) == SYMBOL_HEADER_WIDETAG
582 (char*)((struct vector
*)
583 native_pointer(SYMBOL(sym
)->name
))->data
))
584 return (os_vm_address_t
)fixnum_value(table
->data
[i
+1]);
586 // Something is wrong if we have a hashtable but find nothing.
587 fprintf(stderr
, "WARNING: get_asm_routine_by_name(%s) failed\n",
593 void asm_routine_poke(const char* routine
, int offset
, char byte
)
595 char *address
= (char *)get_asm_routine_by_name(routine
);
597 address
[offset
] = byte
;