1 /* $NetBSD: lfs_inode.c,v 1.2 1999/10/01 04:35:23 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. 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.2 1999/10/01 04:35:23 perseant 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 #ifdef __STDC__ 65 #include <string.h> 66 #include <unistd.h> 67 #endif 68 69 #include "dump.h" 70 71 #define MAXIFPB (MAXBSIZE / sizeof(IFILE)) 72 73 #define HASDUMPEDFILE 0x1 74 #define HASSUBDIRS 0x2 75 76 struct lfs *sblock; 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 *sblock_buf) 84 { 85 int needswap = 0; 86 87 sblock = (struct lfs *)sblock_buf; 88 rawread(LFS_LABELPAD, (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 needswap = 1; 94 } else 95 #endif 96 quit("bad sblock magic number\n"); 97 } 98 return needswap; 99 } 100 101 /* 102 * Fill in the ufsi struct, as well as the maxino and dev_bsize global 103 * variables. 104 */ 105 struct ufsi * 106 fs_parametrize(void) 107 { 108 static struct ufsi ufsi; 109 110 spcl.c_flags = iswap32(iswap32(spcl.c_flags) | DR_NEWINODEFMT); 111 112 ufsi.ufs_dsize = fsbtodb(sblock,sblock->lfs_size); 113 ufsi.ufs_bsize = sblock->lfs_bsize; 114 ufsi.ufs_bshift = sblock->lfs_bshift; 115 ufsi.ufs_fsize = sblock->lfs_fsize; 116 ufsi.ufs_frag = sblock->lfs_frag; 117 ufsi.ufs_fsatoda = 0; 118 ufsi.ufs_nindir = sblock->lfs_nindir; 119 ufsi.ufs_inopb = sblock->lfs_inopb; 120 ufsi.ufs_maxsymlinklen = sblock->lfs_maxsymlinklen; 121 ufsi.ufs_bmask = ~(sblock->lfs_bmask); 122 ufsi.ufs_qbmask = sblock->lfs_bmask; 123 ufsi.ufs_fmask = ~(sblock->lfs_ffmask); 124 ufsi.ufs_qfmask = sblock->lfs_ffmask; 125 126 dev_bsize = sblock->lfs_bsize >> sblock->lfs_fsbtodb; 127 128 return &ufsi; 129 } 130 131 ino_t 132 fs_maxino(void) 133 { 134 return ((getino(sblock->lfs_ifile)->di_size 135 - (sblock->lfs_cleansz + sblock->lfs_segtabsz) 136 * sblock->lfs_bsize) 137 / sblock->lfs_bsize) * sblock->lfs_ifpb - 1; 138 } 139 140 /* 141 * XXX KS - I know there's a better way to do this. 142 */ 143 #define BASE_SINDIR (NDADDR) 144 #define BASE_DINDIR (NDADDR+NINDIR(fs)) 145 #define BASE_TINDIR (NDADDR+NINDIR(fs)+NINDIR(fs)*NINDIR(fs)) 146 147 #define D_UNITS (NINDIR(fs)) 148 #define T_UNITS (NINDIR(fs)*NINDIR(fs)) 149 150 static daddr_t 151 lfs_bmap(struct lfs *fs, struct dinode *idinode, ufs_daddr_t lbn) 152 { 153 ufs_daddr_t residue, up; 154 int off=0; 155 char bp[MAXBSIZE]; 156 157 if(lbn > 0 && lbn > (idinode->di_size-1)/dev_bsize) { 158 return UNASSIGNED; 159 } 160 /* 161 * Indirect blocks: if it is a first-level indirect, pull its 162 * address from the inode; otherwise, call ourselves to find the 163 * address of the parent indirect block, and load that to find 164 * the desired address. 165 */ 166 if(lbn < 0) { 167 lbn *= -1; 168 if(lbn == NDADDR) { 169 /* printf("lbn %d: single indir base\n", -lbn); */ 170 return idinode->di_ib[0]; /* single indirect */ 171 } else if(lbn == BASE_DINDIR+1) { 172 /* printf("lbn %d: double indir base\n", -lbn); */ 173 return idinode->di_ib[1]; /* double indirect */ 174 } else if(lbn == BASE_TINDIR+2) { 175 /* printf("lbn %d: triple indir base\n", -lbn); */ 176 return idinode->di_ib[2]; /* triple indirect */ 177 } 178 179 /* 180 * Find the immediate parent. This is essentially finding the 181 * residue of modulus, and then rounding accordingly. 182 */ 183 residue = (lbn-NDADDR) % NINDIR(fs); 184 if(residue == 1) { 185 /* Double indirect. Parent is the triple. */ 186 up = idinode->di_ib[2]; 187 off = (lbn-2-BASE_TINDIR)/(NINDIR(fs)*NINDIR(fs)); 188 if(up == UNASSIGNED || up == LFS_UNUSED_DADDR) 189 return UNASSIGNED; 190 /* printf("lbn %d: parent is the triple\n", -lbn); */ 191 bread(up, bp, sblock->lfs_bsize); 192 return ((daddr_t *)bp)[off]; 193 } else /* residue == 0 */ { 194 /* Single indirect. Two cases. */ 195 if(lbn < BASE_TINDIR) { 196 /* Parent is the double, simple */ 197 up = -(BASE_DINDIR) - 1; 198 off = (lbn-BASE_DINDIR) / D_UNITS; 199 /* printf("lbn %d: parent is %d/%d\n", -lbn, up,off); */ 200 } else { 201 /* Ancestor is the triple, more complex */ 202 up = ((lbn-BASE_TINDIR) / T_UNITS) 203 * T_UNITS + BASE_TINDIR + 1; 204 off = (lbn/D_UNITS) - (up/D_UNITS); 205 up = -up; 206 /* printf("lbn %d: parent is %d/%d\n", -lbn, up,off); */ 207 } 208 } 209 } else { 210 /* Direct block. Its parent must be a single indirect. */ 211 if(lbn < NDADDR) 212 return idinode->di_db[lbn]; 213 else { 214 /* Parent is an indirect block. */ 215 up = -(((lbn-NDADDR) / D_UNITS) * D_UNITS + NDADDR); 216 off = (lbn-NDADDR) % D_UNITS; 217 /* printf("lbn %d: parent is %d/%d\n", lbn,up,off); */ 218 } 219 } 220 up = lfs_bmap(fs,idinode,up); 221 if(up == UNASSIGNED || up == LFS_UNUSED_DADDR) 222 return UNASSIGNED; 223 bread(up, bp, sblock->lfs_bsize); 224 return ((daddr_t *)bp)[off]; 225 } 226 227 static struct ifile * 228 lfs_ientry(ino_t ino) 229 { 230 static struct ifile ifileblock[MAXIFPB]; 231 static daddr_t ifblkno; 232 ufs_daddr_t lbn; 233 daddr_t blkno; 234 235 lbn = ino/sblock->lfs_ifpb + sblock->lfs_cleansz + sblock->lfs_segtabsz; 236 blkno = lfs_bmap(sblock,getino(sblock->lfs_ifile),lbn); 237 if(blkno != ifblkno) 238 bread(blkno, (char *)ifileblock, sblock->lfs_bsize); 239 return ifileblock + (ino%sblock->lfs_ifpb); 240 } 241 242 /* Search a block for a specific dinode. */ 243 static struct dinode * 244 lfs_ifind(struct lfs *fs, ino_t ino, struct dinode *dip) 245 { 246 register int cnt; 247 248 for(cnt=0;cnt<INOPB(fs);cnt++) 249 if(dip[cnt].di_inumber == ino) 250 return &(dip[cnt]); 251 return NULL; 252 } 253 254 struct dinode * 255 getino(inum) 256 ino_t inum; 257 { 258 static daddr_t inoblkno; 259 daddr_t blkno; 260 static struct dinode inoblock[MAXINOPB]; 261 static struct dinode ifile_dinode; /* XXX fill this in */ 262 static struct dinode empty_dinode; /* Always stays zeroed */ 263 struct dinode *dp; 264 265 if(inum == sblock->lfs_ifile) { 266 /* Load the ifile inode if not already */ 267 if(ifile_dinode.di_u.inumber == 0) { 268 blkno = sblock->lfs_idaddr; 269 bread(blkno, (char *)inoblock, (int)sblock->lfs_bsize); 270 dp = lfs_ifind(sblock, inum, inoblock); 271 ifile_dinode = *dp; /* Structure copy */ 272 } 273 return &ifile_dinode; 274 } 275 276 curino = inum; 277 blkno = lfs_ientry(inum)->if_daddr; 278 if(blkno == LFS_UNUSED_DADDR) 279 return &empty_dinode; 280 281 if(blkno != inoblkno) { 282 bread(blkno, (char *)inoblock, (int)sblock->lfs_bsize); 283 #ifdef notyet 284 if (needswap) 285 for (i = 0; i < MAXINOPB; i++) 286 ffs_dinode_swap(&inoblock[i], &inoblock[i]); 287 #endif 288 } 289 return lfs_ifind(sblock, inum, inoblock); 290 } 291