X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fsave.lisp;h=c6ec320895f0b23d568dd2239e6b09fc5825e92b;hb=3f3033a6c0ddf0af8dd1b5a17c2a4b82ea59b94f;hp=4aa940a8a7c6f1844cd8d8e35a2f1997a3b76db4;hpb=04ee798422795a1e3d664c257a6b02b833eec4c6;p=sbcl.git diff --git a/src/code/save.lisp b/src/code/save.lisp index 4aa940a..c6ec320 100644 --- a/src/code/save.lisp +++ b/src/code/save.lisp @@ -20,22 +20,30 @@ (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)) #!+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)) #!+gencgc (defvar sb!vm::*restart-lisp-function*) (defun save-lisp-and-die (core-file-name &key (toplevel #'toplevel-init) + (executable nil) + (save-runtime-options nil) (purify t) (root-structures ()) (environment-name "auxiliary") - (executable nil)) + (compression nil)) #!+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. @@ -46,13 +54,22 @@ The following &KEY arguments are defined: :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:QUIT :UNIX-STATUS 0) being called. :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 @@ -73,6 +90,13 @@ The following &KEY arguments are defined: 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). + The save/load process changes the values of some global variables: *STANDARD-OUTPUT*, *DEBUG-IO*, etc. @@ -83,12 +107,8 @@ The save/load process changes the values of some global variables: 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 @@ -108,6 +128,13 @@ 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 @@ -117,20 +144,32 @@ sufficiently motivated to do lengthy fixes." (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))) + (without-gcing + (save name + (get-lisp-obj-address #'restart-lisp) + (foreign-bool executable) + (foreign-bool save-runtime-options) + (foreign-bool compression) + (or compression 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 @@ -144,18 +183,20 @@ sufficiently motivated to do lengthy fixes." ;; 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*) (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))