sbin/dump/traverse.c

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