home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-387-Vol-3of3.iso / p / plbin.zip / pl / src / pl-save.c < prev    next >
C/C++ Source or Header  |  1993-03-04  |  17KB  |  605 lines
  1. /*  pl-save.c,v 1.11 1993/02/23 13:16:45 jan Exp
  2.  
  3.     Copyright (c) 1991 Jan Wielemaker. All rights reserved.
  4.     See ../LICENCE to find out about your rights.
  5.     jan@swi.psy.uva.nl
  6.  
  7.     Purpose: Create saved state
  8. */
  9.  
  10. #include "pl-incl.h"
  11.  
  12. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  13. This file defines  a package to  create and restore  states of Prolog.
  14. Actually there is little  that makes it specific  to prolog.   Earlier
  15. versions of Prolog used the GNU unexec() code underlying gnu-emacs and
  16. undump.  Together with  dynamic  stack  allocation and loading foreign
  17. code, this used the be the main reason for Prolog not  to be portable.
  18. This package  is an  attempt  to  create  a reasonable   portable save
  19. functionality.
  20.  
  21.  
  22. HOW DOES IT WORK?
  23.  
  24. This program tries  to find all  parts of memory  that contains  valid
  25. information, except for the text-segment.  These sections are saved on
  26. file together with some administrative information.  Restoring a state
  27. implies memory areas are set-up equivalent to the state when the state
  28. is  saved; all the  sections are read back  in  place and  the  system
  29. performs a longjmp(), either to the start of the  program, or to where
  30. it was.
  31.  
  32.  
  33. ASSUMPTIONS
  34.  
  35.   1) We  assume  the running prolog image to  consists of a  `text' area
  36.   that   is read-only and in   any  run  of prolog   loaded  at the same
  37.   addresses.  This  will be  true  on almost any machine  using  virtual
  38.   memory (and (thus) no relocation).
  39.  
  40.   2) There is memory area  that holds the programs data  as well as  the
  41.   data belonging to malloc(), etc.   By default,  this is area  &environ
  42.   ... sbrk(0)
  43.  
  44.   3)  (for save/[1,2] only)  The C-stack  can be   reloaded at the  same
  45.   position.
  46.  
  47.   4) The program  knows  about possible other  memory areas.  When using
  48.   dynamic-stacks, the mapped areas are passed for save/[1,2].
  49.  
  50.  
  51. PORTABILITY/OPTIONS
  52.  
  53.   O_C_STACK_GROWS_UP
  54.     Each subsequent C-stackframe  is  at a  higher address.  Note that
  55.     addresses are considered unsigned.  By default we assume the stack
  56.     grows downwards.
  57.  
  58.   BASE_OF_C_STACK 
  59.     If your machine has a fixed address where the C-stack  starts, you
  60.     may #define BASE_OF_C_STACK to  this  address.  Normally using the
  61.     STACK_BASE_ALIGN   mechanism  is   a better   guarantee   you  are
  62.     independant of versions of the OS.
  63.  
  64.   STACK_BASE_ALIGN
  65.     If BASE_OF_C_STACK is  not defined,  we will round  the pointer to
  66.     argc  of main()  depending  on  O_C_STACK_GROWS_UP down/up  to   a
  67.     multiple of this value (default: 64 Kbytes).  This generally finds
  68.     the stack's base address.
  69. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  70.  
  71. #if OS2 && EMX
  72. /*                      Notes on the OS/2 port.
  73.             atoenne@mpi-sb.mpg.de
  74.  
  75.     The save/2 primitive had a rather unusual problem in OS/2. The save
  76.     function tries to write the memory between start of data and the
  77.     end of the heap as one huge chunk to disk. OS/2 however does not
  78.     allocate the junk area between the end of data and the start of
  79.     the heap. Consequently we get a protection violation with the original
  80.     save function. We have to write two sections, one for data and
  81.     one for the heap. These areas are determined as follows:
  82.  
  83.     data ranges from &_data to &_end
  84.     heap ranges from _heap_base to sbrk(0)
  85.  
  86.     The routines for determing the stack frame are fine.
  87.  
  88. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  89. #endif /* OS2 */
  90.  
  91. #if TEST
  92. #undef DEBUG
  93. #define DEBUG(l, g) {g;}
  94. #endif
  95.  
  96. #if O_SAVE
  97. #include <sys/types.h>
  98. #include <unistd.h>
  99. #include <stdio.h>
  100. #include <setjmp.h>
  101. #include <fcntl.h>
  102. #include "pl-save.h"
  103.  
  104. #if sun
  105. int    brk P((caddr_t));
  106. caddr_t sbrk P((int));
  107. #endif
  108. #if OS2 & EMX
  109. extern caddr _heap_base;
  110. extern long _heap_end;
  111. #endif /* OS2 */
  112.  
  113. extern char **environ;
  114.  
  115. #ifndef DATA_START
  116. #ifndef FIRST_DATA_SYMBOL
  117. #define FIRST_DATA_SYMBOL environ;
  118. #endif
  119. #define DATA_START &FIRST_DATA_SYMBOL
  120. #endif
  121.  
  122. #ifndef DATA_END
  123. #ifdef LAST_DATA_SYMBOL
  124. #define DATA_END ((caddr) &LAST_DATA_SYMBOL)
  125. #else
  126. #define DATA_END ((caddr) sbrk(0))
  127. #endif
  128. #endif
  129.  
  130. #ifdef  FIRST_DATA_SYMBOL
  131. extern  char **FIRST_DATA_SYMBOL;
  132. #endif
  133. #ifdef LAST_DATA_SYMBOL            /* --- atoenne@mpi-sb.mpg.de --- */
  134. extern  char **LAST_DATA_SYMBOL;
  135. #endif
  136.  
  137. #ifndef STACK_BASE_ALIGN
  138. #define STACK_BASE_ALIGN (1<<16)    /* 64K */
  139. #endif
  140. #define MAXSTACKFRAMESIZE 256    /* Should generally do ... */
  141. #define MAXLINE1    256    /* Maximum length of the ASCII header */
  142.  
  143. #define SAVE_MAGIC    3823212    /* Just a random number */
  144.  
  145. typedef struct save_header
  146. { long    magic;            /* Determine type of file */
  147.   long  save_version;        /* Version of the hosting process */
  148.   caddr brk;            /* Value of the break when saved */
  149.   int    nsections;        /* Number of sections available */
  150. } * SaveHeader;
  151.  
  152. #define exit(status)    Halt(status);
  153.  
  154. #define SectionOffset(n)    (sizeof(struct save_header) + \
  155.                  (n) * sizeof(struct save_section))
  156.  
  157. #define tryRead(fd, buf, n) \
  158.     if ( read(fd, buf, n) != n ) \
  159.         return warning("restore/1: read failed: %s", OsError())
  160. #define tryWrite(fd, buf, n) \
  161.     if ( write(fd, buf, n) != n ) \
  162.         return warning("save/1: write failed: %s", OsError())
  163. #define trySeek(fd, where) \
  164.     if ( lseek(fd, where, SEEK_SET) != where ) \
  165.         return warning("restore/1: seek failed: %s", OsError())
  166.  
  167.  
  168.         /********************************
  169.         *           VARIABLES        *
  170.         ********************************/
  171.  
  172. static long    save_version;    /* Magic code to verify same version */
  173. static jmp_buf ret_main_ctx;    /* Context of RET_MAIN */
  174. static jmp_buf ret_return_ctx;    /* Context of RET_RETURN */
  175. static caddr   c_stack_base;    /* Base address of C-stack */
  176.  
  177.  
  178.         /********************************
  179.         *          SAVE VERSION        *
  180.         ********************************/
  181.  
  182. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  183. This function  returns  a number depending on  the text-segment.   The
  184. text-segment should be  the same when  reloading a state.  This is not
  185. an ideal solution: it forces the entire text to be loaded.
  186. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  187.  
  188. static long
  189. saveVersion()
  190. { if ( save_version == 0 )
  191.   { long *start = (long *) saveVersion;
  192.     long *end    = (long *) startProlog;
  193.     int  step   = (end - start) / 500;
  194.     
  195.     DEBUG(1, printf("Computing saveVersion in 0x%x .. 0x%x\n", start, end));
  196.  
  197.     for(; start < end; start += step)
  198.       save_version ^= *start;
  199.   }
  200.  
  201.   DEBUG(1, printf("saveVersion = %ld\n", save_version));
  202.  
  203.   return save_version;
  204. }
  205.  
  206.  
  207.         /********************************
  208.         *              IO        *
  209.         ********************************/
  210.  
  211. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  212. The FILE related IO buffer  will be restored  in the same  state as it
  213. was  before the saved state  was created.  We want  to  read new input
  214. instead  of saved input   and therefore we   have to  clear  the input
  215. stream.  Currently this is done by setting the _cnt slot of  the stdio
  216. structure to 0.  This is not very portable.
  217.  
  218. Alternatives?   One  would be  to allocate  new  IO buffers, but then,
  219. assigning these to stdin is not very neat either.   I guess a macro is
  220. best ...
  221. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  222.  
  223. static void
  224. resetIO()
  225. { ResetTty();
  226. }
  227.  
  228.  
  229.         /********************************
  230.         *            C-STACK        *
  231.         ********************************/
  232.  
  233. static caddr
  234. topOfCStack()
  235. { int local;
  236.  
  237.   return (caddr) &local;
  238. }
  239.  
  240. static caddr
  241. baseOfCStack(argc, argv, env)
  242. int *argc;
  243. char **argv, **env;
  244. { 
  245. #ifdef BASE_OF_C_STACK
  246.   return (caddr) BASE_OF_C_STACK;
  247. #else
  248.  
  249.   ulong base = (ulong) &argc;
  250.   char **p;
  251.  
  252. #ifdef O_C_STACK_GROWS_UP
  253. #define BoundStack(a,b) ((a) < (b) ? (a) : (b))
  254. #else
  255. #define BoundStack(a,b) ((a) > (b) ? (a) : (b))
  256. #endif
  257.  
  258.   base = BoundStack(base, (ulong)argv);
  259.   for(p = argv; *p; p++)
  260.     base = BoundStack(base, (ulong)*p);
  261.   base = BoundStack(base, (ulong)env);
  262.   for(p = env; *p; p++)
  263.     base = BoundStack(base, (ulong)*p);
  264.  
  265. # if ( O_C_STACK_GROWS_UP )        /* round-down */
  266.   return (caddr) (base & ~(STACK_BASE_ALIGN-1));
  267. # else
  268.   return (caddr) ((base+STACK_BASE_ALIGN-1) & ~(STACK_BASE_ALIGN-1));
  269. # endif
  270. #endif
  271. }
  272.  
  273.  
  274. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  275. Read the C-stack back.  First of all, we must  try  to get out  of the
  276. region that  is  overwritten by  the  read.   We do  this   by calling
  277. ourselfves recursively until  we are  out.  We  take a  small security
  278. region: MAXSTACKFRAMESIZE.
  279.  
  280. Note, your  compiler  might  be smart  enough   to  use tail-recursion
  281. optimization on this function.  If so, you'll have to fool it or don't
  282. optimise this file.
  283. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  284.  
  285. static int
  286. readCStack(fd, start, length)
  287. int fd;
  288. caddr start;
  289. long length;
  290. { 
  291. #if O_C_STACK_GROWS_UP
  292.   if ( (ulong) &fd - MAXSTACKFRAMESIZE > (ulong) start )
  293. #else
  294.   if ( (ulong) &fd + MAXSTACKFRAMESIZE < (ulong) start )
  295. #endif
  296.   { DEBUG(1, printf("&fd = 0x%x\n", (unsigned) &fd));
  297.     tryRead(fd, start, length);
  298.     DEBUG(1, printf("C-stack read; starting longjmp\n"));
  299.     resetIO();
  300.     longjmp(ret_return_ctx, 1);
  301.   } else
  302.     return readCStack(fd, start, length);
  303. }
  304.  
  305.  
  306.         /********************************
  307.         *            RESTORE        *
  308.         ********************************/
  309.  
  310. #ifndef O_BINARY
  311. #define O_BINARY 0
  312. #endif
  313.  
  314. int
  315. restore(file, allocf)
  316. char *file;
  317. int (*allocf) P((SaveSection));
  318. { int fd;
  319.   char buf[MAXLINE1];
  320.   int n;
  321.   long header_offset = 0;
  322.   struct save_header header;
  323.   char *s;
  324.  
  325.   if ((fd = open(file, O_RDONLY|O_BINARY)) < 0)
  326.     return warning("restore/1: cannot open %s: %s", file, OsError());
  327.   tryRead(fd, buf, MAXLINE1);
  328.  
  329.   for(n = 0, s = buf; n++ < MAXLINE1; s++)
  330.   { if ( *s == EOS )
  331.     { header_offset = n;
  332.       break;
  333.     }
  334.   }
  335.   DEBUG(1, printf("header_offset = %d\n", header_offset));
  336.   if ( header_offset == 0 )
  337.     return warning("restore/1: %s is not a saved state", file);
  338.  
  339.   trySeek(fd, header_offset);
  340.   tryRead(fd, &header, sizeof(header));
  341.  
  342.   if ( header.magic != SAVE_MAGIC )
  343.     return warning("restore/1: %s is not a saved state", file);
  344.   if ( header.save_version != saveVersion() )
  345.     return warning("restore/1: %s has incompatible save version", file);
  346.   
  347.   if ( brk(header.brk) )
  348.     return warning("restore/1: failed to set the break: %s", OsError());
  349.  
  350.   { jmp_buf restore_ctx;    /* Will be destroyed */
  351.  
  352.     memcpy(restore_ctx, ret_main_ctx, sizeof(restore_ctx));
  353.  
  354.     for(n = 0; n < header.nsections; n++)
  355.     { struct save_section section_header;
  356.  
  357.       trySeek(fd, header_offset+SectionOffset(n));
  358.       tryRead(fd, §ion_header, sizeof(section_header));
  359.       DEBUG(1, printf("Restoring # %d (0x%x-0x%x) offset = %ld)\n",
  360.               n, (unsigned) section_header.start,
  361.               (unsigned) section_header.start + section_header.length,
  362.               header_offset+section_header.offset));
  363.       trySeek(fd, header_offset+section_header.offset);
  364.       if ( section_header.type == S_CSTACK )
  365.     readCStack(fd, section_header.start, section_header.length);
  366.       else 
  367.       { if ( allocf )
  368.       (*allocf)(§ion_header);
  369.     tryRead(fd, section_header.start, section_header.length);
  370.       }
  371.     }
  372.  
  373.     memcpy(ret_main_ctx, restore_ctx, sizeof(restore_ctx));
  374.  
  375.     resetIO();
  376.     longjmp(ret_main_ctx, 1);
  377.     /*NOTREACHED*/
  378.   }
  379. }
  380.  
  381.         /********************************
  382.         *            SAVE        *
  383.         ********************************/
  384.  
  385. #ifdef HEAP_START
  386. #define C_DATA_SECTIONS 2        /* heap separate from data  */
  387. #else
  388. #define C_DATA_SECTIONS 1
  389. #endif
  390.  
  391. int
  392. save(file, interpreter, kind, nsections, sections)
  393. char *file;
  394. char *interpreter;
  395. int kind;            /* RET_RETURN; RET_MAIN */
  396. int nsections;            /* additional sections */
  397. SaveSection sections;
  398. { int fd;
  399.   struct save_section sects[MAX_SAVE_SECTIONS];
  400.   char buf[MAXLINE1];
  401.   long header_offset;
  402.   volatile long section_offset;        /* volatile to keep gcc happy */
  403.   struct save_header header;
  404.   int nsects = nsections + C_DATA_SECTIONS;
  405.   int sects_size;
  406.   int n;
  407.   SaveSection sect;
  408.  
  409.   if ( kind == RET_RETURN )
  410.     nsects++;                /* C-stack section  */
  411.   sects_size = sizeof(struct save_section) * nsects;
  412.  
  413.   if ( (fd = open(file, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0777)) < 0 )
  414.     return warning("save/1: cannot write %s: %s\n", file, OsError());
  415.   
  416. #if OS2
  417.   sprintf(buf, "/* Self-starting SWI-Prolog state */\r\n'@ECHO OFF'\r\nparse source . . name\r\n\"%s -r \" name arg(1)\r\nexit\r\n\032", OsPath(interpreter));
  418. #else
  419.   sprintf(buf, "#!/bin/sh\nexec %s -r $0 $*\n", OsPath(interpreter));
  420. #endif
  421.   header_offset = strlen(buf) + 1; /* +1 to write the EOS too */
  422.   DEBUG(1, printf("header_offset = %d\n", header_offset));
  423.   tryWrite(fd, buf, header_offset);
  424.  
  425.   header.magic         = SAVE_MAGIC;
  426.   header.save_version   = saveVersion();
  427.   header.brk        = sbrk(0);
  428.   header.nsections    = nsects;
  429.     
  430.   section_offset = sizeof(header) + sects_size;
  431.  
  432.   sects[0].start    = (caddr) DATA_START;
  433.   sects[0].length    = (long) DATA_END - (long) sects[0].start;
  434.   sects[0].type        = S_DATA;
  435.   sects[0].flags    = 0;
  436. #ifdef HEAP_START
  437.   sects[1].start        = HEAP_START;
  438.   sects[1].length       = (long) sbrk(0) - (long) sects[1].start;
  439.   sects[1].type         = S_DATA;
  440.   sects[1].flags        = 0;
  441. #endif /* HEAP_START */
  442.  
  443.   memcpy(§s[C_DATA_SECTIONS], sections,
  444.      nsections * sizeof(struct save_section));
  445.  
  446.   if ( kind == RET_RETURN )
  447.   { SaveSection stack_sect = §s[nsections+C_DATA_SECTIONS];
  448.  
  449.     if ( setjmp(ret_return_ctx) )
  450.     { DEBUG(1, printf("Yipie, returning from state\n"));
  451.       return SAVE_RESTORE;
  452.     } 
  453.     
  454. #if O_C_STACK_GROWS_UP
  455.     stack_sect->start  = c_stack_base;
  456.     stack_sect->length = (ulong) topOfCStack() - (ulong) stack_sect->start;
  457. #else
  458.     stack_sect->start  = topOfCStack();
  459.     stack_sect->length = (ulong) c_stack_base - (ulong) stack_sect->start;
  460. #endif
  461.     stack_sect->type   = S_CSTACK;
  462.     stack_sect->flags  = 0;
  463.   }
  464.  
  465.   for(n=0, sect = sects; n++ < header.nsections; sect++)
  466.   { sect->offset = section_offset;
  467.     section_offset += sect->length;
  468.   }
  469.  
  470.   tryWrite(fd, &header, sizeof(header));
  471.   tryWrite(fd, sects, sects_size);
  472.  
  473.   for(n=0, sect = sects; n++ < header.nsections; sect++)
  474.   { DEBUG(1, printf("Saving # %d 0x%x-0x%x (offset = %ld)\n",
  475.             n,
  476.             (unsigned) sect->start,
  477.             (unsigned) sect->start+sect->length,
  478.             tell(fd)));
  479.     tryWrite(fd, sect->start, sect->length);
  480.   }
  481.  
  482.   close(fd);
  483.  
  484.   return SAVE_SAVE;
  485. }
  486.  
  487.  
  488. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  489. main() stub
  490. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  491.  
  492. int
  493. main(argc, argv, env)
  494. int argc;
  495. char **argv;
  496. char **env;
  497. { int rval;
  498.  
  499.   c_stack_base = baseOfCStack(&argc, argv, env);
  500.  
  501.   if ( setjmp(ret_main_ctx) )
  502.   { DEBUG(1, printf("Restarting startProlog()\n"));
  503.     environ = env;
  504.     rval = startProlog(argc, argv, env);
  505.   } else
  506.   { if ( argc >= 3 && streq(argv[1], "-r") )
  507. #if O_DYNAMIC_STACKS
  508.     { extern int allocateSection P((SaveSection));
  509.  
  510.       if ( !restore(argv[2], allocateSection) )
  511.     exit(1);
  512.     }
  513. #else
  514.     { if ( !restore(argv[2], NULL) )
  515.     exit(1);
  516.     }
  517. #endif
  518.  
  519.     rval = startProlog(argc, argv, env);
  520.   }
  521.  
  522.   exit(rval);
  523.   return 1;
  524. }
  525.  
  526. #else /* !O_SAVE */
  527.  
  528. int
  529. main(argc, argv, env)
  530. int argc;
  531. char **argv;
  532. char **env;
  533. { exit(startProlog(argc, argv, env));
  534.   return 1;
  535. }
  536.  
  537. #endif
  538.  
  539.  
  540. #if TEST                /* test stand-alone */
  541.  
  542. static value = 1;
  543. static dumped = 0;
  544.  
  545. bool
  546. warning(va_alist)
  547. va_dcl
  548. { va_list args;
  549.   char *fm;
  550.  
  551.   va_start(args);
  552.   fm = va_arg(args, char *);
  553.   fprintf(stderr, "[WARNING: ");
  554.   vfprintf(stderr, fm, args);
  555.   fprintf(stderr, "]\n");
  556.   va_end(args);
  557.  
  558.   fail;
  559. }
  560.  
  561.  
  562. char *
  563. OsError()
  564. { static char errmsg[64];
  565.   extern int sys_nerr;
  566.   extern char *sys_errlist[];
  567.   extern int errno;
  568.  
  569.   if ( errno < sys_nerr )
  570.     return sys_errlist[errno];
  571.  
  572.   sprintf(errmsg, "Unknown Error (%d)", errno);
  573.   return errmsg;
  574. }
  575.  
  576.  
  577. startProlog(argc, argv, env)
  578. int argc;
  579. char **argv, **env;
  580. { char *interpreter = argv[0];
  581.  
  582.   argc--; argv++;
  583.  
  584.   printf("value = %d\n", value++);
  585.  
  586.   for ( ; argc > 1; argc--, argv++ )
  587.   { if ( streq(argv[0], "-s") )
  588.     { save(argv[1], interpreter, RET_MAIN, 0, NULL);
  589.       printf("Saved (-s) in %s\n", argv[1]);
  590.       exit(0);
  591.     }
  592.     if ( streq(argv[0], "-S") )
  593.     { if ( save(argv[1], interpreter, RET_RETURN, 0, NULL) == SAVE_SAVE )
  594.     printf("Saved (-S) in %s\n", argv[1]);
  595.       else
  596.     printf("Restored from %s\n", argv[1]);
  597.       exit(0);
  598.     }
  599.   }
  600.  
  601.   exit(0);
  602. }
  603.  
  604. #endif
  605.