(define-alien-routine "save" (boolean)
(file c-string)
(initial-fun (unsigned #.sb!vm:n-word-bits))
- (prepend-runtime int))
+ (prepend-runtime int)
+ (save-runtime-options int)
+ (compressed int)
+ (compression-level int)
+ (application-type int))
#!+gencgc
(define-alien-routine "gc_and_save" void
(file c-string)
- (prepend-runtime int))
+ (prepend-runtime int)
+ (save-runtime-options int)
+ (compressed int)
+ (compression-level int)
+ (application-type int))
#!+gencgc
(defvar sb!vm::*restart-lisp-function*)
(defun save-lisp-and-die (core-file-name &key
(toplevel #'toplevel-init)
- (purify #!+gencgc nil
- #!-gencgc t)
+ (executable nil)
+ (save-runtime-options nil)
+ (purify t)
(root-structures ())
(environment-name "auxiliary")
- (executable nil))
+ (compression nil)
+ #!+win32
+ (application-type :console))
#!+sb-doc
"Save a \"core image\", i.e. enough information to restart a Lisp
process later in the same state, in the file of the specified name.
:TOPLEVEL
The function to run when the created core file is resumed. The
default function handles command line toplevel option processing
- and runs the top level read-eval-print loop. This function should
- not return.
+ and runs the top level read-eval-print loop. This function returning
+ is equivalent to (SB-EXT:EXIT :CODE 0) being called.
+
+ TOPLEVEL functions should always provide an ABORT restart: otherwise
+ code they call will run without one.
:EXECUTABLE
If true, arrange to combine the SBCL runtime and the core image
to create a standalone executable. If false (the default), the
- core image will not be executable on its own.
+ core image will not be executable on its own. Executable images
+ always behave as if they were passed the --noinform runtime option.
+
+ :SAVE-RUNTIME-OPTIONS
+ If true, values of runtime options --dynamic-space-size and
+ --control-stack-size that were used to start SBCL are stored in
+ the standalone executable, and restored when the executable is
+ run. This also inhibits normal runtime option processing, causing
+ all command line arguments to be passed to the toplevel.
+ Meaningless if :EXECUTABLE is NIL.
:PURIFY
If true (the default on cheneygc), do a purifying GC which moves all
somewhat longer than the normal GC which is otherwise done, but
it's only done once, and subsequent GC's will be done less often
and will take less time in the resulting core file. See the PURIFY
- function. For platforms that use the generational garbage collector
- (x86 and x86-64) purification generally results in a loss of
- performance.
+ function. This parameter has no effect on platforms using the
+ generational garbage collector.
:ROOT-STRUCTURES
This should be a list of the main entry points in any newly loaded
This is also passed to the PURIFY function when :PURIFY is T.
(rarely used)
+ :COMPRESSION
+ This is only meaningful if the runtime was built with the :SB-CORE-COMPRESSION
+ feature enabled. If NIL (the default), saves to uncompressed core files. If
+ :SB-CORE-COMPRESSION was enabled at build-time, the argument may also be
+ an integer from -1 to 9, corresponding to zlib compression levels, or T
+ (which is equivalent to the default compression level, -1).
+
+ :APPLICATION-TYPE
+ Present only on Windows and is meaningful only with :EXECUTABLE T.
+ Specifies the subsystem of the executable, :CONSOLE or :GUI.
+ The notable difference is that :GUI doesn't automatically create a console
+ window. The default is :CONSOLE.
+
The save/load process changes the values of some global variables:
*STANDARD-OUTPUT*, *DEBUG-IO*, etc.
This is reinitialized to reflect the working directory where the
saved core is loaded.
-Foreign objects loaded with SB-ALIEN:LOAD-SHARED-OBJECT are automatically
-reloaded on startup, but references to foreign symbols do not survive intact
-on all platforms: in this case a WARNING is signalled when saving the core. If
-no warning is signalled, then the foreign symbol references will remain
-intact. Platforms where this is currently the case are x86/FreeBSD, x86/Linux,
-x86/NetBSD, sparc/Linux, sparc/SunOS, and ppc/Darwin.
+SAVE-LISP-AND-DIE interacts with SB-ALIEN:LOAD-SHARED-OBJECT: see its
+documentation for details.
On threaded platforms only a single thread may remain running after
SB-EXT:*SAVE-HOOKS* have run. Applications using multiple threads can
This isn't because we like it this way, but just because there don't
seem to be good quick fixes for either limitation and no one has been
sufficiently motivated to do lengthy fixes."
+ #!+gencgc
+ (declare (ignore purify root-structures environment-name))
+ #!+sb-core-compression
+ (check-type compression (or boolean (integer -1 9)))
+ #!-sb-core-compression
+ (when compression
+ (error "Unable to save compressed core: this runtime was not built with zlib support"))
+ (when (eql t compression)
+ (setf compression -1))
+ (tune-hashtable-sizes-of-all-packages)
(deinit)
;; FIXME: Would it be possible to unmix the PURIFY logic from this
;; function, and just do a GC :FULL T here? (Then if the user wanted
(labels ((restart-lisp ()
(handling-end-of-the-world
(reinit)
+ #!+hpux (sb!sys:%primitive sb!vm::setup-return-from-lisp-stub)
(funcall toplevel)))
+ (foreign-bool (value)
+ (if value 1 0))
(save-core (gc)
- (when gc
- #!-gencgc (gc)
- ;; Do a destructive non-conservative GC, and then save a core.
- ;; A normal GC will leave huge amounts of storage unreclaimed
- ;; (over 50% on x86). This needs to be done by a single function
- ;; since the GC will invalidate the stack.
- #!+gencgc (gc-and-save (unix-namestring core-file-name nil)
- (if executable 1 0)))
- (without-gcing
- (save (unix-namestring core-file-name nil)
- (get-lisp-obj-address #'restart-lisp)
- (if executable 1 0)))))
+ (let ((name (native-namestring
+ (physicalize-pathname core-file-name)
+ :as-file t)))
+ (when gc
+ #!-gencgc (gc)
+ ;; Do a destructive non-conservative GC, and then save a core.
+ ;; A normal GC will leave huge amounts of storage unreclaimed
+ ;; (over 50% on x86). This needs to be done by a single function
+ ;; since the GC will invalidate the stack.
+ #!+gencgc (gc-and-save name
+ (foreign-bool executable)
+ (foreign-bool save-runtime-options)
+ (foreign-bool compression)
+ (or compression 0)
+ #!+win32
+ (ecase application-type
+ (:console 0)
+ (:gui 1))
+ #!-win32 0))
+ (without-gcing
+ (save name
+ (get-lisp-obj-address #'restart-lisp)
+ (foreign-bool executable)
+ (foreign-bool save-runtime-options)
+ (foreign-bool compression)
+ (or compression 0)
+ #!+win32
+ (ecase application-type
+ (:console 0)
+ (:gui 1))
+ #!-win32 0)))))
;; Save the restart function into a static symbol, to allow GC-AND-SAVE
;; access to it even after the GC has moved it.
#!+gencgc
(setf sb!vm::*restart-lisp-function* #'restart-lisp)
- (cond (purify
+ (cond #!-gencgc
+ (purify
(purify :root-structures root-structures
:environment-name environment-name)
(save-core nil))
;; Compact the environment even though we're skipping the
;; other purification stages.
(sb!kernel::compact-environment-aux "Auxiliary" 200)
- (save-core t)))))
+ (save-core t)))
+ ;; Something went very wrong -- reinitialize to have a prayer
+ ;; of being able to report the error.
+ (reinit)
+ (error "Could not save core.")))
(defun deinit ()
- (dolist (hook *save-hooks*)
- (with-simple-restart (continue "Skip this save hook.")
- (funcall hook)))
+ (call-hooks "save" *save-hooks*)
+ #!+sb-wtimer
+ (itimer-emulation-deinit)
(when (rest (sb!thread:list-all-threads))
(error "Cannot save core with multiple threads running."))
- #!-win32
- (when (fboundp 'cancel-finalization)
- (cancel-finalization sb!sys:*tty*))
(float-deinit)
(profile-deinit)
- (debug-deinit)
- (foreign-deinit))
+ (foreign-deinit)
+ (stream-deinit)
+ (deinit-finalizers)
+ (drop-all-hash-caches))
projects / sbcl.git / blobdiff