#include <unistd.h>
#include "sbcl.h"
+
+#ifndef LISP_FEATURE_WIN32
+#ifdef LISP_FEATURE_LINUX
+/* For madvise */
+# define _BSD_SOURCE
+#endif
+#include <sys/mman.h>
+#endif
+
#include "os.h"
#include "runtime.h"
#include "globals.h"
#include "validate.h"
#include "gc-internal.h"
-/* lutex stuff */
-#if defined(LISP_FEATURE_SB_THREAD) && defined(LISP_FEATURE_SB_LUTEX)
-#include "genesis/sap.h"
-#include "pthread-lutex.h"
-#endif
+#include <errno.h>
+#ifdef LISP_FEATURE_SB_CORE_COMPRESSION
+# include <zlib.h>
+#endif
unsigned char build_id[] =
#include "../../output/build-id.tmp"
lseek(fd, -end_offset, SEEK_END);
- if (new_runtime_options = read_runtime_options(fd)) {
+ if ((new_runtime_options = read_runtime_options(fd))) {
runtime_options = new_runtime_options;
}
}
if ((fd = open_binary(filename, O_RDONLY)) < 0)
goto lose;
+
+ if (read(fd, &header, (size_t)lispobj_size) < lispobj_size)
+ goto lose;
+ if (header == CORE_MAGIC) {
+ /* This file is a real core, not an embedded core. Return 0 to
+ * indicate where the core starts, and do not look for runtime
+ * options in this case. */
+ return 0;
+ }
+
if (lseek(fd, -lispobj_size, SEEK_END) < 0)
goto lose;
if (read(fd, &header, (size_t)lispobj_size) < lispobj_size)
}
#endif
+#ifdef LISP_FEATURE_SB_CORE_COMPRESSION
+# define ZLIB_BUFFER_SIZE (1u<<16)
+os_vm_address_t inflate_core_bytes(int fd, os_vm_offset_t offset,
+ os_vm_address_t addr, int len)
+{
+ z_stream stream;
+ unsigned char buf[ZLIB_BUFFER_SIZE];
+ int ret;
+
+ if (-1 == lseek(fd, offset, SEEK_SET)) {
+ lose("Unable to lseek() on corefile\n");
+ }
+
+ stream.zalloc = NULL;
+ stream.zfree = NULL;
+ stream.opaque = NULL;
+ stream.avail_in = 0;
+ stream.next_in = buf;
+
+ ret = inflateInit(&stream);
+ if (ret != Z_OK)
+ lose("zlib error %i\n", ret);
+
+ stream.next_out = (void*)addr;
+ stream.avail_out = len;
+ do {
+ ssize_t count = read(fd, buf, sizeof(buf));
+ if (count < 0)
+ lose("unable to read core file (errno = %i)\n", errno);
+ stream.next_in = buf;
+ stream.avail_in = count;
+ if (count == 0) break;
+ ret = inflate(&stream, Z_NO_FLUSH);
+ switch (ret) {
+ case Z_STREAM_END:
+ break;
+ case Z_OK:
+ if (stream.avail_out == 0)
+ lose("Runaway gzipped core directory... aborting\n");
+ if (stream.avail_in > 0)
+ lose("zlib inflate returned without fully"
+ "using up input buffer... aborting\n");
+ break;
+ default:
+ lose("zlib inflate error: %i\n", ret);
+ break;
+ }
+ } while (ret != Z_STREAM_END);
+
+ if (stream.avail_out > 0) {
+ if (stream.avail_out >= os_vm_page_size)
+ fprintf(stderr, "Warning: gzipped core directory significantly"
+ "shorter than expected (%lu bytes)", (unsigned long)stream.avail_out);
+ /* Is this needed? */
+ memset(stream.next_out, 0, stream.avail_out);
+ }
+
+ inflateEnd(&stream);
+ return addr;
+}
+# undef ZLIB_BUFFER_SIZE
+#endif
+
+int merge_core_pages = -1;
+
static void
process_directory(int fd, lispobj *ptr, int count, os_vm_offset_t file_offset)
{
struct ndir_entry *entry;
+ int compressed;
FSHOW((stderr, "/process_directory(..), count=%d\n", count));
for (entry = (struct ndir_entry *) ptr; --count>= 0; ++entry) {
-
+ compressed = 0;
long id = entry->identifier;
+ if (id <= (MAX_CORE_SPACE_ID | DEFLATED_CORE_SPACE_ID_FLAG)) {
+ if (id & DEFLATED_CORE_SPACE_ID_FLAG)
+ compressed = 1;
+ id &= ~(DEFLATED_CORE_SPACE_ID_FLAG);
+ }
long offset = os_vm_page_size * (1 + entry->data_page);
os_vm_address_t addr =
(os_vm_address_t) (os_vm_page_size * entry->address);
os_vm_address_t real_addr;
FSHOW((stderr, "/mapping %ld(0x%lx) bytes at 0x%lx\n",
(long)len, (long)len, (unsigned long)addr));
+ if (compressed) {
+#ifdef LISP_FEATURE_SB_CORE_COMPRESSION
+ real_addr = inflate_core_bytes(fd, offset + file_offset, addr, len);
+#else
+ lose("This runtime was not built with zlib-compressed core support... aborting\n");
+#endif
+ } else {
#ifdef LISP_FEATURE_HPUX
- real_addr = copy_core_bytes(fd, offset + file_offset, addr, len);
+ real_addr = copy_core_bytes(fd, offset + file_offset, addr, len);
#else
- real_addr = os_map(fd, offset + file_offset, addr, len);
+ real_addr = os_map(fd, offset + file_offset, addr, len);
#endif
+ }
if (real_addr != addr) {
lose("file mapped in wrong place! "
"(0x%08x != 0x%08lx)\n",
}
}
+#ifdef MADV_MERGEABLE
+ if ((merge_core_pages == 1)
+ || ((merge_core_pages == -1) && compressed)) {
+ madvise(addr, len, MADV_MERGEABLE);
+ }
+#endif
+
FSHOW((stderr, "/space id = %ld, free pointer = 0x%lx\n",
id, (unsigned long)free_pointer));
initial_function = (lispobj)*ptr;
break;
-#if defined(LISP_FEATURE_SB_THREAD) && defined(LISP_FEATURE_SB_LUTEX)
- case LUTEX_TABLE_CORE_ENTRY_TYPE_CODE:
- SHOW("LUTEX_TABLE_CORE_ENTRY_TYPE_CODE case");
- {
- size_t n_lutexes = *ptr;
- size_t fdoffset = (*(ptr + 1) + 1) * (os_vm_page_size);
- size_t data_length = n_lutexes * sizeof(struct sap *);
- struct lutex **lutexes_to_resurrect = malloc(data_length);
- long bytes_read;
-
- lseek(fd, fdoffset + file_offset, SEEK_SET);
-
- FSHOW((stderr, "attempting to read %ld lutexes from core\n", n_lutexes));
- bytes_read = read(fd, lutexes_to_resurrect, data_length);
-
- /* XXX */
- if (bytes_read != data_length) {
- lose("Could not read the lutex table");
- }
- else {
- int i;
-
- for (i=0; i<n_lutexes; ++i) {
- struct lutex *lutex = lutexes_to_resurrect[i];
-
- FSHOW((stderr, "re-init'ing lutex @ %p\n", lutex));
- lutex_init((tagged_lutex_t) lutex);
- }
-
- free(lutexes_to_resurrect);
- }
- break;
- }
-#endif
-
#ifdef LISP_FEATURE_GENCGC
case PAGE_TABLE_CORE_ENTRY_TYPE_CODE:
{
size_t offset = 0;
long bytes_read;
unsigned long data[4096];
+ unsigned long word;
lseek(fd, fdoffset + file_offset, SEEK_SET);
while ((bytes_read = read(fd, data, (size < 4096 ? size : 4096 )))
> 0)
* core entry was rounded up to os_vm_page_size
* during the save, and might now have more
* elements than the page table.
+ *
+ * The low bits of each word are allocation flags.
*/
- if (data[i]) {
- page_table[offset].region_start_offset = data[i];
+ if (word=data[i]) {
+ page_table[offset].region_start_offset = word & ~0x03;
+ page_table[offset].allocated = word & 0x03;
}
i++;
offset++;