1 /* $NetBSD: lfs_inode.c,v 1.7 2003/04/02 10:39:25 fvdl 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. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #include <sys/cdefs.h> 37 #ifndef lint 38 __COPYRIGHT("@(#) Copyright (c) 1980, 1991, 1993, 1994\n\ 39 The Regents of the University of California. All rights reserved.\n"); 40 #endif /* not lint */ 41 42 #ifndef lint 43 #if 0 44 static char sccsid[] = "@(#)main.c 8.6 (Berkeley) 5/1/95"; 45 #else 46 __RCSID("$NetBSD: lfs_inode.c,v 1.7 2003/04/02 10:39:25 fvdl Exp $"); 47 #endif 48 #endif /* not lint */ 49 50 #include <sys/param.h> 51 #include <sys/time.h> 52 #include <sys/stat.h> 53 #include <ufs/ufs/dir.h> 54 #include <ufs/ufs/dinode.h> 55 #include <sys/mount.h> 56 #include <ufs/lfs/lfs.h> 57 58 #include <protocols/dumprestore.h> 59 60 #include <ctype.h> 61 #include <errno.h> 62 #include <fts.h> 63 #include <stdio.h> 64 #include <string.h> 65 #include <unistd.h> 66 67 #include "dump.h" 68 69 #define MAXIFPB (MAXBSIZE / sizeof(IFILE)) 70 71 #define HASDUMPEDFILE 0x1 72 #define HASSUBDIRS 0x2 73 74 struct lfs *sblock; 75 76 int is_ufs2 = 0; 77 78 /* 79 * Read the superblock from disk, and check its magic number. 80 * Determine whether byte-swapping needs to be done on this filesystem. 81 */ 82 int 83 fs_read_sblock(char *superblock) 84 { 85 char tbuf[LFS_SBPAD]; 86 int ns = 0; 87 off_t sboff = LFS_LABELPAD; 88 89 sblock = (struct lfs *)superblock; 90 while(1) { 91 rawread(sboff, (char *) sblock, LFS_SBPAD); 92 if (sblock->lfs_magic != LFS_MAGIC) { 93 #ifdef notyet 94 if (sblock->lfs_magic == bswap32(LFS_MAGIC)) { 95 lfs_sb_swap(sblock, sblock, 0); 96 ns = 1; 97 } else 98 #endif 99 quit("bad sblock magic number\n"); 100 } 101 if (fsbtob(sblock, sblock->lfs_sboffs[0]) != sboff) { 102 sboff = fsbtob(sblock, sblock->lfs_sboffs[0]); 103 continue; 104 } 105 break; 106 } 107 108 /* 109 * Read the secondary and take the older of the two 110 */ 111 rawread(fsbtob(sblock, sblock->lfs_sboffs[1]), tbuf, LFS_SBPAD); 112 #ifdef notyet 113 if (ns) 114 lfs_sb_swap(tbuf, tbuf, 0); 115 #endif 116 if (((struct lfs *)tbuf)->lfs_magic != LFS_MAGIC) { 117 msg("Warning: secondary superblock at 0x%x bad magic\n", 118 fsbtodb(sblock, sblock->lfs_sboffs[1])); 119 } else { 120 if (sblock->lfs_version > 1) { 121 if (((struct lfs *)tbuf)->lfs_serial < sblock->lfs_serial) { 122 memcpy(sblock, tbuf, LFS_SBPAD); 123 sboff = fsbtob(sblock, sblock->lfs_sboffs[1]); 124 } 125 } else { 126 if (((struct lfs *)tbuf)->lfs_otstamp < sblock->lfs_otstamp) { 127 memcpy(sblock, tbuf, LFS_SBPAD); 128 sboff = fsbtob(sblock, sblock->lfs_sboffs[1]); 129 } 130 } 131 } 132 if (sboff != LFS_SBPAD) { 133 msg("Using superblock at alternate location 0x%lx\n", 134 (unsigned long)(btodb(sboff))); 135 } 136 137 return ns; 138 } 139 140 /* 141 * Fill in the ufsi struct, as well as the maxino and dev_bsize global 142 * variables. 143 */ 144 struct ufsi * 145 fs_parametrize(void) 146 { 147 static struct ufsi ufsi; 148 149 spcl.c_flags = iswap32(iswap32(spcl.c_flags) | DR_NEWINODEFMT); 150 151 ufsi.ufs_dsize = fsbtodb(sblock,sblock->lfs_size); 152 if (sblock->lfs_version == 1) 153 ufsi.ufs_dsize = sblock->lfs_size >> sblock->lfs_blktodb; 154 ufsi.ufs_bsize = sblock->lfs_bsize; 155 ufsi.ufs_bshift = sblock->lfs_bshift; 156 ufsi.ufs_fsize = sblock->lfs_fsize; 157 ufsi.ufs_frag = sblock->lfs_frag; 158 ufsi.ufs_fsatoda = sblock->lfs_fsbtodb; 159 if (sblock->lfs_version == 1) 160 ufsi.ufs_fsatoda = 0; 161 ufsi.ufs_nindir = sblock->lfs_nindir; 162 ufsi.ufs_inopb = sblock->lfs_inopb; 163 ufsi.ufs_maxsymlinklen = sblock->lfs_maxsymlinklen; 164 ufsi.ufs_bmask = ~(sblock->lfs_bmask); 165 ufsi.ufs_qbmask = sblock->lfs_bmask; 166 ufsi.ufs_fmask = ~(sblock->lfs_ffmask); 167 ufsi.ufs_qfmask = sblock->lfs_ffmask; 168 169 dev_bsize = sblock->lfs_bsize >> sblock->lfs_blktodb; 170 171 return &ufsi; 172 } 173 174 ino_t 175 fs_maxino(void) 176 { 177 return ((getino(sblock->lfs_ifile)->dp1.di_size 178 - (sblock->lfs_cleansz + sblock->lfs_segtabsz) 179 * sblock->lfs_bsize) 180 / sblock->lfs_bsize) * sblock->lfs_ifpb - 1; 181 } 182 183 void 184 fs_mapinodes(ino_t maxino, u_int64_t *tapesz, int *anydirskipped) 185 { 186 ino_t ino; 187 188 for (ino = ROOTINO; ino < maxino; ino++) 189 mapfileino(ino, tapesz, anydirskipped); 190 } 191 192 /* 193 * XXX KS - I know there's a better way to do this. 194 */ 195 #define BASE_SINDIR (NDADDR) 196 #define BASE_DINDIR (NDADDR+NINDIR(fs)) 197 #define BASE_TINDIR (NDADDR+NINDIR(fs)+NINDIR(fs)*NINDIR(fs)) 198 199 #define D_UNITS (NINDIR(fs)) 200 #define T_UNITS (NINDIR(fs)*NINDIR(fs)) 201 202 static daddr_t 203 lfs_bmap(struct lfs *fs, struct ufs1_dinode *idinode, daddr_t lbn) 204 { 205 daddr_t residue, up; 206 int off=0; 207 char bp[MAXBSIZE]; 208 209 if(lbn > 0 && lbn > lblkno(fs, idinode->di_size)) { 210 return UNASSIGNED; 211 } 212 /* 213 * Indirect blocks: if it is a first-level indirect, pull its 214 * address from the inode; otherwise, call ourselves to find the 215 * address of the parent indirect block, and load that to find 216 * the desired address. 217 */ 218 if(lbn < 0) { 219 lbn *= -1; 220 if(lbn == NDADDR) { 221 /* printf("lbn %d: single indir base\n", -lbn); */ 222 return idinode->di_ib[0]; /* single indirect */ 223 } else if(lbn == BASE_DINDIR+1) { 224 /* printf("lbn %d: double indir base\n", -lbn); */ 225 return idinode->di_ib[1]; /* double indirect */ 226 } else if(lbn == BASE_TINDIR+2) { 227 /* printf("lbn %d: triple indir base\n", -lbn); */ 228 return idinode->di_ib[2]; /* triple indirect */ 229 } 230 231 /* 232 * Find the immediate parent. This is essentially finding the 233 * residue of modulus, and then rounding accordingly. 234 */ 235 residue = (lbn-NDADDR) % NINDIR(fs); 236 if(residue == 1) { 237 /* Double indirect. Parent is the triple. */ 238 up = idinode->di_ib[2]; 239 off = (lbn-2-BASE_TINDIR)/(NINDIR(fs)*NINDIR(fs)); 240 if(up == UNASSIGNED || up == LFS_UNUSED_DADDR) 241 return UNASSIGNED; 242 /* printf("lbn %d: parent is the triple\n", -lbn); */ 243 bread(fsbtodb(sblock, up), bp, sblock->lfs_bsize); 244 /* XXX ondisk32 */ 245 return (daddr_t)((int32_t *)bp)[off]; 246 } else /* residue == 0 */ { 247 /* Single indirect. Two cases. */ 248 if(lbn < BASE_TINDIR) { 249 /* Parent is the double, simple */ 250 up = -(BASE_DINDIR) - 1; 251 off = (lbn-BASE_DINDIR) / D_UNITS; 252 /* printf("lbn %d: parent is %d/%d\n", -lbn, up,off); */ 253 } else { 254 /* Ancestor is the triple, more complex */ 255 up = ((lbn-BASE_TINDIR) / T_UNITS) 256 * T_UNITS + BASE_TINDIR + 1; 257 off = (lbn/D_UNITS) - (up/D_UNITS); 258 up = -up; 259 /* printf("lbn %d: parent is %d/%d\n", -lbn, up,off); */ 260 } 261 } 262 } else { 263 /* Direct block. Its parent must be a single indirect. */ 264 if(lbn < NDADDR) 265 return idinode->di_db[lbn]; 266 else { 267 /* Parent is an indirect block. */ 268 up = -(((lbn-NDADDR) / D_UNITS) * D_UNITS + NDADDR); 269 off = (lbn-NDADDR) % D_UNITS; 270 /* printf("lbn %d: parent is %d/%d\n", lbn,up,off); */ 271 } 272 } 273 up = lfs_bmap(fs,idinode,up); 274 if(up == UNASSIGNED || up == LFS_UNUSED_DADDR) 275 return UNASSIGNED; 276 bread(fsbtodb(sblock, up), bp, sblock->lfs_bsize); 277 /* XXX ondisk32 */ 278 return (daddr_t)((int32_t *)bp)[off]; 279 } 280 281 static struct ifile * 282 lfs_ientry(ino_t ino) 283 { 284 static struct ifile ifileblock[MAXIFPB]; 285 static daddr_t ifblkno; 286 daddr_t lbn; 287 daddr_t blkno; 288 union dinode *dp; 289 290 lbn = ino/sblock->lfs_ifpb + sblock->lfs_cleansz + sblock->lfs_segtabsz; 291 dp = getino(sblock->lfs_ifile); 292 blkno = lfs_bmap(sblock, &dp->dp1 ,lbn); 293 if (blkno != ifblkno) 294 bread(fsbtodb(sblock, blkno), (char *)ifileblock, 295 sblock->lfs_bsize); 296 return ifileblock + (ino % sblock->lfs_ifpb); 297 } 298 299 /* Search a block for a specific dinode. */ 300 static struct ufs1_dinode * 301 lfs_ifind(struct lfs *fs, ino_t ino, struct ufs1_dinode *dip) 302 { 303 register int cnt; 304 305 for(cnt=0;cnt<INOPB(fs);cnt++) 306 if(dip[cnt].di_inumber == ino) 307 return &(dip[cnt]); 308 return NULL; 309 } 310 311 union dinode * 312 getino(inum) 313 ino_t inum; 314 { 315 static daddr_t inoblkno; 316 daddr_t blkno; 317 static struct ufs1_dinode inoblock[MAXBSIZE / sizeof (struct ufs1_dinode)]; 318 static struct ufs1_dinode ifile_dinode; /* XXX fill this in */ 319 static struct ufs1_dinode empty_dinode; /* Always stays zeroed */ 320 struct ufs1_dinode *dp; 321 322 if(inum == sblock->lfs_ifile) { 323 /* Load the ifile inode if not already */ 324 if(ifile_dinode.di_u.inumber == 0) { 325 blkno = sblock->lfs_idaddr; 326 bread(fsbtodb(sblock, blkno), (char *)inoblock, 327 (int)sblock->lfs_bsize); 328 dp = lfs_ifind(sblock, inum, inoblock); 329 ifile_dinode = *dp; /* Structure copy */ 330 } 331 return (union dinode *)&ifile_dinode; 332 } 333 334 curino = inum; 335 blkno = lfs_ientry(inum)->if_daddr; 336 if(blkno == LFS_UNUSED_DADDR) 337 return (union dinode *)&empty_dinode; 338 339 if(blkno != inoblkno) { 340 bread(fsbtodb(sblock, blkno), (char *)inoblock, 341 (int)sblock->lfs_bsize); 342 #ifdef notyet 343 if (needswap) 344 for (i = 0; i < MAXINOPB; i++) 345 ffs_dinode_swap(&inoblock[i], &inoblock[i]); 346 #endif 347 } 348 return (union dinode *)lfs_ifind(sblock, inum, inoblock); 349 } 350