sbin/dump_lfs/lfs_inode.c

   1 /*      $NetBSD: lfs_inode.c,v 1.13 2006/09/28 23:23:01 perseant Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1980, 1991, 1993, 1994
   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 __COPYRIGHT("@(#) Copyright (c) 1980, 1991, 1993, 1994\
  35  The Regents of the University of California.  All rights reserved.");
  36 #endif /* not lint */
  37
  38 #ifndef lint
  39 #if 0
  40 static char sccsid[] = "@(#)main.c      8.6 (Berkeley) 5/1/95";
  41 #else
  42 __RCSID("$NetBSD: lfs_inode.c,v 1.13 2006/09/28 23:23:01 perseant Exp $");
  43 #endif
  44 #endif /* not lint */
  45
  46 #include <sys/param.h>
  47 #include <sys/time.h>
  48 #include <sys/stat.h>
  49 #include <ufs/ufs/dir.h>
  50 #include <ufs/ufs/dinode.h>
  51 #include <sys/mount.h>
  52 #include <ufs/lfs/lfs.h>
  53
  54 #include <protocols/dumprestore.h>
  55
  56 #include <ctype.h>
  57 #include <errno.h>
  58 #include <fcntl.h>
  59 #include <fts.h>
  60 #include <stdio.h>
  61 #include <string.h>
  62 #include <unistd.h>
  63
  64 #include "dump.h"
  65
  66 #define MAXIFPB        (MAXBSIZE / sizeof(IFILE))
  67
  68 #define HASDUMPEDFILE   0x1
  69 #define HASSUBDIRS      0x2
  70
  71 struct lfs *sblock;
  72
  73 int is_ufs2 = 0;
  74
  75 /*
  76  * Read the superblock from disk, and check its magic number.
  77  * Determine whether byte-swapping needs to be done on this filesystem.
  78  */
  79 int
  80 fs_read_sblock(char *superblock)
  81 {
  82         char tbuf[LFS_SBPAD];
  83         int ns = 0;
  84         off_t sboff = LFS_LABELPAD;
  85
  86         sblock = (struct lfs *)superblock;
  87         while(1) {
  88                 rawread(sboff, (char *) sblock, LFS_SBPAD);
  89                 if (sblock->lfs_magic != LFS_MAGIC) {
  90 #ifdef notyet
  91                         if (sblock->lfs_magic == bswap32(LFS_MAGIC)) {
  92                                 lfs_sb_swap(sblock, sblock, 0);
  93                                 ns = 1;
  94                         } else
  95 #endif
  96                                 quit("bad sblock magic number\n");
  97                 }
  98                 if (fsbtob(sblock, (off_t)sblock->lfs_sboffs[0]) != sboff) {
  99                         sboff = fsbtob(sblock, (off_t)sblock->lfs_sboffs[0]);
 100                         continue;
 101                 }
 102                 break;
 103         }
 104
 105         /*
 106          * Read the secondary and take the older of the two
 107          */
 108         rawread(fsbtob(sblock, (off_t)sblock->lfs_sboffs[1]), tbuf, LFS_SBPAD);
 109 #ifdef notyet
 110         if (ns)
 111                 lfs_sb_swap(tbuf, tbuf, 0);
 112 #endif
 113         if (((struct lfs *)tbuf)->lfs_magic != LFS_MAGIC) {
 114                 msg("Warning: secondary superblock at 0x%" PRIx64 " bad magic\n",
 115                         fsbtodb(sblock, (off_t)sblock->lfs_sboffs[1]));
 116         } else {
 117                 if (sblock->lfs_version > 1) {
 118                         if (((struct lfs *)tbuf)->lfs_serial < sblock->lfs_serial) {
 119                                 memcpy(sblock, tbuf, LFS_SBPAD);
 120                                 sboff = fsbtob(sblock, (off_t)sblock->lfs_sboffs[1]);
 121                         }
 122                 } else {
 123                         if (((struct lfs *)tbuf)->lfs_otstamp < sblock->lfs_otstamp) {
 124                                 memcpy(sblock, tbuf, LFS_SBPAD);
 125                                 sboff = fsbtob(sblock, (off_t)sblock->lfs_sboffs[1]);
 126                         }
 127                 }
 128         }
 129         if (sboff != LFS_SBPAD) {
 130                 msg("Using superblock at alternate location 0x%lx\n",
 131                     (unsigned long)(btodb(sboff)));
 132         }
 133
 134         return ns;
 135 }
 136
 137 /*
 138  * Fill in the ufsi struct, as well as the maxino and dev_bsize global
 139  * variables.
 140  */
 141 struct ufsi *
 142 fs_parametrize(void)
 143 {
 144         static struct ufsi ufsi;
 145
 146         spcl.c_flags = iswap32(iswap32(spcl.c_flags) | DR_NEWINODEFMT);
 147
 148         ufsi.ufs_dsize = fsbtodb(sblock,sblock->lfs_size);
 149         if (sblock->lfs_version == 1)
 150                 ufsi.ufs_dsize = sblock->lfs_size >> sblock->lfs_blktodb;
 151         ufsi.ufs_bsize = sblock->lfs_bsize;
 152         ufsi.ufs_bshift = sblock->lfs_bshift;
 153         ufsi.ufs_fsize = sblock->lfs_fsize;
 154         ufsi.ufs_frag = sblock->lfs_frag;
 155         ufsi.ufs_fsatoda = sblock->lfs_fsbtodb;
 156         if (sblock->lfs_version == 1)
 157                 ufsi.ufs_fsatoda = 0;
 158         ufsi.ufs_nindir = sblock->lfs_nindir;
 159         ufsi.ufs_inopb = sblock->lfs_inopb;
 160         ufsi.ufs_maxsymlinklen = sblock->lfs_maxsymlinklen;
 161         ufsi.ufs_bmask = ~(sblock->lfs_bmask);
 162         ufsi.ufs_qbmask = sblock->lfs_bmask;
 163         ufsi.ufs_fmask = ~(sblock->lfs_ffmask);
 164         ufsi.ufs_qfmask = sblock->lfs_ffmask;
 165
 166         dev_bsize = sblock->lfs_bsize >> sblock->lfs_blktodb;
 167
 168         return &ufsi;
 169 }
 170
 171 ino_t
 172 fs_maxino(void)
 173 {
 174         return ((getino(sblock->lfs_ifile)->dp1.di_size
 175                    - (sblock->lfs_cleansz + sblock->lfs_segtabsz)
 176                    * sblock->lfs_bsize)
 177                   / sblock->lfs_bsize) * sblock->lfs_ifpb - 1;
 178 }
 179
 180 void
 181 fs_mapinodes(ino_t maxino, u_int64_t *tapesz, int *anydirskipped)
 182 {
 183         ino_t ino;
 184
 185         for (ino = ROOTINO; ino < maxino; ino++)
 186                 mapfileino(ino, tapesz, anydirskipped);
 187 }
 188
 189 /*
 190  * XXX KS - I know there's a better way to do this.
 191  */
 192 #define BASE_SINDIR (NDADDR)
 193 #define BASE_DINDIR (NDADDR+NINDIR(fs))
 194 #define BASE_TINDIR (NDADDR+NINDIR(fs)+NINDIR(fs)*NINDIR(fs))
 195
 196 #define D_UNITS (NINDIR(fs))
 197 #define T_UNITS (NINDIR(fs)*NINDIR(fs))
 198
 199 static daddr_t
 200 lfs_bmap(struct lfs *fs, struct ufs1_dinode *idinode, daddr_t lbn)
 201 {
 202         daddr_t residue, up;
 203         int off=0;
 204         char bp[MAXBSIZE];
 205
 206         up = UNASSIGNED;        /* XXXGCC -Wunitialized [sh3] */
 207
 208         if(lbn > 0 && lbn > lblkno(fs, idinode->di_size)) {
 209                 return UNASSIGNED;
 210         }
 211         /*
 212          * Indirect blocks: if it is a first-level indirect, pull its
 213          * address from the inode; otherwise, call ourselves to find the
 214          * address of the parent indirect block, and load that to find
 215          * the desired address.
 216          */
 217         if(lbn < 0) {
 218                 lbn *= -1;
 219                 if(lbn == NDADDR) {
 220                         /* printf("lbn %d: single indir base\n", -lbn); */
 221                         return idinode->di_ib[0]; /* single indirect */
 222                 } else if(lbn == BASE_DINDIR+1) {
 223                         /* printf("lbn %d: double indir base\n", -lbn); */
 224                         return idinode->di_ib[1]; /* double indirect */
 225                 } else if(lbn == BASE_TINDIR+2) {
 226                         /* printf("lbn %d: triple indir base\n", -lbn); */
 227                         return idinode->di_ib[2]; /* triple indirect */
 228                 }
 229
 230                 /*
 231                  * Find the immediate parent. This is essentially finding the
 232                  * residue of modulus, and then rounding accordingly.
 233                  */
 234                 residue = (lbn-NDADDR) % NINDIR(fs);
 235                 if(residue == 1) {
 236                         /* Double indirect.  Parent is the triple. */
 237                         up = idinode->di_ib[2];
 238                         off = (lbn-2-BASE_TINDIR)/(NINDIR(fs)*NINDIR(fs));
 239                         if(up == UNASSIGNED || up == LFS_UNUSED_DADDR)
 240                                 return UNASSIGNED;
 241                         /* printf("lbn %d: parent is the triple\n", -lbn); */
 242                         bread(fsbtodb(sblock, up), bp, sblock->lfs_bsize);
 243                         /* XXX ondisk32 */
 244                         return (daddr_t)((int32_t *)bp)[off];
 245                 } else /* residue == 0 */ {
 246                         /* Single indirect.  Two cases. */
 247                         if(lbn < BASE_TINDIR) {
 248                                 /* Parent is the double, simple */
 249                                 up = -(BASE_DINDIR) - 1;
 250                                 off = (lbn-BASE_DINDIR) / D_UNITS;
 251                                 /* printf("lbn %d: parent is %d/%d\n", -lbn, up,off); */
 252                         } else {
 253                                 /* Ancestor is the triple, more complex */
 254                                 up = ((lbn-BASE_TINDIR) / T_UNITS)
 255                                         * T_UNITS + BASE_TINDIR + 1;
 256                                 off = (lbn/D_UNITS) - (up/D_UNITS);
 257                                 up = -up;
 258                                 /* printf("lbn %d: parent is %d/%d\n", -lbn, up,off); */
 259                         }
 260                 }
 261         } else {
 262                 /* Direct block.  Its parent must be a single indirect. */
 263                 if(lbn < NDADDR)
 264                         return idinode->di_db[lbn];
 265                 else {
 266                         /* Parent is an indirect block. */
 267                         up = -(((lbn-NDADDR) / D_UNITS) * D_UNITS + NDADDR);
 268                         off = (lbn-NDADDR) % D_UNITS;
 269                         /* printf("lbn %d: parent is %d/%d\n", lbn,up,off); */
 270                 }
 271         }
 272         up = lfs_bmap(fs,idinode,up);
 273         if(up == UNASSIGNED || up == LFS_UNUSED_DADDR)
 274                 return UNASSIGNED;
 275         bread(fsbtodb(sblock, up), bp, sblock->lfs_bsize);
 276         /* XXX ondisk32 */
 277         return (daddr_t)((int32_t *)bp)[off];
 278 }
 279
 280 static struct ifile *
 281 lfs_ientry(ino_t ino)
 282 {
 283         static struct ifile ifileblock[MAXIFPB];
 284         static daddr_t ifblkno;
 285         daddr_t lbn;
 286         daddr_t blkno;
 287         union dinode *dp;
 288
 289         lbn = ino/sblock->lfs_ifpb + sblock->lfs_cleansz + sblock->lfs_segtabsz;
 290         dp = getino(sblock->lfs_ifile);
 291         blkno = lfs_bmap(sblock, &dp->dp1 ,lbn);
 292         if (blkno != ifblkno)
 293                 bread(fsbtodb(sblock, blkno), (char *)ifileblock,
 294                     sblock->lfs_bsize);
 295         return ifileblock + (ino % sblock->lfs_ifpb);
 296 }
 297
 298 /* Search a block for a specific dinode. */
 299 static struct ufs1_dinode *
 300 lfs_ifind(struct lfs *fs, ino_t ino, struct ufs1_dinode *dip)
 301 {
 302         int cnt;
 303
 304         for(cnt=0;cnt<INOPB(fs);cnt++)
 305                 if(dip[cnt].di_inumber == ino)
 306                         return &(dip[cnt]);
 307         return NULL;
 308 }
 309
 310 union dinode *
 311 getino(ino_t inum)
 312 {
 313         static daddr_t inoblkno;
 314         daddr_t blkno;
 315         static struct ufs1_dinode inoblock[MAXBSIZE / sizeof (struct ufs1_dinode)];
 316         static struct ufs1_dinode ifile_dinode; /* XXX fill this in */
 317         static struct ufs1_dinode empty_dinode; /* Always stays zeroed */
 318         struct ufs1_dinode *dp;
 319
 320         if(inum == sblock->lfs_ifile) {
 321                 /* Load the ifile inode if not already */
 322                 if(ifile_dinode.di_u.inumber == 0) {
 323                         blkno = sblock->lfs_idaddr;
 324                         bread(fsbtodb(sblock, blkno), (char *)inoblock,
 325                                 (int)sblock->lfs_bsize);
 326                         dp = lfs_ifind(sblock, inum, inoblock);
 327                         ifile_dinode = *dp; /* Structure copy */
 328                 }
 329                 return (union dinode *)&ifile_dinode;
 330         }
 331
 332         curino = inum;
 333         blkno = lfs_ientry(inum)->if_daddr;
 334         if(blkno == LFS_UNUSED_DADDR)
 335                 return (union dinode *)&empty_dinode;
 336
 337         if(blkno != inoblkno) {
 338                 bread(fsbtodb(sblock, blkno), (char *)inoblock,
 339                         (int)sblock->lfs_bsize);
 340 #ifdef notyet
 341                 if (needswap)
 342                         for (i = 0; i < MAXINOPB; i++)
 343                                 ffs_dinode_swap(&inoblock[i], &inoblock[i]);
 344 #endif
 345         }
 346         return (union dinode *)lfs_ifind(sblock, inum, inoblock);
 347 }
 348
 349 /*
 350  * Tell the filesystem not to overwrite any currently dirty segments
 351  * until we are finished.  (It may still write into clean segments, of course,
 352  * since we're not using those.)  This is only called when dump_lfs is called
 353  * with -X, i.e. we are working on a mounted filesystem.
 354  */
 355 static int root_fd = -1;
 356 char *wrap_mpname;
 357
 358 int
 359 lfs_wrap_stop(char *mpname)
 360 {
 361         int waitfor = 0;
 362
 363         root_fd = open(mpname, O_RDONLY, 0);
 364         if (root_fd < 0)
 365                 return -1;
 366         wrap_mpname = mpname;
 367         fcntl(root_fd, LFCNREWIND, -1); /* Ignore return value */
 368         if (fcntl(root_fd, LFCNWRAPSTOP, &waitfor) < 0) {
 369                 perror("LFCNWRAPSTOP");
 370                 return -1;
 371         }
 372         msg("Disabled log wrap on %s\n", mpname);
 373         return 0;
 374 }
 375
 376 /*
 377  * Allow the filesystem to continue normal operation.
 378  * This would happen anyway when we exit; we do it explicitly here
 379  * to show the message, for the user's benefit.
 380  */
 381 void
 382 lfs_wrap_go(void)
 383 {
 384         int waitfor = 0;
 385
 386         if (root_fd < 0)
 387                 return;
 388
 389         fcntl(root_fd, LFCNWRAPGO, &waitfor);
 390         close(root_fd);
 391         root_fd = -1;
 392         msg("Re-enabled log wrap on %s\n", wrap_mpname);
 393 }