Home | History | Annotate | Line # | Download | only in restore
symtab.c revision 1.6
      1  1.1      cgd /*
      2  1.4  mycroft  * Copyright (c) 1983, 1993
      3  1.4  mycroft  *	The Regents of the University of California.  All rights reserved.
      4  1.1      cgd  *
      5  1.1      cgd  * Redistribution and use in source and binary forms, with or without
      6  1.1      cgd  * modification, are permitted provided that the following conditions
      7  1.1      cgd  * are met:
      8  1.1      cgd  * 1. Redistributions of source code must retain the above copyright
      9  1.1      cgd  *    notice, this list of conditions and the following disclaimer.
     10  1.1      cgd  * 2. Redistributions in binary form must reproduce the above copyright
     11  1.1      cgd  *    notice, this list of conditions and the following disclaimer in the
     12  1.1      cgd  *    documentation and/or other materials provided with the distribution.
     13  1.1      cgd  * 3. All advertising materials mentioning features or use of this software
     14  1.1      cgd  *    must display the following acknowledgement:
     15  1.1      cgd  *	This product includes software developed by the University of
     16  1.1      cgd  *	California, Berkeley and its contributors.
     17  1.1      cgd  * 4. Neither the name of the University nor the names of its contributors
     18  1.1      cgd  *    may be used to endorse or promote products derived from this software
     19  1.1      cgd  *    without specific prior written permission.
     20  1.1      cgd  *
     21  1.1      cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     22  1.1      cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23  1.1      cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24  1.1      cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     25  1.1      cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     26  1.1      cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     27  1.1      cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     28  1.1      cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     29  1.1      cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     30  1.1      cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     31  1.1      cgd  * SUCH DAMAGE.
     32  1.1      cgd  */
     33  1.1      cgd 
     34  1.1      cgd #ifndef lint
     35  1.6  mycroft /*static char sccsid[] = "from: @(#)symtab.c	8.2 (Berkeley) 9/13/94";*/
     36  1.6  mycroft static char *rcsid = "$Id: symtab.c,v 1.6 1994/12/28 02:21:52 mycroft Exp $";
     37  1.1      cgd #endif /* not lint */
     38  1.1      cgd 
     39  1.1      cgd /*
     40  1.1      cgd  * These routines maintain the symbol table which tracks the state
     41  1.1      cgd  * of the file system being restored. They provide lookup by either
     42  1.1      cgd  * name or inode number. They also provide for creation, deletion,
     43  1.1      cgd  * and renaming of entries. Because of the dynamic nature of pathnames,
     44  1.1      cgd  * names should not be saved, but always constructed just before they
     45  1.1      cgd  * are needed, by calling "myname".
     46  1.1      cgd  */
     47  1.1      cgd 
     48  1.3      cgd #include <sys/param.h>
     49  1.3      cgd #include <sys/stat.h>
     50  1.3      cgd 
     51  1.4  mycroft #include <ufs/ufs/dinode.h>
     52  1.3      cgd 
     53  1.3      cgd #include <errno.h>
     54  1.3      cgd #include <fcntl.h>
     55  1.3      cgd #include <stdio.h>
     56  1.3      cgd #include <stdlib.h>
     57  1.3      cgd #include <string.h>
     58  1.3      cgd #include <unistd.h>
     59  1.3      cgd 
     60  1.1      cgd #include "restore.h"
     61  1.3      cgd #include "extern.h"
     62  1.1      cgd 
     63  1.1      cgd /*
     64  1.1      cgd  * The following variables define the inode symbol table.
     65  1.1      cgd  * The primary hash table is dynamically allocated based on
     66  1.1      cgd  * the number of inodes in the file system (maxino), scaled by
     67  1.1      cgd  * HASHFACTOR. The variable "entry" points to the hash table;
     68  1.1      cgd  * the variable "entrytblsize" indicates its size (in entries).
     69  1.1      cgd  */
     70  1.1      cgd #define HASHFACTOR 5
     71  1.1      cgd static struct entry **entry;
     72  1.1      cgd static long entrytblsize;
     73  1.1      cgd 
     74  1.3      cgd static void		 addino __P((ino_t, struct entry *));
     75  1.3      cgd static struct entry	*lookupparent __P((char *));
     76  1.3      cgd static void		 removeentry __P((struct entry *));
     77  1.3      cgd 
     78  1.1      cgd /*
     79  1.1      cgd  * Look up an entry by inode number
     80  1.1      cgd  */
     81  1.1      cgd struct entry *
     82  1.1      cgd lookupino(inum)
     83  1.1      cgd 	ino_t inum;
     84  1.1      cgd {
     85  1.1      cgd 	register struct entry *ep;
     86  1.1      cgd 
     87  1.6  mycroft 	if (inum < WINO || inum >= maxino)
     88  1.3      cgd 		return (NULL);
     89  1.3      cgd 	for (ep = entry[inum % entrytblsize]; ep != NULL; ep = ep->e_next)
     90  1.1      cgd 		if (ep->e_ino == inum)
     91  1.1      cgd 			return (ep);
     92  1.3      cgd 	return (NULL);
     93  1.1      cgd }
     94  1.1      cgd 
     95  1.1      cgd /*
     96  1.1      cgd  * Add an entry into the entry table
     97  1.1      cgd  */
     98  1.3      cgd static void
     99  1.1      cgd addino(inum, np)
    100  1.1      cgd 	ino_t inum;
    101  1.1      cgd 	struct entry *np;
    102  1.1      cgd {
    103  1.1      cgd 	struct entry **epp;
    104  1.1      cgd 
    105  1.6  mycroft 	if (inum < WINO || inum >= maxino)
    106  1.1      cgd 		panic("addino: out of range %d\n", inum);
    107  1.1      cgd 	epp = &entry[inum % entrytblsize];
    108  1.1      cgd 	np->e_ino = inum;
    109  1.1      cgd 	np->e_next = *epp;
    110  1.1      cgd 	*epp = np;
    111  1.1      cgd 	if (dflag)
    112  1.3      cgd 		for (np = np->e_next; np != NULL; np = np->e_next)
    113  1.1      cgd 			if (np->e_ino == inum)
    114  1.1      cgd 				badentry(np, "duplicate inum");
    115  1.1      cgd }
    116  1.1      cgd 
    117  1.1      cgd /*
    118  1.1      cgd  * Delete an entry from the entry table
    119  1.1      cgd  */
    120  1.3      cgd void
    121  1.1      cgd deleteino(inum)
    122  1.1      cgd 	ino_t inum;
    123  1.1      cgd {
    124  1.1      cgd 	register struct entry *next;
    125  1.1      cgd 	struct entry **prev;
    126  1.1      cgd 
    127  1.6  mycroft 	if (inum < WINO || inum >= maxino)
    128  1.1      cgd 		panic("deleteino: out of range %d\n", inum);
    129  1.1      cgd 	prev = &entry[inum % entrytblsize];
    130  1.3      cgd 	for (next = *prev; next != NULL; next = next->e_next) {
    131  1.1      cgd 		if (next->e_ino == inum) {
    132  1.1      cgd 			next->e_ino = 0;
    133  1.1      cgd 			*prev = next->e_next;
    134  1.1      cgd 			return;
    135  1.1      cgd 		}
    136  1.1      cgd 		prev = &next->e_next;
    137  1.1      cgd 	}
    138  1.1      cgd 	panic("deleteino: %d not found\n", inum);
    139  1.1      cgd }
    140  1.1      cgd 
    141  1.1      cgd /*
    142  1.1      cgd  * Look up an entry by name
    143  1.1      cgd  */
    144  1.1      cgd struct entry *
    145  1.1      cgd lookupname(name)
    146  1.1      cgd 	char *name;
    147  1.1      cgd {
    148  1.1      cgd 	register struct entry *ep;
    149  1.1      cgd 	register char *np, *cp;
    150  1.1      cgd 	char buf[MAXPATHLEN];
    151  1.1      cgd 
    152  1.1      cgd 	cp = name;
    153  1.3      cgd 	for (ep = lookupino(ROOTINO); ep != NULL; ep = ep->e_entries) {
    154  1.1      cgd 		for (np = buf; *cp != '/' && *cp != '\0'; )
    155  1.1      cgd 			*np++ = *cp++;
    156  1.1      cgd 		*np = '\0';
    157  1.3      cgd 		for ( ; ep != NULL; ep = ep->e_sibling)
    158  1.1      cgd 			if (strcmp(ep->e_name, buf) == 0)
    159  1.1      cgd 				break;
    160  1.3      cgd 		if (ep == NULL)
    161  1.1      cgd 			break;
    162  1.1      cgd 		if (*cp++ == '\0')
    163  1.1      cgd 			return (ep);
    164  1.1      cgd 	}
    165  1.3      cgd 	return (NULL);
    166  1.1      cgd }
    167  1.1      cgd 
    168  1.1      cgd /*
    169  1.1      cgd  * Look up the parent of a pathname
    170  1.1      cgd  */
    171  1.3      cgd static struct entry *
    172  1.1      cgd lookupparent(name)
    173  1.1      cgd 	char *name;
    174  1.1      cgd {
    175  1.1      cgd 	struct entry *ep;
    176  1.1      cgd 	char *tailindex;
    177  1.1      cgd 
    178  1.5  mycroft 	tailindex = strrchr(name, '/');
    179  1.4  mycroft 	if (tailindex == NULL)
    180  1.3      cgd 		return (NULL);
    181  1.1      cgd 	*tailindex = '\0';
    182  1.1      cgd 	ep = lookupname(name);
    183  1.1      cgd 	*tailindex = '/';
    184  1.3      cgd 	if (ep == NULL)
    185  1.3      cgd 		return (NULL);
    186  1.1      cgd 	if (ep->e_type != NODE)
    187  1.1      cgd 		panic("%s is not a directory\n", name);
    188  1.1      cgd 	return (ep);
    189  1.1      cgd }
    190  1.1      cgd 
    191  1.1      cgd /*
    192  1.1      cgd  * Determine the current pathname of a node or leaf
    193  1.1      cgd  */
    194  1.1      cgd char *
    195  1.1      cgd myname(ep)
    196  1.1      cgd 	register struct entry *ep;
    197  1.1      cgd {
    198  1.1      cgd 	register char *cp;
    199  1.1      cgd 	static char namebuf[MAXPATHLEN];
    200  1.1      cgd 
    201  1.1      cgd 	for (cp = &namebuf[MAXPATHLEN - 2]; cp > &namebuf[ep->e_namlen]; ) {
    202  1.1      cgd 		cp -= ep->e_namlen;
    203  1.5  mycroft 		memcpy(cp, ep->e_name, (long)ep->e_namlen);
    204  1.1      cgd 		if (ep == lookupino(ROOTINO))
    205  1.1      cgd 			return (cp);
    206  1.1      cgd 		*(--cp) = '/';
    207  1.1      cgd 		ep = ep->e_parent;
    208  1.1      cgd 	}
    209  1.1      cgd 	panic("%s: pathname too long\n", cp);
    210  1.1      cgd 	return(cp);
    211  1.1      cgd }
    212  1.1      cgd 
    213  1.1      cgd /*
    214  1.1      cgd  * Unused symbol table entries are linked together on a freelist
    215  1.1      cgd  * headed by the following pointer.
    216  1.1      cgd  */
    217  1.3      cgd static struct entry *freelist = NULL;
    218  1.1      cgd 
    219  1.1      cgd /*
    220  1.1      cgd  * add an entry to the symbol table
    221  1.1      cgd  */
    222  1.1      cgd struct entry *
    223  1.1      cgd addentry(name, inum, type)
    224  1.1      cgd 	char *name;
    225  1.1      cgd 	ino_t inum;
    226  1.1      cgd 	int type;
    227  1.1      cgd {
    228  1.1      cgd 	register struct entry *np, *ep;
    229  1.1      cgd 
    230  1.3      cgd 	if (freelist != NULL) {
    231  1.1      cgd 		np = freelist;
    232  1.1      cgd 		freelist = np->e_next;
    233  1.5  mycroft 		memset(np, 0, (long)sizeof(struct entry));
    234  1.1      cgd 	} else {
    235  1.1      cgd 		np = (struct entry *)calloc(1, sizeof(struct entry));
    236  1.3      cgd 		if (np == NULL)
    237  1.1      cgd 			panic("no memory to extend symbol table\n");
    238  1.1      cgd 	}
    239  1.1      cgd 	np->e_type = type & ~LINK;
    240  1.1      cgd 	ep = lookupparent(name);
    241  1.3      cgd 	if (ep == NULL) {
    242  1.3      cgd 		if (inum != ROOTINO || lookupino(ROOTINO) != NULL)
    243  1.1      cgd 			panic("bad name to addentry %s\n", name);
    244  1.1      cgd 		np->e_name = savename(name);
    245  1.1      cgd 		np->e_namlen = strlen(name);
    246  1.1      cgd 		np->e_parent = np;
    247  1.1      cgd 		addino(ROOTINO, np);
    248  1.1      cgd 		return (np);
    249  1.1      cgd 	}
    250  1.5  mycroft 	np->e_name = savename(strrchr(name, '/') + 1);
    251  1.1      cgd 	np->e_namlen = strlen(np->e_name);
    252  1.1      cgd 	np->e_parent = ep;
    253  1.1      cgd 	np->e_sibling = ep->e_entries;
    254  1.1      cgd 	ep->e_entries = np;
    255  1.1      cgd 	if (type & LINK) {
    256  1.1      cgd 		ep = lookupino(inum);
    257  1.3      cgd 		if (ep == NULL)
    258  1.1      cgd 			panic("link to non-existant name\n");
    259  1.1      cgd 		np->e_ino = inum;
    260  1.1      cgd 		np->e_links = ep->e_links;
    261  1.1      cgd 		ep->e_links = np;
    262  1.1      cgd 	} else if (inum != 0) {
    263  1.3      cgd 		if (lookupino(inum) != NULL)
    264  1.1      cgd 			panic("duplicate entry\n");
    265  1.1      cgd 		addino(inum, np);
    266  1.1      cgd 	}
    267  1.1      cgd 	return (np);
    268  1.1      cgd }
    269  1.1      cgd 
    270  1.1      cgd /*
    271  1.1      cgd  * delete an entry from the symbol table
    272  1.1      cgd  */
    273  1.3      cgd void
    274  1.1      cgd freeentry(ep)
    275  1.1      cgd 	register struct entry *ep;
    276  1.1      cgd {
    277  1.1      cgd 	register struct entry *np;
    278  1.1      cgd 	ino_t inum;
    279  1.1      cgd 
    280  1.1      cgd 	if (ep->e_flags != REMOVED)
    281  1.1      cgd 		badentry(ep, "not marked REMOVED");
    282  1.1      cgd 	if (ep->e_type == NODE) {
    283  1.3      cgd 		if (ep->e_links != NULL)
    284  1.1      cgd 			badentry(ep, "freeing referenced directory");
    285  1.3      cgd 		if (ep->e_entries != NULL)
    286  1.1      cgd 			badentry(ep, "freeing non-empty directory");
    287  1.1      cgd 	}
    288  1.1      cgd 	if (ep->e_ino != 0) {
    289  1.1      cgd 		np = lookupino(ep->e_ino);
    290  1.3      cgd 		if (np == NULL)
    291  1.1      cgd 			badentry(ep, "lookupino failed");
    292  1.1      cgd 		if (np == ep) {
    293  1.1      cgd 			inum = ep->e_ino;
    294  1.1      cgd 			deleteino(inum);
    295  1.3      cgd 			if (ep->e_links != NULL)
    296  1.1      cgd 				addino(inum, ep->e_links);
    297  1.1      cgd 		} else {
    298  1.3      cgd 			for (; np != NULL; np = np->e_links) {
    299  1.1      cgd 				if (np->e_links == ep) {
    300  1.1      cgd 					np->e_links = ep->e_links;
    301  1.1      cgd 					break;
    302  1.1      cgd 				}
    303  1.1      cgd 			}
    304  1.3      cgd 			if (np == NULL)
    305  1.1      cgd 				badentry(ep, "link not found");
    306  1.1      cgd 		}
    307  1.1      cgd 	}
    308  1.1      cgd 	removeentry(ep);
    309  1.1      cgd 	freename(ep->e_name);
    310  1.1      cgd 	ep->e_next = freelist;
    311  1.1      cgd 	freelist = ep;
    312  1.1      cgd }
    313  1.1      cgd 
    314  1.1      cgd /*
    315  1.1      cgd  * Relocate an entry in the tree structure
    316  1.1      cgd  */
    317  1.3      cgd void
    318  1.1      cgd moveentry(ep, newname)
    319  1.1      cgd 	register struct entry *ep;
    320  1.1      cgd 	char *newname;
    321  1.1      cgd {
    322  1.1      cgd 	struct entry *np;
    323  1.1      cgd 	char *cp;
    324  1.1      cgd 
    325  1.1      cgd 	np = lookupparent(newname);
    326  1.3      cgd 	if (np == NULL)
    327  1.1      cgd 		badentry(ep, "cannot move ROOT");
    328  1.1      cgd 	if (np != ep->e_parent) {
    329  1.1      cgd 		removeentry(ep);
    330  1.1      cgd 		ep->e_parent = np;
    331  1.1      cgd 		ep->e_sibling = np->e_entries;
    332  1.1      cgd 		np->e_entries = ep;
    333  1.1      cgd 	}
    334  1.5  mycroft 	cp = strrchr(newname, '/') + 1;
    335  1.1      cgd 	freename(ep->e_name);
    336  1.1      cgd 	ep->e_name = savename(cp);
    337  1.1      cgd 	ep->e_namlen = strlen(cp);
    338  1.1      cgd 	if (strcmp(gentempname(ep), ep->e_name) == 0)
    339  1.1      cgd 		ep->e_flags |= TMPNAME;
    340  1.1      cgd 	else
    341  1.1      cgd 		ep->e_flags &= ~TMPNAME;
    342  1.1      cgd }
    343  1.1      cgd 
    344  1.1      cgd /*
    345  1.1      cgd  * Remove an entry in the tree structure
    346  1.1      cgd  */
    347  1.3      cgd static void
    348  1.1      cgd removeentry(ep)
    349  1.1      cgd 	register struct entry *ep;
    350  1.1      cgd {
    351  1.1      cgd 	register struct entry *np;
    352  1.1      cgd 
    353  1.1      cgd 	np = ep->e_parent;
    354  1.1      cgd 	if (np->e_entries == ep) {
    355  1.1      cgd 		np->e_entries = ep->e_sibling;
    356  1.1      cgd 	} else {
    357  1.3      cgd 		for (np = np->e_entries; np != NULL; np = np->e_sibling) {
    358  1.1      cgd 			if (np->e_sibling == ep) {
    359  1.1      cgd 				np->e_sibling = ep->e_sibling;
    360  1.1      cgd 				break;
    361  1.1      cgd 			}
    362  1.1      cgd 		}
    363  1.3      cgd 		if (np == NULL)
    364  1.1      cgd 			badentry(ep, "cannot find entry in parent list");
    365  1.1      cgd 	}
    366  1.1      cgd }
    367  1.1      cgd 
    368  1.1      cgd /*
    369  1.1      cgd  * Table of unused string entries, sorted by length.
    370  1.1      cgd  *
    371  1.1      cgd  * Entries are allocated in STRTBLINCR sized pieces so that names
    372  1.1      cgd  * of similar lengths can use the same entry. The value of STRTBLINCR
    373  1.1      cgd  * is chosen so that every entry has at least enough space to hold
    374  1.1      cgd  * a "struct strtbl" header. Thus every entry can be linked onto an
    375  1.1      cgd  * apprpriate free list.
    376  1.1      cgd  *
    377  1.1      cgd  * NB. The macro "allocsize" below assumes that "struct strhdr"
    378  1.1      cgd  *     has a size that is a power of two.
    379  1.1      cgd  */
    380  1.1      cgd struct strhdr {
    381  1.1      cgd 	struct strhdr *next;
    382  1.1      cgd };
    383  1.1      cgd 
    384  1.1      cgd #define STRTBLINCR	(sizeof(struct strhdr))
    385  1.1      cgd #define allocsize(size)	(((size) + 1 + STRTBLINCR - 1) & ~(STRTBLINCR - 1))
    386  1.1      cgd 
    387  1.3      cgd static struct strhdr strtblhdr[allocsize(NAME_MAX) / STRTBLINCR];
    388  1.1      cgd 
    389  1.1      cgd /*
    390  1.1      cgd  * Allocate space for a name. It first looks to see if it already
    391  1.1      cgd  * has an appropriate sized entry, and if not allocates a new one.
    392  1.1      cgd  */
    393  1.1      cgd char *
    394  1.1      cgd savename(name)
    395  1.1      cgd 	char *name;
    396  1.1      cgd {
    397  1.1      cgd 	struct strhdr *np;
    398  1.1      cgd 	long len;
    399  1.1      cgd 	char *cp;
    400  1.1      cgd 
    401  1.1      cgd 	if (name == NULL)
    402  1.1      cgd 		panic("bad name\n");
    403  1.1      cgd 	len = strlen(name);
    404  1.1      cgd 	np = strtblhdr[len / STRTBLINCR].next;
    405  1.1      cgd 	if (np != NULL) {
    406  1.1      cgd 		strtblhdr[len / STRTBLINCR].next = np->next;
    407  1.1      cgd 		cp = (char *)np;
    408  1.1      cgd 	} else {
    409  1.1      cgd 		cp = malloc((unsigned)allocsize(len));
    410  1.1      cgd 		if (cp == NULL)
    411  1.1      cgd 			panic("no space for string table\n");
    412  1.1      cgd 	}
    413  1.1      cgd 	(void) strcpy(cp, name);
    414  1.1      cgd 	return (cp);
    415  1.1      cgd }
    416  1.1      cgd 
    417  1.1      cgd /*
    418  1.1      cgd  * Free space for a name. The resulting entry is linked onto the
    419  1.1      cgd  * appropriate free list.
    420  1.1      cgd  */
    421  1.3      cgd void
    422  1.1      cgd freename(name)
    423  1.1      cgd 	char *name;
    424  1.1      cgd {
    425  1.1      cgd 	struct strhdr *tp, *np;
    426  1.1      cgd 
    427  1.1      cgd 	tp = &strtblhdr[strlen(name) / STRTBLINCR];
    428  1.1      cgd 	np = (struct strhdr *)name;
    429  1.1      cgd 	np->next = tp->next;
    430  1.1      cgd 	tp->next = np;
    431  1.1      cgd }
    432  1.1      cgd 
    433  1.1      cgd /*
    434  1.1      cgd  * Useful quantities placed at the end of a dumped symbol table.
    435  1.1      cgd  */
    436  1.1      cgd struct symtableheader {
    437  1.1      cgd 	long	volno;
    438  1.1      cgd 	long	stringsize;
    439  1.1      cgd 	long	entrytblsize;
    440  1.1      cgd 	time_t	dumptime;
    441  1.1      cgd 	time_t	dumpdate;
    442  1.1      cgd 	ino_t	maxino;
    443  1.1      cgd 	long	ntrec;
    444  1.1      cgd };
    445  1.1      cgd 
    446  1.1      cgd /*
    447  1.1      cgd  * dump a snapshot of the symbol table
    448  1.1      cgd  */
    449  1.3      cgd void
    450  1.1      cgd dumpsymtable(filename, checkpt)
    451  1.1      cgd 	char *filename;
    452  1.1      cgd 	long checkpt;
    453  1.1      cgd {
    454  1.1      cgd 	register struct entry *ep, *tep;
    455  1.1      cgd 	register ino_t i;
    456  1.1      cgd 	struct entry temp, *tentry;
    457  1.1      cgd 	long mynum = 1, stroff = 0;
    458  1.1      cgd 	FILE *fd;
    459  1.1      cgd 	struct symtableheader hdr;
    460  1.1      cgd 
    461  1.1      cgd 	vprintf(stdout, "Check pointing the restore\n");
    462  1.1      cgd 	if (Nflag)
    463  1.1      cgd 		return;
    464  1.1      cgd 	if ((fd = fopen(filename, "w")) == NULL) {
    465  1.3      cgd 		fprintf(stderr, "fopen: %s\n", strerror(errno));
    466  1.1      cgd 		panic("cannot create save file %s for symbol table\n",
    467  1.1      cgd 			filename);
    468  1.1      cgd 	}
    469  1.1      cgd 	clearerr(fd);
    470  1.1      cgd 	/*
    471  1.1      cgd 	 * Assign indicies to each entry
    472  1.1      cgd 	 * Write out the string entries
    473  1.1      cgd 	 */
    474  1.6  mycroft 	for (i = WINO; i <= maxino; i++) {
    475  1.3      cgd 		for (ep = lookupino(i); ep != NULL; ep = ep->e_links) {
    476  1.1      cgd 			ep->e_index = mynum++;
    477  1.1      cgd 			(void) fwrite(ep->e_name, sizeof(char),
    478  1.1      cgd 			       (int)allocsize(ep->e_namlen), fd);
    479  1.1      cgd 		}
    480  1.1      cgd 	}
    481  1.1      cgd 	/*
    482  1.1      cgd 	 * Convert pointers to indexes, and output
    483  1.1      cgd 	 */
    484  1.1      cgd 	tep = &temp;
    485  1.1      cgd 	stroff = 0;
    486  1.6  mycroft 	for (i = WINO; i <= maxino; i++) {
    487  1.3      cgd 		for (ep = lookupino(i); ep != NULL; ep = ep->e_links) {
    488  1.5  mycroft 			memcpy(tep, ep, (long)sizeof(struct entry));
    489  1.1      cgd 			tep->e_name = (char *)stroff;
    490  1.1      cgd 			stroff += allocsize(ep->e_namlen);
    491  1.1      cgd 			tep->e_parent = (struct entry *)ep->e_parent->e_index;
    492  1.3      cgd 			if (ep->e_links != NULL)
    493  1.1      cgd 				tep->e_links =
    494  1.1      cgd 					(struct entry *)ep->e_links->e_index;
    495  1.3      cgd 			if (ep->e_sibling != NULL)
    496  1.1      cgd 				tep->e_sibling =
    497  1.1      cgd 					(struct entry *)ep->e_sibling->e_index;
    498  1.3      cgd 			if (ep->e_entries != NULL)
    499  1.1      cgd 				tep->e_entries =
    500  1.1      cgd 					(struct entry *)ep->e_entries->e_index;
    501  1.3      cgd 			if (ep->e_next != NULL)
    502  1.1      cgd 				tep->e_next =
    503  1.1      cgd 					(struct entry *)ep->e_next->e_index;
    504  1.1      cgd 			(void) fwrite((char *)tep, sizeof(struct entry), 1, fd);
    505  1.1      cgd 		}
    506  1.1      cgd 	}
    507  1.1      cgd 	/*
    508  1.1      cgd 	 * Convert entry pointers to indexes, and output
    509  1.1      cgd 	 */
    510  1.1      cgd 	for (i = 0; i < entrytblsize; i++) {
    511  1.3      cgd 		if (entry[i] == NULL)
    512  1.3      cgd 			tentry = NULL;
    513  1.1      cgd 		else
    514  1.1      cgd 			tentry = (struct entry *)entry[i]->e_index;
    515  1.1      cgd 		(void) fwrite((char *)&tentry, sizeof(struct entry *), 1, fd);
    516  1.1      cgd 	}
    517  1.1      cgd 	hdr.volno = checkpt;
    518  1.1      cgd 	hdr.maxino = maxino;
    519  1.1      cgd 	hdr.entrytblsize = entrytblsize;
    520  1.1      cgd 	hdr.stringsize = stroff;
    521  1.1      cgd 	hdr.dumptime = dumptime;
    522  1.1      cgd 	hdr.dumpdate = dumpdate;
    523  1.1      cgd 	hdr.ntrec = ntrec;
    524  1.1      cgd 	(void) fwrite((char *)&hdr, sizeof(struct symtableheader), 1, fd);
    525  1.1      cgd 	if (ferror(fd)) {
    526  1.3      cgd 		fprintf(stderr, "fwrite: %s\n", strerror(errno));
    527  1.1      cgd 		panic("output error to file %s writing symbol table\n",
    528  1.1      cgd 			filename);
    529  1.1      cgd 	}
    530  1.1      cgd 	(void) fclose(fd);
    531  1.1      cgd }
    532  1.1      cgd 
    533  1.1      cgd /*
    534  1.1      cgd  * Initialize a symbol table from a file
    535  1.1      cgd  */
    536  1.3      cgd void
    537  1.1      cgd initsymtable(filename)
    538  1.1      cgd 	char *filename;
    539  1.1      cgd {
    540  1.1      cgd 	char *base;
    541  1.1      cgd 	long tblsize;
    542  1.1      cgd 	register struct entry *ep;
    543  1.1      cgd 	struct entry *baseep, *lep;
    544  1.1      cgd 	struct symtableheader hdr;
    545  1.1      cgd 	struct stat stbuf;
    546  1.1      cgd 	register long i;
    547  1.1      cgd 	int fd;
    548  1.1      cgd 
    549  1.1      cgd 	vprintf(stdout, "Initialize symbol table.\n");
    550  1.1      cgd 	if (filename == NULL) {
    551  1.1      cgd 		entrytblsize = maxino / HASHFACTOR;
    552  1.1      cgd 		entry = (struct entry **)
    553  1.1      cgd 			calloc((unsigned)entrytblsize, sizeof(struct entry *));
    554  1.3      cgd 		if (entry == (struct entry **)NULL)
    555  1.1      cgd 			panic("no memory for entry table\n");
    556  1.1      cgd 		ep = addentry(".", ROOTINO, NODE);
    557  1.1      cgd 		ep->e_flags |= NEW;
    558  1.1      cgd 		return;
    559  1.1      cgd 	}
    560  1.3      cgd 	if ((fd = open(filename, O_RDONLY, 0)) < 0) {
    561  1.3      cgd 		fprintf(stderr, "open: %s\n", strerror(errno));
    562  1.1      cgd 		panic("cannot open symbol table file %s\n", filename);
    563  1.1      cgd 	}
    564  1.1      cgd 	if (fstat(fd, &stbuf) < 0) {
    565  1.3      cgd 		fprintf(stderr, "stat: %s\n", strerror(errno));
    566  1.1      cgd 		panic("cannot stat symbol table file %s\n", filename);
    567  1.1      cgd 	}
    568  1.1      cgd 	tblsize = stbuf.st_size - sizeof(struct symtableheader);
    569  1.1      cgd 	base = calloc(sizeof(char), (unsigned)tblsize);
    570  1.1      cgd 	if (base == NULL)
    571  1.1      cgd 		panic("cannot allocate space for symbol table\n");
    572  1.1      cgd 	if (read(fd, base, (int)tblsize) < 0 ||
    573  1.1      cgd 	    read(fd, (char *)&hdr, sizeof(struct symtableheader)) < 0) {
    574  1.3      cgd 		fprintf(stderr, "read: %s\n", strerror(errno));
    575  1.1      cgd 		panic("cannot read symbol table file %s\n", filename);
    576  1.1      cgd 	}
    577  1.1      cgd 	switch (command) {
    578  1.1      cgd 	case 'r':
    579  1.1      cgd 		/*
    580  1.1      cgd 		 * For normal continuation, insure that we are using
    581  1.1      cgd 		 * the next incremental tape
    582  1.1      cgd 		 */
    583  1.1      cgd 		if (hdr.dumpdate != dumptime) {
    584  1.1      cgd 			if (hdr.dumpdate < dumptime)
    585  1.1      cgd 				fprintf(stderr, "Incremental tape too low\n");
    586  1.1      cgd 			else
    587  1.1      cgd 				fprintf(stderr, "Incremental tape too high\n");
    588  1.1      cgd 			done(1);
    589  1.1      cgd 		}
    590  1.1      cgd 		break;
    591  1.1      cgd 	case 'R':
    592  1.1      cgd 		/*
    593  1.1      cgd 		 * For restart, insure that we are using the same tape
    594  1.1      cgd 		 */
    595  1.1      cgd 		curfile.action = SKIP;
    596  1.1      cgd 		dumptime = hdr.dumptime;
    597  1.1      cgd 		dumpdate = hdr.dumpdate;
    598  1.1      cgd 		if (!bflag)
    599  1.1      cgd 			newtapebuf(hdr.ntrec);
    600  1.1      cgd 		getvol(hdr.volno);
    601  1.1      cgd 		break;
    602  1.1      cgd 	default:
    603  1.1      cgd 		panic("initsymtable called from command %c\n", command);
    604  1.1      cgd 		break;
    605  1.1      cgd 	}
    606  1.1      cgd 	maxino = hdr.maxino;
    607  1.1      cgd 	entrytblsize = hdr.entrytblsize;
    608  1.1      cgd 	entry = (struct entry **)
    609  1.1      cgd 		(base + tblsize - (entrytblsize * sizeof(struct entry *)));
    610  1.1      cgd 	baseep = (struct entry *)(base + hdr.stringsize - sizeof(struct entry));
    611  1.1      cgd 	lep = (struct entry *)entry;
    612  1.1      cgd 	for (i = 0; i < entrytblsize; i++) {
    613  1.3      cgd 		if (entry[i] == NULL)
    614  1.1      cgd 			continue;
    615  1.1      cgd 		entry[i] = &baseep[(long)entry[i]];
    616  1.1      cgd 	}
    617  1.1      cgd 	for (ep = &baseep[1]; ep < lep; ep++) {
    618  1.1      cgd 		ep->e_name = base + (long)ep->e_name;
    619  1.1      cgd 		ep->e_parent = &baseep[(long)ep->e_parent];
    620  1.3      cgd 		if (ep->e_sibling != NULL)
    621  1.1      cgd 			ep->e_sibling = &baseep[(long)ep->e_sibling];
    622  1.3      cgd 		if (ep->e_links != NULL)
    623  1.1      cgd 			ep->e_links = &baseep[(long)ep->e_links];
    624  1.3      cgd 		if (ep->e_entries != NULL)
    625  1.1      cgd 			ep->e_entries = &baseep[(long)ep->e_entries];
    626  1.3      cgd 		if (ep->e_next != NULL)
    627  1.1      cgd 			ep->e_next = &baseep[(long)ep->e_next];
    628  1.1      cgd 	}
    629  1.1      cgd }
    630