1.0.41.22: runtime: Rename backtrace() to lisp_backtrace().

[sbcl.git] / src / runtime / coreparse.c

diff --git a/src/runtime/coreparse.c b/src/runtime/coreparse.c
index 5fd590e..1757444 100644 (file)
--- a/src/runtime/coreparse.c
+++ b/src/runtime/coreparse.c
@@ -83,12 +83,16 @@ read_runtime_options(int fd)
 void
 maybe_initialize_runtime_options(int fd)
 {
+    struct runtime_options *new_runtime_options;
     off_t end_offset = sizeof(lispobj) +
         sizeof(os_vm_offset_t) +
         (RUNTIME_OPTIONS_WORDS * sizeof(size_t));
 
     lseek(fd, -end_offset, SEEK_END);
-    runtime_options = read_runtime_options(fd);
+
+    if (new_runtime_options = read_runtime_options(fd)) {
+        runtime_options = new_runtime_options;
+    }
 }
 
 /* Search 'filename' for an embedded core.  An SBCL core has, at the
@@ -145,6 +149,41 @@ lose:
     return -1;
 }
 
+/* If more platforms doesn't support overlapping mmap rename this
+ * def to something like ifdef nommapoverlap */
+/* currently hpux only */
+#ifdef LISP_FEATURE_HPUX
+os_vm_address_t copy_core_bytes(int fd, os_vm_offset_t offset,
+                                os_vm_address_t addr, int len)
+{
+  unsigned char buf[4096];
+  int c,x;
+  int old_fd = lseek(fd, 0, SEEK_CUR);
+
+  if(len & (4096-1)){
+    fprintf(stderr, "cant copy a slice of core because slice-length is not of page size(4096)\n");
+    exit(-1);
+  }
+  if(old_fd < 0){
+    fprintf(stderr, "cant perform lseek() on corefile\n");
+  }
+  lseek(fd, offset, SEEK_SET);
+  if(fd < 0){
+    fprintf(stderr, "cant perform lseek(%u,%lu,SEEK_SET) on corefile\n", fd, offset);
+  }
+  for(x = 0; x < len; x += 4096){
+    c = read(fd, buf, 4096);
+    if(c != 4096){
+      fprintf(stderr, "cant read memory area from corefile at position %lu, got %d\n", offset + x, c);
+      exit(-1);
+    }
+    memcpy(addr+x, buf, 4096);
+  }
+  os_flush_icache(addr, len);
+  return addr;
+}
+#endif
+
 static void
 process_directory(int fd, lispobj *ptr, int count, os_vm_offset_t file_offset)
 {
@@ -160,12 +199,15 @@ process_directory(int fd, lispobj *ptr, int count, os_vm_offset_t file_offset)
             (os_vm_address_t) (os_vm_page_size * entry->address);
         lispobj *free_pointer = (lispobj *) addr + entry->nwords;
         unsigned long len = os_vm_page_size * entry->page_count;
-
         if (len != 0) {
             os_vm_address_t real_addr;
             FSHOW((stderr, "/mapping %ld(0x%lx) bytes at 0x%lx\n",
                    (long)len, (long)len, (unsigned long)addr));
+#ifdef LISP_FEATURE_HPUX
+            real_addr = copy_core_bytes(fd, offset + file_offset, addr, len);
+#else
             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",
@@ -381,6 +423,7 @@ load_core_file(char *file, os_vm_offset_t file_offset)
             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)
@@ -393,9 +436,12 @@ load_core_file(char *file, os_vm_offset_t file_offset)
                      * 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++;