/* Support for dumping and reloading various pieces of GDB's internal state. Copyright 1992 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* This file provides support for dumping and then later reloading various portions of gdb's internal state. It was originally implemented to support a need for mapping in an image of gdb's symbol table from an external file, where this image was created by an external program, such as an incremental linker. However, it was generalized to enable future support for dumping and reloading various other useful pieces of gdb's internal state. State files have a fairly simple form which is intended to be easily extensible. The basic format is: <file-header> <state-data> <form-tree> Where: file-header A simple file-header containing a magic number so that gdb (and other readers) can quickly determine what kind of file this is, and a file offset to the root of the form-tree. state-data The "raw" state-data that is referenced by nodes in the form-tree. form-tree A tree of arbitrarily sized nodes containing information about gdb's internal state, and possibly referencing data in the state-data section of the file. Resembles DWARF in some respects. When writing a state file, a hole is left for the file-header at the beginning of the file, the state data is written immediately after the file header (while storing the file offsets and sizes back into the internal form-tree along the way), the form-tree itself is written at the end of the file, and then the file header is written by seeking back to the beginning of the file. This order is required because the form tree contains file offsets and sizes in the state data portion of the file, and the file header contains the file offset to the start of the form tree. Readers simply open the file, validate the magic number, seek to the root of the form-tree, and walk the tree looking for the information that they are interested in (and ignoring things that they aren't, or don't understand). */ #include "defs.h" #include "symtab.h" #include "bfd.h" #include "symfile.h" #include "state.h" #ifndef SEEK_SET #define SEEK_SET 0 #endif #ifndef SEEK_END #define SEEK_END 2 #endif /* Inside the state file, the form-tree consists of a series of form-tree entries (FTE's). The parent/child/sibling relationships are implied by the ordering and by an explicit sibling reference in FTE's that have siblings. Specifically, given two sequential FTE's, say A and B, if B immediately follows A, and A does not have a sibling reference to B, then B is the first child of A. Otherwise B must be a sibling of A and A must have a sibling reference for it. Each FTE is simply an array of long integers, with at least three members. This form was chosen over a packed data form for simplicity in access, not having to worry about the relative sizes of the different integers (short, int, long), and not having to worry about alignment constraints. Also in the name of simplicity, every FTE has a sibling reference slot reserved for it, even if there are no siblings. The first value in an FTE is the size of the FTE in bytes, including the size value itself. The second entry contains a tag which indicates the type of the FTE. The third entry is a sibling reference, which either refers to a valid sibling node or is zero. Following is zero or more attributes, each of which consists of one or more long values. */ /* Tag names and codes. */ #define TAG_padding 0x0000 /* Padding */ #define TAG_objfile 0x0001 /* Dumped objfile */ /* Form names, codes, and macros. */ #define FORM_ABSREF 0x01 /* Next long is absolute file offset */ #define FORM_RELREF 0x02 /* Next long is relative file offset */ #define FORM_IVAL 0x03 /* Next long is int value */ #define FORM_ADDR 0x04 /* Next long is mem addr */ #define FORM_MASK 0xFF #define FORM_X(atr) ((atr) & FORM_MASK) /* Attribute names and codes. */ #define AT_sibling (0x0100 | FORM_RELREF) /* Reference to sibling node */ #define AT_name (0x0200 | FORM_ABSREF) /* Reference to a string */ #define AT_offset (0x0300 | FORM_ABSREF) /* Reference to generic data */ #define AT_size (0x0400 | FORM_IVAL) #define AT_addr (0x0500 | FORM_ADDR) #define AT_aux_addr (0x0600 | FORM_ADDR) /* */ static void load_symbols PARAMS ((FILE *)); static void dump_state_command PARAMS ((char *, int)); static void load_state_command PARAMS ((char *, int)); #ifdef HAVE_MMAP static void write_header PARAMS ((sfd *)); static void write_formtree PARAMS ((sfd *)); static void write_objfile_state PARAMS ((sfd *)); static void free_subtree PARAMS ((struct formnode *)); static void size_subtree PARAMS ((struct formnode *)); #endif struct formnode *formtree = NULL; /* ARGSUSED */ static void load_symbols (statefile) FILE *statefile; { #if 0 /* Discard old symbols. FIXME: This is essentially symbol_file_command's body when there is no name. Make it a common function that is called from each place. */ if (symfile_objfile) { free_objfile (symfile_objfile); } symfile_objfile = NULL; #endif #if 0 && defined (HAVE_MMAP) if (mtop > mbase) { warning ("internal error: mbase (%08x) != mtop (%08x)", mbase, mtop); munmap (mbase, mtop - mbase); } #endif /* HAVE_MMAP */ /* Getting new symbols may change our opinion about what is frameless. */ reinit_frame_cache (); } #ifdef HAVE_MMAP /* Allocate a form node */ static struct formnode * alloc_formnode () { struct formnode *fnp; fnp = (struct formnode *) xmalloc (sizeof (struct formnode)); (void) memset (fnp, 0, sizeof (struct formnode)); fnp -> sibling = formtree; formtree = fnp; return (fnp); } /* Recursively walk a form-tree from the specified node, freeing nodes from the bottom up. The concept is pretty simple, just free all the child nodes, then all the sibling nodes, then the node itself. */ static void free_subtree (fnp) struct formnode *fnp; { if (fnp != NULL) { free_subtree (fnp -> child); free_subtree (fnp -> sibling); if (fnp -> nodedata != NULL) { free (fnp -> nodedata); } free (fnp); } } /* Recursively walk a form-tree from the specified node, computing the size of each subtree from the bottom up. At each node, the file space that will be consumed by the subtree rooted in that node is the sum of all the subtrees rooted in each child node plus the size of the node itself. Thus for each node, we size the child subtrees, add to that our size, contribute this size towards the size of any parent node, and then ask any of our siblings to do the same. Also, once we know the size of any subtree rooted at this node, we can initialize the offset to the sibling node (if any). Since every form-tree node must have valid nodedata at this point, we detect and report a warning for any node that doesn't. */ static void size_subtree (fnp) struct formnode *fnp; { long *lp; if (fnp != NULL) { if (fnp -> nodedata == NULL) { warning ("internal error -- empty form node"); } else { size_subtree (fnp -> child); fnp -> treesize += *(long *) fnp -> nodedata; if (fnp -> parent != NULL) { fnp -> parent -> treesize += fnp -> treesize; } if (fnp -> sibling) { size_subtree (fnp -> sibling); lp = (long *) (fnp -> nodedata + 2 * sizeof (long)); *lp = fnp -> treesize; } } } } /* Recursively walk a form-tree from the specified node, writing nodes from the top down. */ static void write_subtree (fnp, asfd) struct formnode *fnp; sfd *asfd; { if (fnp != NULL) { if (fnp -> nodedata != NULL) { fwrite (fnp -> nodedata, *(long *) fnp -> nodedata, 1, asfd -> fp); } write_subtree (fnp -> child, asfd); write_subtree (fnp -> sibling, asfd); } } /* Free the entire current formtree. Called via do_cleanups, regardless of whether there is an error or not. */ static void free_formtree () { free_subtree (formtree); formtree = NULL; } /* Write out the file header. Generally this is done last, even though it is located at the start of the file, since we need to have file offset to where the annotated form tree was written, and it's size. */ static void write_header (asfd) sfd *asfd; { fseek (asfd -> fp, 0L, SEEK_SET); fwrite ((char *) &asfd -> hdr, sizeof (asfd -> hdr), 1, asfd -> fp); } /* Write out the annotated form tree. We should already have written out the state data, and noted the file offsets and sizes in each node of the form tree that references part of the state data. The form tree can be written anywhere in the file where there is room for it. Since there is always room at the end of the file, we write it there. We also need to record the file offset to the start of the form tree, and it's size, for future use when writing the file header. In order to compute the sibling references, we need to know, at each node, how much space will be consumed when all of that node's children nodes have been written. Thus we walk the tree, computing the sizes of the subtrees from the bottom up. At any node, the offset from the start of that node to the start of the sibling node is simply the size of the node plus the size of the subtree rooted in that node. */ static void write_formtree (asfd) sfd *asfd; { size_subtree (formtree); fseek (asfd -> fp, 0L, SEEK_END); asfd -> hdr.sf_ftoff = ftell (asfd -> fp); write_subtree (formtree, asfd); asfd -> hdr.sf_ftsize = ftell (asfd -> fp) - asfd -> hdr.sf_ftoff; } /* Note that we currently only support having one objfile with dumpable state. */ static void write_objfile_state (asfd) sfd *asfd; { struct objfile *objfile; struct formnode *fnp; PTR base; PTR breakval; long *lp; unsigned int ftesize; long ftebuf[64]; long foffset; /* First walk through the objfile list looking for the first objfile that is dumpable. */ for (objfile = object_files; objfile != NULL; objfile = objfile -> next) { if (objfile -> flags & OBJF_DUMPABLE) { break; } } if (objfile == NULL) { warning ("no dumpable objfile was found"); } else { fnp = alloc_formnode (); lp = ftebuf; lp++; /* Skip FTE size slot, filled in at the end. */ *lp++ = TAG_objfile; /* This is an objfile FTE */ *lp++ = 0; /* Zero the sibling reference slot. */ /* Build an AT_name attribute for the objfile's name, and write the name into the state data. */ *lp++ = AT_name; *lp++ = (long) ftell (asfd -> fp); fwrite (objfile -> name, strlen (objfile -> name) + 1, 1, asfd -> fp); /* Build an AT_addr attribute for the virtual address to which the objfile data is mapped (and needs to be remapped when read in). */ base = mmap_base (); *lp++ = AT_addr; *lp++ = (long) base; /* Build an AT_aux_addr attribute for the address of the objfile structure itself, within the dumpable data. When we read the objfile back in, we use this address as the pointer the "struct objfile". */ *lp++ = AT_aux_addr; *lp++ = (long) objfile; /* Reposition in state file to next paging boundry so we can mmap the dumpable objfile data when we reload it. */ foffset = (long) mmap_page_align ((PTR) ftell (asfd -> fp)); fseek (asfd -> fp, foffset, SEEK_SET); /* Build an AT_offset attribute for the offset in the state file to the start of the dumped objfile data. */ *lp++ = AT_offset; *lp++ = (long) ftell (asfd -> fp); /* Build an AT_size attribute for the size of the dumped objfile data. */ breakval = mmap_sbrk (0); *lp++ = AT_size; *lp++ = breakval - base; /* Write the dumpable data. */ fwrite ((char *) base, breakval - base, 1, asfd -> fp); /* Now finish up the FTE by filling in the size slot based on how much of the ftebuf we have used, allocate some memory for it hung off the form tree node, and copy it there. */ ftebuf[0] = (lp - ftebuf) * sizeof (ftebuf[0]); fnp -> nodedata = (char *) xmalloc (ftebuf[0]); memcpy (fnp -> nodedata, ftebuf, ftebuf[0]); } } static void load_state_command (arg_string, from_tty) char *arg_string; int from_tty; { char *filename; char **argv; FILE *fp; struct cleanup *cleanups; dont_repeat (); if (arg_string == NULL) { error ("load-state takes a file name and optional state specifiers"); } else if ((argv = buildargv (arg_string)) == NULL) { fatal ("virtual memory exhausted.", 0); } cleanups = make_cleanup (freeargv, argv); filename = tilde_expand (*argv); make_cleanup (free, filename); if ((fp = fopen (filename, "r")) == NULL) { perror_with_name (filename); } make_cleanup (fclose, fp); immediate_quit++; while (*++argv != NULL) { if (strcmp (*argv, "symbols") == 0) { if (from_tty && !query ("load symbol table state from file \"%s\"? ", filename)) { error ("Not confirmed."); } load_symbols (fp); } else { error ("unknown state specifier '%s'", *argv); } } immediate_quit--; do_cleanups (cleanups); } /* ARGSUSED */ static void dump_state_command (arg_string, from_tty) char *arg_string; int from_tty; { char *filename; char **argv; sfd *asfd; struct cleanup *cleanups; dont_repeat (); if (arg_string == NULL) { error ("dump-state takes a file name and state specifiers"); } else if ((argv = buildargv (arg_string)) == NULL) { fatal ("virtual memory exhausted.", 0); } cleanups = make_cleanup (freeargv, argv); filename = tilde_expand (*argv); make_cleanup (free, filename); /* Now attempt to create a fresh state file. */ if ((asfd = sfd_fopen (filename, "w")) == NULL) { perror_with_name (filename); } make_cleanup (sfd_fclose, asfd); make_cleanup (free_formtree, NULL); immediate_quit++; /* Now that we have an open and initialized state file, seek to the proper offset to start writing state data and the process the arguments. For each argument, write the state data and initialize a form-tree node for each piece of state data. */ fseek (asfd -> fp, sizeof (sf_hdr), SEEK_SET); while (*++argv != NULL) { if (strcmp (*argv, "objfile") == 0) { write_objfile_state (asfd); } else { error ("unknown state specifier '%s'", *argv); } } /* We have written any state data. All that is left to do now is write the form-tree and the file header. */ write_formtree (asfd); write_header (asfd); immediate_quit--; do_cleanups (cleanups); } static char * find_fte_by_walk (thisfte, endfte, tag) char *thisfte; char *endfte; long tag; { char *found = NULL; char *nextfte; long thistag; long thissize; long siboffset; while (thisfte < endfte) { if ((thistag = *(long *)(thisfte + sizeof (long))) == tag) { found = thisfte; break; } else { thissize = *(long *)(thisfte); siboffset = *(long *)(thisfte + (2 * sizeof (long))); nextfte = thisfte + (siboffset != 0 ? siboffset : thissize); found = find_fte_by_walk (thisfte + thissize, nextfte, tag); thisfte = nextfte; } } return (found); } /* Walk the form-tree looking for a specific FTE type. Returns the first one found that matches the specified tag. */ static char * find_fte (asfd, tag) sfd *asfd; long tag; { char *ftbase; char *ftend; char *ftep; char *found = NULL; if (fseek (asfd -> fp, asfd -> hdr.sf_ftoff, SEEK_SET) == 0) { ftbase = xmalloc (asfd -> hdr.sf_ftsize); ftend = ftbase + asfd -> hdr.sf_ftsize; if (fread (ftbase, asfd -> hdr.sf_ftsize, 1, asfd -> fp) == 1) { ftep = find_fte_by_walk (ftbase, ftend, tag); if (ftep != NULL) { found = xmalloc (*(long *)ftep); memcpy (found, ftep, (int) *(long *)ftep); } } free (ftbase); } return (found); } struct objfile * objfile_from_statefile (asfd) sfd *asfd; { struct objfile *objfile = NULL; char *ftep; long *thisattr; long *endattr; PTR base; long foffset; long mapsize; ftep = find_fte (asfd, TAG_objfile); thisattr = (long *) (ftep + 3 * sizeof (long)); endattr = (long *) (ftep + *(long *)ftep); while (thisattr < endattr) { switch (*thisattr++) { case AT_name: /* Ignore for now */ thisattr++; break; case AT_addr: base = (PTR) *thisattr++; break; case AT_aux_addr: objfile = (struct objfile *) *thisattr++; break; case AT_offset: foffset = *thisattr++; break; case AT_size: mapsize = *thisattr++; break; } } if (mmap_remap (base, mapsize, (int) fileno (asfd -> fp), foffset) != base) { print_sys_errmsg (asfd -> filename, errno); error ("mapping failed"); } return (objfile); } #else struct objfile * objfile_from_statefile (asfd) sfd *asfd; { error ("this version of gdb doesn't support reloading symtabs from state files"); } #endif /* HAVE_MMAP */ /* Close a state file, freeing all memory that was used by the state file descriptor, closing the raw file pointer, etc. */ void sfd_fclose (asfd) sfd *asfd; { if (asfd != NULL) { if (asfd -> fp != NULL) { fclose (asfd -> fp); } if (asfd -> filename != NULL) { free (asfd -> filename); } free (asfd); } } /* Given the name of a possible statefile, and flags to use to open it, try to open the file and prepare it for use. If the flags contain 'r', then we want to read an existing state file, so attempt to read in the state file header and determine if this is a valid state file. If not, return NULL. Returns a pointer to a properly initialized state file descriptor if successful. */ sfd * sfd_fopen (name, flags) char *name; char *flags; { int success = 0; sfd *asfd; asfd = (sfd *) xmalloc (sizeof (sfd)); (void) memset (asfd, 0, sizeof (sfd)); asfd -> filename = xmalloc (strlen (name) + 1); (void) strcpy (asfd -> filename, name); if ((asfd -> fp = fopen (asfd -> filename, flags)) != NULL) { /* We have the file, now see if we are reading an existing file or writing to a new file. We don't currently support "rw". */ if (strchr (flags, 'r') != NULL) { if (fread ((char *) &asfd -> hdr, sizeof (asfd -> hdr), 1, asfd -> fp) == 1) { if (SF_GOOD_MAGIC (asfd)) { success = 1; } } } else { /* This is a new state file. Initialize various things. */ asfd -> hdr.sf_mag0 = SF_MAG0; asfd -> hdr.sf_mag1 = SF_MAG1; asfd -> hdr.sf_mag2 = SF_MAG2; asfd -> hdr.sf_mag3 = SF_MAG3; success = 1; } } if (!success) { sfd_fclose (asfd); asfd = NULL; } return (asfd); } void _initialize_state () { #ifdef HAVE_MMAP add_com ("load-state", class_support, load_state_command, "Load some saved gdb state from FILE.\n\ Select and load some portion of gdb's saved state from the specified file.\n\ The dump-state command may be used to save various portions of gdb's\n\ internal state."); add_com ("dump-state", class_support, dump_state_command, "Dump some of gdb's state to FILE.\n\ Select and dump some portion of gdb's internal state to the specified file.\n\ The load-state command may be used to reload various portions of gdb's\n\ internal state from the file."); #endif /* HAVE_MMAP */ }