Home | History | Annotate | Line # | Download | only in dump
traverse.c revision 1.30
      1  1.30     lukem /*	$NetBSD: traverse.c,v 1.30 2001/05/28 00:41:14 lukem Exp $	*/
      2   1.9       cgd 
      3   1.1       cgd /*-
      4   1.4   mycroft  * Copyright (c) 1980, 1988, 1991, 1993
      5   1.4   mycroft  *	The Regents of the University of California.  All rights reserved.
      6   1.1       cgd  *
      7   1.1       cgd  * Redistribution and use in source and binary forms, with or without
      8   1.1       cgd  * modification, are permitted provided that the following conditions
      9   1.1       cgd  * are met:
     10   1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     11   1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     12   1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     13   1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     14   1.1       cgd  *    documentation and/or other materials provided with the distribution.
     15   1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     16   1.1       cgd  *    must display the following acknowledgement:
     17   1.1       cgd  *	This product includes software developed by the University of
     18   1.1       cgd  *	California, Berkeley and its contributors.
     19   1.1       cgd  * 4. Neither the name of the University nor the names of its contributors
     20   1.1       cgd  *    may be used to endorse or promote products derived from this software
     21   1.1       cgd  *    without specific prior written permission.
     22   1.1       cgd  *
     23   1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24   1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25   1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26   1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27   1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28   1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29   1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30   1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31   1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32   1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33   1.1       cgd  * SUCH DAMAGE.
     34   1.1       cgd  */
     35   1.1       cgd 
     36  1.18     lukem #include <sys/cdefs.h>
     37   1.1       cgd #ifndef lint
     38   1.9       cgd #if 0
     39  1.19     lukem static char sccsid[] = "@(#)traverse.c	8.7 (Berkeley) 6/15/95";
     40   1.9       cgd #else
     41  1.30     lukem __RCSID("$NetBSD: traverse.c,v 1.30 2001/05/28 00:41:14 lukem Exp $");
     42   1.9       cgd #endif
     43   1.1       cgd #endif /* not lint */
     44   1.1       cgd 
     45   1.4   mycroft #include <sys/param.h>
     46   1.4   mycroft #include <sys/time.h>
     47   1.4   mycroft #include <sys/stat.h>
     48   1.1       cgd #ifdef sunos
     49   1.4   mycroft #include <sys/vnode.h>
     50   1.4   mycroft 
     51   1.1       cgd #include <ufs/fs.h>
     52   1.4   mycroft #include <ufs/fsdir.h>
     53   1.4   mycroft #include <ufs/inode.h>
     54   1.1       cgd #else
     55   1.4   mycroft #include <ufs/ufs/dir.h>
     56   1.4   mycroft #include <ufs/ufs/dinode.h>
     57  1.19     lukem #include <ufs/ffs/fs.h>
     58  1.20    bouyer #include <ufs/ffs/ffs_extern.h>
     59   1.1       cgd #endif
     60   1.4   mycroft 
     61   1.1       cgd #include <protocols/dumprestore.h>
     62   1.4   mycroft 
     63   1.4   mycroft #include <ctype.h>
     64  1.17     lukem #include <errno.h>
     65  1.17     lukem #include <fts.h>
     66   1.4   mycroft #include <stdio.h>
     67   1.4   mycroft #include <string.h>
     68   1.1       cgd #include <unistd.h>
     69   1.4   mycroft 
     70   1.1       cgd #include "dump.h"
     71   1.1       cgd 
     72   1.1       cgd #define	HASDUMPEDFILE	0x1
     73   1.1       cgd #define	HASSUBDIRS	0x2
     74   1.1       cgd 
     75   1.4   mycroft #ifdef	FS_44INODEFMT
     76   1.4   mycroft typedef	quad_t fsizeT;
     77   1.4   mycroft #else
     78  1.15       cgd typedef	int32_t fsizeT;
     79   1.4   mycroft #endif
     80   1.4   mycroft 
     81  1.29     lukem static	int dirindir(ino_t, daddr_t, int, long *, long *, int);
     82  1.29     lukem static	void dmpindir(ino_t, daddr_t, int, fsizeT *);
     83  1.29     lukem static	int searchdir(ino_t, daddr_t, long, long, long *, int);
     84   1.4   mycroft 
     85   1.1       cgd /*
     86   1.1       cgd  * This is an estimation of the number of TP_BSIZE blocks in the file.
     87   1.1       cgd  * It estimates the number of blocks in files with holes by assuming
     88   1.1       cgd  * that all of the blocks accounted for by di_blocks are data blocks
     89   1.1       cgd  * (when some of the blocks are usually used for indirect pointers);
     90   1.1       cgd  * hence the estimate may be high.
     91   1.1       cgd  */
     92   1.1       cgd long
     93  1.29     lukem blockest(struct dinode *dp)
     94   1.1       cgd {
     95   1.1       cgd 	long blkest, sizeest;
     96   1.1       cgd 
     97   1.1       cgd 	/*
     98   1.1       cgd 	 * dp->di_size is the size of the file in bytes.
     99   1.1       cgd 	 * dp->di_blocks stores the number of sectors actually in the file.
    100   1.1       cgd 	 * If there are more sectors than the size would indicate, this just
    101   1.1       cgd 	 *	means that there are indirect blocks in the file or unused
    102   1.1       cgd 	 *	sectors in the last file block; we can safely ignore these
    103   1.1       cgd 	 *	(blkest = sizeest below).
    104   1.1       cgd 	 * If the file is bigger than the number of sectors would indicate,
    105   1.1       cgd 	 *	then the file has holes in it.	In this case we must use the
    106   1.1       cgd 	 *	block count to estimate the number of data blocks used, but
    107   1.1       cgd 	 *	we use the actual size for estimating the number of indirect
    108   1.1       cgd 	 *	dump blocks (sizeest vs. blkest in the indirect block
    109   1.1       cgd 	 *	calculation).
    110   1.1       cgd 	 */
    111  1.25  sommerfe 	blkest = howmany(dbtob((u_int64_t)dp->di_blocks), TP_BSIZE);
    112   1.1       cgd 	sizeest = howmany(dp->di_size, TP_BSIZE);
    113   1.1       cgd 	if (blkest > sizeest)
    114   1.1       cgd 		blkest = sizeest;
    115  1.28  perseant 	if (dp->di_size > ufsib->ufs_bsize * NDADDR) {
    116   1.1       cgd 		/* calculate the number of indirect blocks on the dump tape */
    117   1.1       cgd 		blkest +=
    118  1.28  perseant 			howmany(sizeest - NDADDR * ufsib->ufs_bsize / TP_BSIZE,
    119   1.1       cgd 			TP_NINDIR);
    120   1.1       cgd 	}
    121   1.1       cgd 	return (blkest + 1);
    122   1.1       cgd }
    123   1.1       cgd 
    124   1.4   mycroft /* Auxiliary macro to pick up files changed since previous dump. */
    125   1.4   mycroft #define	CHANGEDSINCE(dp, t) \
    126   1.4   mycroft 	((dp)->di_mtime >= (t) || (dp)->di_ctime >= (t))
    127   1.4   mycroft 
    128   1.4   mycroft /* The WANTTODUMP macro decides whether a file should be dumped. */
    129   1.4   mycroft #ifdef UF_NODUMP
    130   1.4   mycroft #define	WANTTODUMP(dp) \
    131  1.20    bouyer 	(CHANGEDSINCE(dp, iswap32(spcl.c_ddate)) && \
    132   1.4   mycroft 	 (nonodump || ((dp)->di_flags & UF_NODUMP) != UF_NODUMP))
    133   1.4   mycroft #else
    134  1.20    bouyer #define	WANTTODUMP(dp) CHANGEDSINCE(dp, iswap32(spcl.c_ddate))
    135   1.4   mycroft #endif
    136   1.4   mycroft 
    137   1.1       cgd /*
    138  1.17     lukem  * Determine if given inode should be dumped
    139  1.17     lukem  */
    140  1.17     lukem void
    141  1.29     lukem mapfileino(ino_t ino, long *tapesize, int *dirskipped)
    142  1.17     lukem {
    143  1.17     lukem 	int mode;
    144  1.17     lukem 	struct dinode *dp;
    145  1.17     lukem 
    146  1.22     lukem 	/*
    147  1.22     lukem 	 * Skip inode if we've already marked it for dumping
    148  1.22     lukem 	 */
    149  1.22     lukem 	if (TSTINO(ino, usedinomap))
    150  1.22     lukem 		return;
    151  1.17     lukem 	dp = getino(ino);
    152  1.17     lukem 	if ((mode = (dp->di_mode & IFMT)) == 0)
    153  1.17     lukem 		return;
    154  1.23    bouyer 	/*
    155  1.23    bouyer 	 * Put all dirs in dumpdirmap, inodes that are to be dumped in the
    156  1.23    bouyer 	 * used map. All inode but dirs who have the nodump attribute go
    157  1.23    bouyer 	 * to the usedinomap.
    158  1.23    bouyer 	 */
    159  1.17     lukem 	SETINO(ino, usedinomap);
    160  1.17     lukem 	if (mode == IFDIR)
    161  1.17     lukem 		SETINO(ino, dumpdirmap);
    162  1.17     lukem 	if (WANTTODUMP(dp)) {
    163  1.17     lukem 		SETINO(ino, dumpinomap);
    164  1.17     lukem 		if (mode != IFREG && mode != IFDIR && mode != IFLNK)
    165  1.17     lukem 			*tapesize += 1;
    166  1.17     lukem 		else
    167  1.17     lukem 			*tapesize += blockest(dp);
    168  1.17     lukem 		return;
    169  1.17     lukem 	}
    170  1.23    bouyer 	if (mode == IFDIR) {
    171  1.23    bouyer #ifdef UF_NODUMP
    172  1.23    bouyer 		if (!nonodump && (dp->di_flags & UF_NODUMP))
    173  1.23    bouyer 			CLRINO(ino, usedinomap);
    174  1.23    bouyer #endif
    175  1.17     lukem 		*dirskipped = 1;
    176  1.23    bouyer 	}
    177  1.17     lukem }
    178  1.17     lukem 
    179  1.17     lukem /*
    180   1.1       cgd  * Dump pass 1.
    181   1.1       cgd  *
    182   1.1       cgd  * Walk the inode list for a filesystem to find all allocated inodes
    183   1.1       cgd  * that have been modified since the previous dump time. Also, find all
    184   1.1       cgd  * the directories in the filesystem.
    185   1.1       cgd  */
    186   1.4   mycroft int
    187  1.29     lukem mapfiles(ino_t maxino, long *tapesize, char *disk, char * const *dirv)
    188   1.1       cgd {
    189   1.1       cgd 	int anydirskipped = 0;
    190   1.1       cgd 
    191  1.17     lukem 	if (dirv != NULL) {
    192  1.17     lukem 		char	 curdir[MAXPATHLEN];
    193  1.17     lukem 		FTS	*dirh;
    194  1.17     lukem 		FTSENT	*entry;
    195  1.17     lukem 		int	 d;
    196  1.17     lukem 
    197  1.17     lukem 		if (getcwd(curdir, sizeof(curdir)) == NULL) {
    198  1.17     lukem 			msg("Can't determine cwd: %s\n", strerror(errno));
    199  1.17     lukem 			dumpabort(0);
    200  1.17     lukem 		}
    201  1.17     lukem 		if ((dirh = fts_open(dirv, FTS_PHYSICAL|FTS_SEEDOT|FTS_XDEV,
    202  1.18     lukem 		    		    NULL)) == NULL) {
    203  1.17     lukem 			msg("fts_open failed: %s\n", strerror(errno));
    204  1.17     lukem 			dumpabort(0);
    205  1.17     lukem 		}
    206  1.17     lukem 		while ((entry = fts_read(dirh)) != NULL) {
    207  1.17     lukem 			switch (entry->fts_info) {
    208  1.17     lukem 			case FTS_DNR:		/* an error */
    209  1.17     lukem 			case FTS_ERR:
    210  1.17     lukem 			case FTS_NS:
    211  1.17     lukem 				msg("Can't fts_read %s: %s\n", entry->fts_path,
    212  1.17     lukem 				    strerror(errno));
    213  1.17     lukem 			case FTS_DP:		/* already seen dir */
    214  1.17     lukem 				continue;
    215  1.17     lukem 			}
    216  1.17     lukem 			mapfileino(entry->fts_statp->st_ino, tapesize,
    217  1.17     lukem 			    &anydirskipped);
    218  1.17     lukem 		}
    219  1.17     lukem 		(void)fts_close(dirh);
    220  1.17     lukem 
    221  1.17     lukem 		/*
    222  1.17     lukem 		 * Add any parent directories
    223  1.17     lukem 		 */
    224  1.17     lukem 		for (d = 0 ; dirv[d] != NULL ; d++) {
    225  1.17     lukem 			char path[MAXPATHLEN];
    226  1.17     lukem 
    227  1.17     lukem 			if (dirv[d][0] != '/')
    228  1.17     lukem 				(void)snprintf(path, sizeof(path), "%s/%s",
    229  1.17     lukem 				    curdir, dirv[d]);
    230   1.4   mycroft 			else
    231  1.17     lukem 				(void)snprintf(path, sizeof(path), "%s",
    232  1.17     lukem 				    dirv[d]);
    233  1.17     lukem 			while (strcmp(path, disk) != 0) {
    234  1.17     lukem 				char *p;
    235  1.17     lukem 				struct stat sb;
    236  1.17     lukem 
    237  1.17     lukem 				if (*path == '\0')
    238  1.17     lukem 					break;
    239  1.17     lukem 				if ((p = strrchr(path, '/')) == NULL)
    240  1.17     lukem 					break;
    241  1.17     lukem 				if (p == path)
    242  1.17     lukem 					break;
    243  1.17     lukem 				*p = '\0';
    244  1.17     lukem 				if (stat(path, &sb) == -1) {
    245  1.17     lukem 					msg("Can't stat %s: %s\n", path,
    246  1.17     lukem 					    strerror(errno));
    247  1.17     lukem 					break;
    248  1.17     lukem 				}
    249  1.17     lukem 				mapfileino(sb.st_ino, tapesize, &anydirskipped);
    250  1.17     lukem 			}
    251  1.17     lukem 		}
    252  1.17     lukem 
    253  1.17     lukem 		/*
    254  1.17     lukem 		 * Ensure that the root inode actually appears in the
    255  1.17     lukem 		 * file list for a subdir
    256  1.17     lukem 		 */
    257  1.17     lukem 		mapfileino(ROOTINO, tapesize, &anydirskipped);
    258  1.17     lukem 	} else {
    259  1.17     lukem 		ino_t ino;
    260  1.17     lukem 
    261  1.17     lukem 		for (ino = ROOTINO; ino < maxino; ino++) {
    262  1.17     lukem 			mapfileino(ino, tapesize, &anydirskipped);
    263   1.1       cgd 		}
    264   1.1       cgd 	}
    265   1.1       cgd 	/*
    266   1.1       cgd 	 * Restore gets very upset if the root is not dumped,
    267   1.1       cgd 	 * so ensure that it always is dumped.
    268   1.1       cgd 	 */
    269   1.1       cgd 	SETINO(ROOTINO, dumpinomap);
    270   1.1       cgd 	return (anydirskipped);
    271   1.1       cgd }
    272   1.1       cgd 
    273   1.1       cgd /*
    274   1.1       cgd  * Dump pass 2.
    275   1.1       cgd  *
    276   1.1       cgd  * Scan each directory on the filesystem to see if it has any modified
    277   1.1       cgd  * files in it. If it does, and has not already been added to the dump
    278   1.1       cgd  * list (because it was itself modified), then add it. If a directory
    279   1.1       cgd  * has not been modified itself, contains no modified files and has no
    280   1.1       cgd  * subdirectories, then it can be deleted from the dump list and from
    281   1.1       cgd  * the list of directories. By deleting it from the list of directories,
    282   1.1       cgd  * its parent may now qualify for the same treatment on this or a later
    283   1.1       cgd  * pass using this algorithm.
    284   1.1       cgd  */
    285   1.4   mycroft int
    286  1.29     lukem mapdirs(ino_t maxino, long *tapesize)
    287   1.1       cgd {
    288  1.23    bouyer 	struct  dinode *dp, di;
    289  1.23    bouyer 	int i, isdir, nodump;
    290  1.16     lukem 	char *map;
    291  1.16     lukem 	ino_t ino;
    292   1.1       cgd 	long filesize;
    293   1.1       cgd 	int ret, change = 0;
    294   1.1       cgd 
    295   1.4   mycroft 	isdir = 0;		/* XXX just to get gcc to shut up */
    296   1.4   mycroft 	for (map = dumpdirmap, ino = 1; ino < maxino; ino++) {
    297   1.4   mycroft 		if (((ino - 1) % NBBY) == 0)	/* map is offset by 1 */
    298   1.1       cgd 			isdir = *map++;
    299   1.1       cgd 		else
    300   1.1       cgd 			isdir >>= 1;
    301  1.23    bouyer 		/*
    302  1.23    bouyer 		 * If dir has been removed from the used map, it's either
    303  1.23    bouyer 		 * because it had the nodump flag, or it herited it from
    304  1.23    bouyer 		 * its parent. A directory can't be in dumpinomap if
    305  1.23    bouyer 		 * not in usedinomap, but we have to go throuh it anyway
    306  1.23    bouyer 		 * to propagate the nodump attribute.
    307  1.23    bouyer 		 */
    308  1.23    bouyer 		nodump = (TSTINO(ino, usedinomap) == 0);
    309  1.23    bouyer 		if ((isdir & 1) == 0 ||
    310  1.23    bouyer 		    (TSTINO(ino, dumpinomap) && nodump == 0))
    311   1.1       cgd 			continue;
    312  1.23    bouyer 
    313   1.1       cgd 		dp = getino(ino);
    314  1.23    bouyer 		di = *dp; /* inode buf may be changed in searchdir */
    315  1.23    bouyer 		filesize = di.di_size;
    316   1.1       cgd 		for (ret = 0, i = 0; filesize > 0 && i < NDADDR; i++) {
    317  1.23    bouyer 			if (di.di_db[i] != 0)
    318  1.23    bouyer 				ret |= searchdir(ino, iswap32(di.di_db[i]),
    319  1.28  perseant 					(long)ufs_dblksize(ufsib, &di, i),
    320  1.23    bouyer 					filesize, tapesize, nodump);
    321   1.1       cgd 			if (ret & HASDUMPEDFILE)
    322   1.1       cgd 				filesize = 0;
    323   1.1       cgd 			else
    324  1.28  perseant 				filesize -= ufsib->ufs_bsize;
    325   1.1       cgd 		}
    326   1.1       cgd 		for (i = 0; filesize > 0 && i < NIADDR; i++) {
    327  1.23    bouyer 			if (di.di_ib[i] == 0)
    328   1.1       cgd 				continue;
    329  1.23    bouyer 			ret |= dirindir(ino, di.di_ib[i], i, &filesize,
    330  1.23    bouyer 			    tapesize, nodump);
    331   1.1       cgd 		}
    332   1.1       cgd 		if (ret & HASDUMPEDFILE) {
    333   1.1       cgd 			SETINO(ino, dumpinomap);
    334  1.23    bouyer 			*tapesize += blockest(&di);
    335   1.1       cgd 			change = 1;
    336   1.1       cgd 			continue;
    337   1.1       cgd 		}
    338  1.23    bouyer 		if (nodump) {
    339  1.23    bouyer 			if (ret & HASSUBDIRS)
    340  1.23    bouyer 				change = 1; /* subdirs have inherited nodump */
    341  1.23    bouyer 			CLRINO(ino, dumpdirmap);
    342  1.23    bouyer 		} else if ((ret & HASSUBDIRS) == 0) {
    343   1.1       cgd 			if (!TSTINO(ino, dumpinomap)) {
    344   1.1       cgd 				CLRINO(ino, dumpdirmap);
    345   1.1       cgd 				change = 1;
    346   1.1       cgd 			}
    347   1.1       cgd 		}
    348   1.1       cgd 	}
    349   1.1       cgd 	return (change);
    350   1.1       cgd }
    351   1.1       cgd 
    352   1.1       cgd /*
    353   1.1       cgd  * Read indirect blocks, and pass the data blocks to be searched
    354   1.1       cgd  * as directories. Quit as soon as any entry is found that will
    355   1.1       cgd  * require the directory to be dumped.
    356   1.1       cgd  */
    357   1.4   mycroft static int
    358  1.29     lukem dirindir(ino_t ino, daddr_t blkno, int ind_level, long *filesize,
    359  1.29     lukem 	long *tapesize, int nodump)
    360   1.1       cgd {
    361   1.1       cgd 	int ret = 0;
    362  1.16     lukem 	int i;
    363   1.1       cgd 	daddr_t	idblk[MAXNINDIR];
    364   1.1       cgd 
    365  1.28  perseant 	bread(fsatoda(ufsib, iswap32(blkno)), (char *)idblk,
    366  1.28  perseant 		(int)ufsib->ufs_bsize);
    367   1.1       cgd 	if (ind_level <= 0) {
    368  1.28  perseant 		for (i = 0; *filesize > 0 && i < ufsib->ufs_nindir; i++) {
    369   1.1       cgd 			blkno = idblk[i];
    370   1.1       cgd 			if (blkno != 0)
    371  1.23    bouyer 				ret |= searchdir(ino, iswap32(blkno),
    372  1.28  perseant 				    ufsib->ufs_bsize, *filesize,
    373  1.23    bouyer 				    tapesize, nodump);
    374   1.1       cgd 			if (ret & HASDUMPEDFILE)
    375   1.1       cgd 				*filesize = 0;
    376   1.1       cgd 			else
    377  1.28  perseant 				*filesize -= ufsib->ufs_bsize;
    378   1.1       cgd 		}
    379   1.1       cgd 		return (ret);
    380   1.1       cgd 	}
    381   1.1       cgd 	ind_level--;
    382  1.28  perseant 	for (i = 0; *filesize > 0 && i < ufsib->ufs_nindir; i++) {
    383   1.1       cgd 		blkno = idblk[i];
    384   1.1       cgd 		if (blkno != 0)
    385  1.23    bouyer 			ret |= dirindir(ino, blkno, ind_level, filesize,
    386  1.23    bouyer 			    tapesize, nodump);
    387   1.1       cgd 	}
    388   1.1       cgd 	return (ret);
    389   1.1       cgd }
    390   1.1       cgd 
    391   1.1       cgd /*
    392   1.1       cgd  * Scan a disk block containing directory information looking to see if
    393   1.1       cgd  * any of the entries are on the dump list and to see if the directory
    394   1.1       cgd  * contains any subdirectories.
    395   1.1       cgd  */
    396   1.4   mycroft static int
    397  1.29     lukem searchdir(ino_t dino, daddr_t blkno, long size, long filesize,
    398  1.29     lukem 	long *tapesize, int nodump)
    399   1.1       cgd {
    400  1.16     lukem 	struct direct *dp;
    401  1.23    bouyer 	struct dinode *ip;
    402  1.16     lukem 	long loc, ret = 0;
    403   1.1       cgd 	char dblk[MAXBSIZE];
    404  1.23    bouyer 	ino_t ino;
    405   1.1       cgd 
    406  1.28  perseant 	bread(fsatoda(ufsib, blkno), dblk, (int)size);
    407   1.1       cgd 	if (filesize < size)
    408   1.1       cgd 		size = filesize;
    409   1.1       cgd 	for (loc = 0; loc < size; ) {
    410   1.1       cgd 		dp = (struct direct *)(dblk + loc);
    411   1.1       cgd 		if (dp->d_reclen == 0) {
    412  1.23    bouyer 			msg("corrupted directory, inumber %d\n", dino);
    413   1.1       cgd 			break;
    414   1.1       cgd 		}
    415  1.20    bouyer 		loc += iswap16(dp->d_reclen);
    416   1.1       cgd 		if (dp->d_ino == 0)
    417   1.1       cgd 			continue;
    418   1.1       cgd 		if (dp->d_name[0] == '.') {
    419   1.1       cgd 			if (dp->d_name[1] == '\0')
    420   1.1       cgd 				continue;
    421   1.1       cgd 			if (dp->d_name[1] == '.' && dp->d_name[2] == '\0')
    422   1.1       cgd 				continue;
    423   1.1       cgd 		}
    424  1.23    bouyer 		ino = iswap32(dp->d_ino);
    425  1.23    bouyer 		if (nodump) {
    426  1.23    bouyer 			ip = getino(ino);
    427  1.23    bouyer 			if (TSTINO(ino, dumpinomap)) {
    428  1.23    bouyer 				CLRINO(ino, dumpinomap);
    429  1.23    bouyer 				CLRINO(ino, usedinomap);
    430  1.23    bouyer 				*tapesize -= blockest(ip);
    431  1.23    bouyer 			}
    432  1.23    bouyer 			/* Add dir back to the dir map, to propagate nodump */
    433  1.23    bouyer 			if ((ip->di_mode & IFMT) == IFDIR) {
    434  1.23    bouyer 				SETINO(ino, dumpdirmap);
    435  1.23    bouyer 				ret |= HASSUBDIRS;
    436  1.23    bouyer 			}
    437  1.23    bouyer 		} else {
    438  1.23    bouyer 			if (TSTINO(ino, dumpinomap)) {
    439  1.23    bouyer 				ret |= HASDUMPEDFILE;
    440  1.23    bouyer 				if (ret & HASSUBDIRS)
    441  1.23    bouyer 					break;
    442  1.23    bouyer 			}
    443  1.23    bouyer 			if (TSTINO(ino, dumpdirmap)) {
    444  1.23    bouyer 				ret |= HASSUBDIRS;
    445  1.23    bouyer 				if (ret & HASDUMPEDFILE)
    446  1.23    bouyer 					break;
    447  1.23    bouyer 			}
    448   1.1       cgd 		}
    449   1.1       cgd 	}
    450   1.1       cgd 	return (ret);
    451   1.1       cgd }
    452   1.1       cgd 
    453   1.1       cgd /*
    454   1.1       cgd  * Dump passes 3 and 4.
    455   1.1       cgd  *
    456   1.1       cgd  * Dump the contents of an inode to tape.
    457   1.1       cgd  */
    458   1.1       cgd void
    459  1.29     lukem dumpino(struct dinode *dp, ino_t ino)
    460   1.1       cgd {
    461   1.1       cgd 	int ind_level, cnt;
    462   1.4   mycroft 	fsizeT size;
    463   1.1       cgd 	char buf[TP_BSIZE];
    464   1.1       cgd 
    465   1.1       cgd 	if (newtape) {
    466   1.1       cgd 		newtape = 0;
    467   1.1       cgd 		dumpmap(dumpinomap, TS_BITS, ino);
    468   1.1       cgd 	}
    469   1.1       cgd 	CLRINO(ino, dumpinomap);
    470  1.20    bouyer 	if (needswap)
    471  1.20    bouyer 		ffs_dinode_swap(dp, &spcl.c_dinode);
    472  1.20    bouyer 	else
    473  1.20    bouyer 		spcl.c_dinode = *dp;
    474  1.20    bouyer 	spcl.c_type = iswap32(TS_INODE);
    475   1.1       cgd 	spcl.c_count = 0;
    476   1.8   mycroft 	switch (dp->di_mode & IFMT) {
    477   1.1       cgd 
    478   1.4   mycroft 	case 0:
    479   1.1       cgd 		/*
    480   1.1       cgd 		 * Freed inode.
    481   1.1       cgd 		 */
    482   1.1       cgd 		return;
    483   1.1       cgd 
    484   1.8   mycroft 	case IFLNK:
    485   1.1       cgd 		/*
    486   1.1       cgd 		 * Check for short symbolic link.
    487   1.1       cgd 		 */
    488   1.5   mycroft 		if (dp->di_size > 0 &&
    489   1.4   mycroft #ifdef FS_44INODEFMT
    490  1.28  perseant 		    (dp->di_size < ufsib->ufs_maxsymlinklen ||
    491  1.29     lukem 		     (ufsib->ufs_maxsymlinklen == 0 && dp->di_blocks == 0))
    492   1.5   mycroft #else
    493  1.29     lukem 		    dp->di_blocks == 0
    494   1.5   mycroft #endif
    495  1.29     lukem 			) {
    496   1.1       cgd 			spcl.c_addr[0] = 1;
    497  1.20    bouyer 			spcl.c_count = iswap32(1);
    498   1.1       cgd 			writeheader(ino);
    499  1.19     lukem 			memmove(buf, dp->di_shortlink, (u_long)dp->di_size);
    500   1.1       cgd 			buf[dp->di_size] = '\0';
    501   1.1       cgd 			writerec(buf, 0);
    502   1.1       cgd 			return;
    503   1.1       cgd 		}
    504   1.1       cgd 		/* fall through */
    505   1.1       cgd 
    506   1.8   mycroft 	case IFDIR:
    507   1.8   mycroft 	case IFREG:
    508   1.1       cgd 		if (dp->di_size > 0)
    509   1.1       cgd 			break;
    510   1.1       cgd 		/* fall through */
    511   1.1       cgd 
    512   1.8   mycroft 	case IFIFO:
    513   1.8   mycroft 	case IFSOCK:
    514   1.8   mycroft 	case IFCHR:
    515   1.8   mycroft 	case IFBLK:
    516   1.1       cgd 		writeheader(ino);
    517   1.1       cgd 		return;
    518   1.1       cgd 
    519   1.1       cgd 	default:
    520   1.8   mycroft 		msg("Warning: undefined file type 0%o\n", dp->di_mode & IFMT);
    521   1.1       cgd 		return;
    522   1.1       cgd 	}
    523  1.28  perseant 	if (dp->di_size > NDADDR * ufsib->ufs_bsize)
    524  1.28  perseant 		cnt = NDADDR * ufsib->ufs_frag;
    525   1.1       cgd 	else
    526  1.28  perseant 		cnt = howmany(dp->di_size, ufsib->ufs_fsize);
    527   1.1       cgd 	blksout(&dp->di_db[0], cnt, ino);
    528  1.28  perseant 	if ((size = dp->di_size - NDADDR * ufsib->ufs_bsize) <= 0)
    529   1.1       cgd 		return;
    530   1.1       cgd 	for (ind_level = 0; ind_level < NIADDR; ind_level++) {
    531   1.1       cgd 		dmpindir(ino, dp->di_ib[ind_level], ind_level, &size);
    532   1.1       cgd 		if (size <= 0)
    533   1.1       cgd 			return;
    534   1.1       cgd 	}
    535   1.1       cgd }
    536   1.1       cgd 
    537   1.1       cgd /*
    538   1.1       cgd  * Read indirect blocks, and pass the data blocks to be dumped.
    539   1.1       cgd  */
    540   1.4   mycroft static void
    541  1.29     lukem dmpindir(ino_t ino, daddr_t blk, int ind_level, fsizeT *size)
    542   1.1       cgd {
    543   1.1       cgd 	int i, cnt;
    544   1.1       cgd 	daddr_t idblk[MAXNINDIR];
    545   1.1       cgd 
    546   1.1       cgd 	if (blk != 0)
    547  1.28  perseant 		bread(fsatoda(ufsib, iswap32(blk)), (char *)idblk,
    548  1.28  perseant 			(int) ufsib->ufs_bsize);
    549   1.1       cgd 	else
    550  1.28  perseant 		memset(idblk, 0, (int)ufsib->ufs_bsize);
    551   1.1       cgd 	if (ind_level <= 0) {
    552  1.28  perseant 		if (*size < ufsib->ufs_nindir * ufsib->ufs_bsize)
    553  1.28  perseant 			cnt = howmany(*size, ufsib->ufs_fsize);
    554   1.1       cgd 		else
    555  1.28  perseant 			cnt = ufsib->ufs_nindir * ufsib->ufs_frag;
    556  1.28  perseant 		*size -= ufsib->ufs_nindir * ufsib->ufs_bsize;
    557   1.1       cgd 		blksout(&idblk[0], cnt, ino);
    558   1.1       cgd 		return;
    559   1.1       cgd 	}
    560   1.1       cgd 	ind_level--;
    561  1.28  perseant 	for (i = 0; i < ufsib->ufs_nindir; i++) {
    562   1.1       cgd 		dmpindir(ino, idblk[i], ind_level, size);
    563   1.1       cgd 		if (*size <= 0)
    564   1.1       cgd 			return;
    565   1.1       cgd 	}
    566   1.1       cgd }
    567   1.1       cgd 
    568   1.1       cgd /*
    569   1.1       cgd  * Collect up the data into tape record sized buffers and output them.
    570   1.1       cgd  */
    571   1.1       cgd void
    572  1.29     lukem blksout(daddr_t *blkp, int frags, ino_t ino)
    573   1.1       cgd {
    574  1.16     lukem 	daddr_t *bp;
    575   1.1       cgd 	int i, j, count, blks, tbperdb;
    576   1.1       cgd 
    577  1.28  perseant 	blks = howmany(frags * ufsib->ufs_fsize, TP_BSIZE);
    578  1.28  perseant 	tbperdb = ufsib->ufs_bsize >> tp_bshift;
    579   1.1       cgd 	for (i = 0; i < blks; i += TP_NINDIR) {
    580   1.1       cgd 		if (i + TP_NINDIR > blks)
    581   1.1       cgd 			count = blks;
    582   1.1       cgd 		else
    583   1.1       cgd 			count = i + TP_NINDIR;
    584   1.1       cgd 		for (j = i; j < count; j++)
    585   1.1       cgd 			if (blkp[j / tbperdb] != 0)
    586   1.1       cgd 				spcl.c_addr[j - i] = 1;
    587   1.1       cgd 			else
    588   1.1       cgd 				spcl.c_addr[j - i] = 0;
    589  1.20    bouyer 		spcl.c_count = iswap32(count - i);
    590   1.1       cgd 		writeheader(ino);
    591   1.1       cgd 		bp = &blkp[i / tbperdb];
    592   1.1       cgd 		for (j = i; j < count; j += tbperdb, bp++)
    593  1.21      ross 			if (*bp != 0) {
    594   1.1       cgd 				if (j + tbperdb <= count)
    595  1.28  perseant 					dumpblock(iswap32(*bp), (int)ufsib->ufs_bsize);
    596   1.1       cgd 				else
    597  1.20    bouyer 					dumpblock(iswap32(*bp), (count - j) * TP_BSIZE);
    598  1.21      ross 			}
    599  1.20    bouyer 		spcl.c_type = iswap32(TS_ADDR);
    600   1.1       cgd 	}
    601   1.1       cgd }
    602   1.1       cgd 
    603   1.1       cgd /*
    604   1.1       cgd  * Dump a map to the tape.
    605   1.1       cgd  */
    606   1.1       cgd void
    607  1.29     lukem dumpmap(char *map, int type, ino_t ino)
    608   1.1       cgd {
    609  1.16     lukem 	int i;
    610   1.1       cgd 	char *cp;
    611   1.1       cgd 
    612  1.20    bouyer 	spcl.c_type = iswap32(type);
    613  1.20    bouyer 	spcl.c_count = iswap32(howmany(mapsize * sizeof(char), TP_BSIZE));
    614   1.1       cgd 	writeheader(ino);
    615  1.20    bouyer 	for (i = 0, cp = map; i < iswap32(spcl.c_count); i++, cp += TP_BSIZE)
    616   1.1       cgd 		writerec(cp, 0);
    617   1.1       cgd }
    618   1.1       cgd 
    619   1.1       cgd /*
    620   1.1       cgd  * Write a header record to the dump tape.
    621   1.1       cgd  */
    622   1.1       cgd void
    623  1.29     lukem writeheader(ino_t ino)
    624   1.1       cgd {
    625  1.16     lukem 	int32_t sum, cnt, *lp;
    626   1.1       cgd 
    627  1.20    bouyer 	spcl.c_inumber = iswap32(ino);
    628  1.20    bouyer 	spcl.c_magic = iswap32(NFS_MAGIC);
    629   1.1       cgd 	spcl.c_checksum = 0;
    630  1.15       cgd 	lp = (int32_t *)&spcl;
    631   1.1       cgd 	sum = 0;
    632  1.15       cgd 	cnt = sizeof(union u_spcl) / (4 * sizeof(int32_t));
    633   1.1       cgd 	while (--cnt >= 0) {
    634  1.20    bouyer 		sum += iswap32(*lp++);
    635  1.20    bouyer 		sum += iswap32(*lp++);
    636  1.20    bouyer 		sum += iswap32(*lp++);
    637  1.20    bouyer 		sum += iswap32(*lp++);
    638   1.1       cgd 	}
    639  1.20    bouyer 	spcl.c_checksum = iswap32(CHECKSUM - sum);
    640   1.1       cgd 	writerec((char *)&spcl, 1);
    641   1.1       cgd }
    642