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 if (-1 == lseek(fd
, offset
, SEEK_SET
)) {
219 lose("Unable to lseek() on corefile\n");
222 stream
.zalloc
= NULL
;
224 stream
.opaque
= NULL
;
226 stream
.next_in
= buf
;
228 ret
= inflateInit(&stream
);
230 lose("zlib error %i\n", ret
);
232 stream
.next_out
= (void*)addr
;
233 stream
.avail_out
= len
;
235 ssize_t count
= read(fd
, buf
, sizeof(buf
));
237 lose("unable to read core file (errno = %i)\n", errno
);
238 stream
.next_in
= buf
;
239 stream
.avail_in
= count
;
240 if (count
== 0) break;
241 ret
= inflate(&stream
, Z_NO_FLUSH
);
246 if (stream
.avail_out
== 0)
247 lose("Runaway gzipped core directory... aborting\n");
248 if (stream
.avail_in
> 0)
249 lose("zlib inflate returned without fully"
250 "using up input buffer... aborting\n");
253 lose("zlib inflate error: %i\n", ret
);
256 } while (ret
!= Z_STREAM_END
);
258 if (stream
.avail_out
> 0) {
259 if (stream
.avail_out
>= os_vm_page_size
)
260 fprintf(stderr
, "Warning: gzipped core directory significantly"
261 "shorter than expected (%lu bytes)", (unsigned long)stream
.avail_out
);
262 /* Is this needed? */
263 memset(stream
.next_out
, 0, stream
.avail_out
);
269 # undef ZLIB_BUFFER_SIZE
272 int merge_core_pages
= -1;
275 process_directory(int fd
, lispobj
*ptr
, int count
, os_vm_offset_t file_offset
)
277 struct ndir_entry
*entry
;
280 FSHOW((stderr
, "/process_directory(..), count=%d\n", count
));
282 for (entry
= (struct ndir_entry
*) ptr
; --count
>= 0; ++entry
) {
284 long id
= entry
->identifier
;
285 if (id
<= (MAX_CORE_SPACE_ID
| DEFLATED_CORE_SPACE_ID_FLAG
)) {
286 if (id
& DEFLATED_CORE_SPACE_ID_FLAG
)
288 id
&= ~(DEFLATED_CORE_SPACE_ID_FLAG
);
290 long offset
= os_vm_page_size
* (1 + entry
->data_page
);
291 os_vm_address_t addr
=
292 (os_vm_address_t
) (os_vm_page_size
* entry
->address
);
293 lispobj
*free_pointer
= (lispobj
*) addr
+ entry
->nwords
;
294 unsigned long len
= os_vm_page_size
* entry
->page_count
;
296 os_vm_address_t real_addr
;
297 FSHOW((stderr
, "/mapping %ld(0x%lx) bytes at 0x%lx\n",
298 (long)len
, (long)len
, (unsigned long)addr
));
300 #ifdef LISP_FEATURE_SB_CORE_COMPRESSION
301 real_addr
= inflate_core_bytes(fd
, offset
+ file_offset
, addr
, len
);
303 lose("This runtime was not built with zlib-compressed core support... aborting\n");
306 #ifdef LISP_FEATURE_HPUX
307 real_addr
= copy_core_bytes(fd
, offset
+ file_offset
, addr
, len
);
309 real_addr
= os_map(fd
, offset
+ file_offset
, addr
, len
);
312 if (real_addr
!= addr
) {
313 lose("file mapped in wrong place! "
314 "(0x%08x != 0x%08lx)\n",
320 #ifdef MADV_MERGEABLE
321 if ((merge_core_pages
== 1)
322 || ((merge_core_pages
== -1) && compressed
)) {
323 madvise(addr
, len
, MADV_MERGEABLE
);
327 FSHOW((stderr
, "/space id = %ld, free pointer = 0x%lx\n",
328 id
, (unsigned long)free_pointer
));
331 case DYNAMIC_CORE_SPACE_ID
:
332 if (len
> dynamic_space_size
) {
334 "dynamic space too small for core: %ldKiB required, %ldKiB available.\n",
336 (long)dynamic_space_size
>> 10);
339 #ifdef LISP_FEATURE_GENCGC
340 if (addr
!= (os_vm_address_t
)DYNAMIC_SPACE_START
) {
341 fprintf(stderr
, "in core: 0x%lx; in runtime: 0x%lx \n",
342 (long)addr
, (long)DYNAMIC_SPACE_START
);
343 lose("core/runtime address mismatch: DYNAMIC_SPACE_START\n");
346 if ((addr
!= (os_vm_address_t
)DYNAMIC_0_SPACE_START
) &&
347 (addr
!= (os_vm_address_t
)DYNAMIC_1_SPACE_START
)) {
348 fprintf(stderr
, "in core: 0x%lx; in runtime: 0x%lx or 0x%lx\n",
350 (long)DYNAMIC_0_SPACE_START
,
351 (long)DYNAMIC_1_SPACE_START
);
352 lose("warning: core/runtime address mismatch: DYNAMIC_SPACE_START\n");
355 #if defined(ALLOCATION_POINTER)
356 SetSymbolValue(ALLOCATION_POINTER
, (lispobj
)free_pointer
,0);
358 dynamic_space_free_pointer
= free_pointer
;
360 /* For stop-and-copy GC, this will be whatever the GC was
361 * using at the time. With GENCGC, this will always be
362 * space 0. (We checked above that for GENCGC,
363 * addr==DYNAMIC_SPACE_START.) */
364 current_dynamic_space
= (lispobj
*)addr
;
366 case STATIC_CORE_SPACE_ID
:
367 if (addr
!= (os_vm_address_t
)STATIC_SPACE_START
) {
368 fprintf(stderr
, "in core: 0x%lx - in runtime: 0x%lx\n",
369 (long)addr
, (long)STATIC_SPACE_START
);
370 lose("core/runtime address mismatch: STATIC_SPACE_START\n");
373 case READ_ONLY_CORE_SPACE_ID
:
374 if (addr
!= (os_vm_address_t
)READ_ONLY_SPACE_START
) {
375 fprintf(stderr
, "in core: 0x%lx - in runtime: 0x%lx\n",
376 (long)addr
, (long)READ_ONLY_SPACE_START
);
377 lose("core/runtime address mismatch: READ_ONLY_SPACE_START\n");
381 lose("unknown space ID %ld addr 0x%lx\n", id
, (long)addr
);
387 load_core_file(char *file
, os_vm_offset_t file_offset
)
391 os_vm_size_t len
, remaining_len
;
392 int fd
= open_binary(file
, O_RDONLY
);
394 lispobj initial_function
= NIL
;
396 FSHOW((stderr
, "/entering load_core_file(%s)\n", file
));
398 fprintf(stderr
, "could not open file \"%s\"\n", file
);
403 lseek(fd
, file_offset
, SEEK_SET
);
404 header
= calloc(os_vm_page_size
, 1);
406 count
= read(fd
, header
, os_vm_page_size
);
407 if (count
< os_vm_page_size
) {
408 lose("premature end of core file\n");
410 SHOW("successfully read first page of core");
415 if (val
!= CORE_MAGIC
) {
416 lose("invalid magic number in core: 0x%lx should have been 0x%x.\n",
420 SHOW("found CORE_MAGIC");
422 while (val
!= END_CORE_ENTRY_TYPE_CODE
) {
425 remaining_len
= len
- 2; /* (-2 to cancel the two ++ operations) */
426 FSHOW((stderr
, "/val=0x%"WORD_FMTX
", remaining_len=0x%"WORD_FMTX
"\n",
427 val
, remaining_len
));
431 case END_CORE_ENTRY_TYPE_CODE
:
432 SHOW("END_CORE_ENTRY_TYPE_CODE case");
435 case VERSION_CORE_ENTRY_TYPE_CODE
:
436 SHOW("VERSION_CORE_ENTRY_TYPE_CODE case");
437 if (*ptr
!= SBCL_CORE_VERSION_INTEGER
) {
438 lose("core file version (%d) != runtime library version (%d)\n",
440 SBCL_CORE_VERSION_INTEGER
);
444 case BUILD_ID_CORE_ENTRY_TYPE_CODE
:
445 SHOW("BUILD_ID_CORE_ENTRY_TYPE_CODE case");
449 FSHOW((stderr
, "build_id[]=\"%s\"\n", build_id
));
450 FSHOW((stderr
, "remaining_len = %d\n", remaining_len
));
451 if (remaining_len
!= strlen((const char *)build_id
))
452 goto losing_build_id
;
453 for (i
= 0; i
< remaining_len
; ++i
) {
454 FSHOW((stderr
, "ptr[%d] = char = %d, expected=%d\n",
455 i
, ptr
[i
], build_id
[i
]));
456 if (ptr
[i
] != build_id
[i
])
457 goto losing_build_id
;
461 /* .core files are not binary-compatible between
462 * builds because we can't easily detect whether the
463 * sources were patched between the time the
464 * dumping-the-.core runtime was built and the time
465 * that the loading-the-.core runtime was built.
467 * (We could easily detect whether version.lisp-expr
468 * was changed, but people experimenting with patches
469 * don't necessarily update version.lisp-expr.) */
471 lose("can't load .core for different runtime, sorry\n");
474 case NEW_DIRECTORY_CORE_ENTRY_TYPE_CODE
:
475 SHOW("NEW_DIRECTORY_CORE_ENTRY_TYPE_CODE case");
476 process_directory(fd
,
478 #ifndef LISP_FEATURE_ALPHA
479 remaining_len
/ (sizeof(struct ndir_entry
) /
482 remaining_len
/ (sizeof(struct ndir_entry
) /
488 case INITIAL_FUN_CORE_ENTRY_TYPE_CODE
:
489 SHOW("INITIAL_FUN_CORE_ENTRY_TYPE_CODE case");
490 initial_function
= (lispobj
)*ptr
;
493 #ifdef LISP_FEATURE_GENCGC
494 case PAGE_TABLE_CORE_ENTRY_TYPE_CODE
:
496 os_vm_size_t size
= *ptr
;
497 os_vm_size_t fdoffset
= (*(ptr
+1) + 1) * (os_vm_page_size
);
498 page_index_t offset
= 0;
502 lseek(fd
, fdoffset
+ file_offset
, SEEK_SET
);
503 while ((bytes_read
= read(fd
, data
, (size
< 4096 ? size
: 4096 )))
509 bytes_read
-= sizeof(word_t
);
510 /* Ignore all zeroes. The size of the page table
511 * core entry was rounded up to os_vm_page_size
512 * during the save, and might now have more
513 * elements than the page table.
515 * The low bits of each word are allocation flags.
517 if ((word
=data
[i
])) {
518 page_table
[offset
].region_start_offset
= word
& ~0x03;
519 page_table
[offset
].allocated
= word
& 0x03;
526 gencgc_partial_pickup
= 1;
531 lose("unknown core file entry: 0x%"WORD_FMTX
"\n", val
);
534 ptr
+= remaining_len
;
535 FSHOW((stderr
, "/new ptr=0x%"WORD_FMTX
"\n", ptr
));
537 SHOW("about to free(header)");
539 SHOW("returning from load_core_file(..)");
540 return initial_function
;