X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fsave.c;h=f6742c3d65a0110880eb7273b66625f201b513d5;hb=6769a6cdb368694f39f9c0e2b6790f45cf308b91;hp=4fd98e7c9f70ac7518b668bc42059ae57295466f;hpb=1b64697e4e8a85ff8f11f5c05de71687dc5ad2e2;p=sbcl.git diff --git a/src/runtime/save.c b/src/runtime/save.c index 4fd98e7..f6742c3 100644 --- a/src/runtime/save.c +++ b/src/runtime/save.c @@ -9,14 +9,19 @@ * files for more information. */ +#ifndef LISP_FEATURE_WIN32 +#include +#include +#endif #include #include +#include #include #include +#include "sbcl.h" #include "runtime.h" #include "os.h" -#include "sbcl.h" #include "core.h" #include "globals.h" #include "save.h" @@ -24,19 +29,36 @@ #include "lispregs.h" #include "validate.h" #include "gc-internal.h" +#include "thread.h" + +#include "genesis/static-symbols.h" +#include "genesis/symbol.h" + +static void +write_lispobj(lispobj obj, FILE *file) +{ + fwrite(&obj, sizeof(lispobj), 1, file); +} static long -write_bytes(FILE *file, char *addr, long bytes) +write_bytes(FILE *file, char *addr, long bytes, os_vm_offset_t file_offset) { long count, here, data; bytes = (bytes+os_vm_page_size-1)&~(os_vm_page_size-1); +#ifdef LISP_FEATURE_WIN32 + /* touch every single page in the space to force it to be mapped. */ + for (count = 0; count < bytes; count += 0x1000) { + volatile int temp = addr[count]; + } +#endif + fflush(file); here = ftell(file); - fseek(file, 0, 2); + fseek(file, 0, SEEK_END); data = (ftell(file)+os_vm_page_size-1)&~(os_vm_page_size-1); - fseek(file, data, 0); + fseek(file, data, SEEK_SET); while (bytes > 0) { count = fwrite(addr, 1, bytes, file); @@ -50,115 +72,280 @@ write_bytes(FILE *file, char *addr, long bytes) } } fflush(file); - fseek(file, here, 0); - return data/os_vm_page_size - 1; + fseek(file, here, SEEK_SET); + return ((data - file_offset) / os_vm_page_size) - 1; } static void -output_space(FILE *file, int id, lispobj *addr, lispobj *end) +output_space(FILE *file, int id, lispobj *addr, lispobj *end, os_vm_offset_t file_offset) { int words, bytes, data; static char *names[] = {NULL, "dynamic", "static", "read-only"}; - putw(id, file); + write_lispobj(id, file); words = end - addr; - putw(words, file); + write_lispobj(words, file); bytes = words * sizeof(lispobj); printf("writing %d bytes from the %s space at 0x%08lx\n", bytes, names[id], (unsigned long)addr); - data = write_bytes(file, (char *)addr, bytes); + data = write_bytes(file, (char *)addr, bytes, file_offset); - putw(data, file); - putw((long)addr / os_vm_page_size, file); - putw((bytes + os_vm_page_size - 1) / os_vm_page_size, file); + write_lispobj(data, file); + write_lispobj((long)addr / os_vm_page_size, file); + write_lispobj((bytes + os_vm_page_size - 1) / os_vm_page_size, file); } -boolean -save(char *filename, lispobj init_function) +FILE * +open_core_for_saving(char *filename) { - FILE *file; - /* Open the output file. We don't actually need the file yet, but * the fopen() might fail for some reason, and we want to detect * that and back out before we do anything irreversible. */ unlink(filename); - file = fopen(filename, "w"); - if (!file) { - perror(filename); - return 1; - } + return fopen(filename, "wb"); +} + +boolean +save_to_filehandle(FILE *file, char *filename, lispobj init_function, + boolean make_executable) +{ + struct thread *th; + os_vm_offset_t core_start_pos, core_end_pos, core_size; /* Smash the enclosing state. (Once we do this, there's no good * way to go back, which is a sufficient reason that this ends up * being SAVE-LISP-AND-DIE instead of SAVE-LISP-AND-GO-ON). */ printf("[undoing binding stack and other enclosing state... "); fflush(stdout); - unbind_to_here((lispobj *)BINDING_STACK_START); - SetSymbolValue(CURRENT_CATCH_BLOCK, 0); - SetSymbolValue(CURRENT_UNWIND_PROTECT_BLOCK, 0); + for_each_thread(th) { /* XXX really? */ + unbind_to_here((lispobj *)th->binding_stack_start,th); + SetSymbolValue(CURRENT_CATCH_BLOCK, 0,th); + SetSymbolValue(CURRENT_UNWIND_PROTECT_BLOCK, 0,th); + } printf("done]\n"); fflush(stdout); - - /* (Now we can actually start copying ourselves into the - * output file.) */ + + /* (Now we can actually start copying ourselves into the output file.) */ printf("[saving current Lisp image into %s:\n", filename); fflush(stdout); - putw(CORE_MAGIC, file); + core_start_pos = ftell(file); + write_lispobj(CORE_MAGIC, file); - putw(VERSION_CORE_ENTRY_TYPE_CODE, file); - putw(3, file); - putw(SBCL_CORE_VERSION_INTEGER, file); + write_lispobj(VERSION_CORE_ENTRY_TYPE_CODE, file); + write_lispobj(3, file); + write_lispobj(SBCL_CORE_VERSION_INTEGER, file); - putw(NEW_DIRECTORY_CORE_ENTRY_TYPE_CODE, file); - putw((5*3)+2, file); + write_lispobj(BUILD_ID_CORE_ENTRY_TYPE_CODE, file); + write_lispobj(/* (We're writing the word count of the entry here, and the 2 + * term is one word for the leading BUILD_ID_CORE_ENTRY_TYPE_CODE + * word and one word where we store the count itself.) */ + 2 + strlen((const char *)build_id), + file); + { + unsigned char *p; + for (p = build_id; *p; ++p) + write_lispobj(*p, file); + } + write_lispobj(NEW_DIRECTORY_CORE_ENTRY_TYPE_CODE, file); + write_lispobj(/* (word count = 3 spaces described by 5 words each, plus the + * entry type code, plus this count itself) */ + (5*3)+2, file); output_space(file, - READ_ONLY_CORE_SPACE_ID, - (lispobj *)READ_ONLY_SPACE_START, - (lispobj *)SymbolValue(READ_ONLY_SPACE_FREE_POINTER)); + READ_ONLY_CORE_SPACE_ID, + (lispobj *)READ_ONLY_SPACE_START, + (lispobj *)SymbolValue(READ_ONLY_SPACE_FREE_POINTER,0), + core_start_pos); output_space(file, - STATIC_CORE_SPACE_ID, - (lispobj *)STATIC_SPACE_START, - (lispobj *)SymbolValue(STATIC_SPACE_FREE_POINTER)); + STATIC_CORE_SPACE_ID, + (lispobj *)STATIC_SPACE_START, + (lispobj *)SymbolValue(STATIC_SPACE_FREE_POINTER,0), + core_start_pos); +#ifdef LISP_FEATURE_GENCGC + /* Flush the current_region, updating the tables. */ + gc_alloc_update_all_page_tables(); + update_dynamic_space_free_pointer(); +#endif #ifdef reg_ALLOC +#ifdef LISP_FEATURE_GENCGC output_space(file, - DYNAMIC_CORE_SPACE_ID, - (lispobj *)current_dynamic_space, - dynamic_space_free_pointer); + DYNAMIC_CORE_SPACE_ID, + (lispobj *)DYNAMIC_SPACE_START, + dynamic_space_free_pointer, + core_start_pos); #else -#ifdef LISP_FEATURE_GENCGC - /* I don't know too much about the circumstances in which we could - * end up here. It may be that current_region_free_pointer is - * guaranteed to be relevant and we could skip these slightly - * paranoid checks. TRT would be to rid the code of - * current_region_foo completely - dan 2002.09.17 */ - if((boxed_region.free_pointer < current_region_free_pointer) && - (boxed_region.end_addr == current_region_end_addr)) - boxed_region.free_pointer = current_region_free_pointer; - /* Flush the current_region, updating the tables. */ - gc_alloc_update_page_tables(0,&boxed_region); - gc_alloc_update_page_tables(1,&unboxed_region); - update_x86_dynamic_space_free_pointer(); + output_space(file, + DYNAMIC_CORE_SPACE_ID, + (lispobj *)current_dynamic_space, + dynamic_space_free_pointer, + core_start_pos); #endif +#else output_space(file, - DYNAMIC_CORE_SPACE_ID, - (lispobj *)DYNAMIC_SPACE_START, - (lispobj *)SymbolValue(ALLOCATION_POINTER)); + DYNAMIC_CORE_SPACE_ID, + (lispobj *)DYNAMIC_SPACE_START, + (lispobj *)SymbolValue(ALLOCATION_POINTER,0), + core_start_pos); #endif - putw(INITIAL_FUN_CORE_ENTRY_TYPE_CODE, file); - putw(3, file); - putw(init_function, file); + write_lispobj(INITIAL_FUN_CORE_ENTRY_TYPE_CODE, file); + write_lispobj(3, file); + write_lispobj(init_function, file); - putw(END_CORE_ENTRY_TYPE_CODE, file); +#ifdef LISP_FEATURE_GENCGC + { + size_t size = (last_free_page*sizeof(long)+os_vm_page_size-1) + &~(os_vm_page_size-1); + long *data = calloc(size, 1); + if (data) { + long offset; + int i; + for (i = 0; i < last_free_page; i++) { + data[i] = page_table[i].first_object_offset; + } + write_lispobj(PAGE_TABLE_CORE_ENTRY_TYPE_CODE, file); + write_lispobj(4, file); + write_lispobj(size, file); + offset = write_bytes(file, (char *) data, size, core_start_pos); + write_lispobj(offset, file); + } + } +#endif + + write_lispobj(END_CORE_ENTRY_TYPE_CODE, file); + /* Write a trailing header, ignored when parsing the core normally. + * This is used to locate the start of the core when the runtime is + * prepended to it. */ + fseek(file, 0, SEEK_END); + core_end_pos = ftell(file); + core_size = core_end_pos - core_start_pos; + + fwrite(&core_size, sizeof(os_vm_offset_t), 1, file); + write_lispobj(CORE_MAGIC, file); fclose(file); - printf("done]\n"); +#ifndef LISP_FEATURE_WIN32 + if (make_executable) + chmod (filename, 0755); +#endif + + printf("done]\n"); exit(0); } + +/* Slurp the executable portion of the runtime into a malloced buffer + * and return it. Places the size in bytes of the runtime into + * 'size_out'. Returns NULL if the runtime cannot be loaded from + * 'runtime_path'. */ +void * +load_runtime(char *runtime_path, size_t *size_out) +{ + void *buf = NULL; + FILE *input = NULL; + size_t size, count; + os_vm_offset_t core_offset; + + core_offset = search_for_embedded_core (runtime_path); + if ((input = fopen(runtime_path, "rb")) == NULL) { + fprintf(stderr, "Unable to open runtime: %s\n", runtime_path); + goto lose; + } + + fseek(input, 0, SEEK_END); + size = (size_t) ftell(input); + fseek(input, 0, SEEK_SET); + + if (core_offset != -1 && size > core_offset) + size = core_offset; + + buf = successful_malloc(size); + if ((count = fread(buf, 1, size, input)) != size) { + fprintf(stderr, "Premature EOF while reading runtime.\n"); + goto lose; + } + + fclose(input); + *size_out = size; + return buf; + +lose: + if (input != NULL) + fclose(input); + if (buf != NULL) + free(buf); + return NULL; +} + +boolean +save_runtime_to_filehandle(FILE *output, void *runtime, size_t runtime_size) +{ + size_t padding; + void *padbytes; + + fwrite(runtime, 1, runtime_size, output); + + padding = (os_vm_page_size - (runtime_size % os_vm_page_size)) & ~os_vm_page_size; + if (padding > 0) { + padbytes = successful_malloc(padding); + memset(padbytes, 0, padding); + fwrite(padbytes, 1, padding, output); + free(padbytes); + } + + return 1; +} + +FILE * +prepare_to_save(char *filename, boolean prepend_runtime, void **runtime_bytes, + size_t *runtime_size) +{ + FILE *file; + char *runtime_path; + + if (prepend_runtime) { + runtime_path = os_get_runtime_executable_path(); + + if (runtime_path == NULL) { + fprintf(stderr, "Unable to get default runtime path.\n"); + return NULL; + } + + *runtime_bytes = load_runtime(runtime_path, runtime_size); + free(runtime_path); + + if (*runtime_bytes == NULL) + return 0; + } + + file = open_core_for_saving(filename); + if (file == NULL) { + free(*runtime_bytes); + perror(filename); + return NULL; + } + + return file; +} + +boolean +save(char *filename, lispobj init_function, boolean prepend_runtime) +{ + FILE *file; + void *runtime_bytes = NULL; + size_t runtime_size; + + file = prepare_to_save(filename, prepend_runtime, &runtime_bytes, &runtime_size); + if (file == NULL) + return 1; + + if (prepend_runtime) + save_runtime_to_filehandle(file, runtime_bytes, runtime_size); + + return save_to_filehandle(file, filename, init_function, prepend_runtime); +}