pass1.c revision 1.34
1 /* $NetBSD: pass1.c,v 1.34 2013/06/08 02:11:11 dholland Exp $ */ 2 3 /* 4 * Copyright (c) 1980, 1986, 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/param.h> 33 #include <sys/time.h> 34 #include <sys/mount.h> 35 #include <sys/buf.h> 36 37 #define vnode uvnode 38 #define _SYS_VNODE_H_ /* XXX */ 39 #include <ufs/lfs/ulfs_inode.h> 40 #include <ufs/lfs/ulfs_dir.h> 41 #include <ufs/lfs/lfs.h> 42 #undef vnode 43 44 #include <err.h> 45 #include <stdio.h> 46 #include <stdlib.h> 47 #include <string.h> 48 #include <signal.h> 49 #include <util.h> 50 51 #include "bufcache.h" 52 #include "vnode.h" 53 #include "lfs_user.h" 54 55 #include "fsck.h" 56 #include "extern.h" 57 #include "fsutil.h" 58 59 SEGUSE *seg_table; 60 extern ulfs_daddr_t *din_table; 61 62 ulfs_daddr_t badblk; 63 static ulfs_daddr_t dupblk; 64 static int i_d_cmp(const void *, const void *); 65 66 struct ino_daddr { 67 ino_t ino; 68 ulfs_daddr_t daddr; 69 }; 70 71 static int 72 i_d_cmp(const void *va, const void *vb) 73 { 74 const struct ino_daddr *a, *b; 75 76 a = *((const struct ino_daddr *const *) va); 77 b = *((const struct ino_daddr *const *) vb); 78 79 if (a->daddr == b->daddr) { 80 return (a->ino - b->ino); 81 } 82 if (a->daddr > b->daddr) { 83 return 1; 84 } 85 return -1; 86 } 87 88 void 89 pass1(void) 90 { 91 ino_t inumber; 92 int i; 93 struct inodesc idesc; 94 struct ulfs1_dinode *tinode; 95 struct ifile *ifp; 96 struct ubuf *bp; 97 struct ino_daddr **dins; 98 99 /* 100 * Find all allocated blocks, initialize numdirs. 101 */ 102 memset(&idesc, 0, sizeof(struct inodesc)); 103 idesc.id_type = ADDR; 104 idesc.id_func = pass1check; 105 idesc.id_lblkno = 0; 106 inumber = 0; 107 n_files = n_blks = 0; 108 109 if (debug) 110 printf("creating sorted inode address table...\n"); 111 /* Sort by daddr */ 112 dins = ecalloc(maxino, sizeof(*dins)); 113 for (i = 0; i < maxino; i++) { 114 dins[i] = emalloc(sizeof(**dins)); 115 dins[i]->ino = i; 116 if (i == fs->lfs_ifile) 117 dins[i]->daddr = fs->lfs_idaddr; 118 else { 119 LFS_IENTRY(ifp, fs, i, bp); 120 dins[i]->daddr = ifp->if_daddr; 121 brelse(bp, 0); 122 } 123 } 124 qsort(dins, maxino, sizeof(*dins), i_d_cmp); 125 126 /* find a value for numdirs, fill in din_table */ 127 if (debug) 128 printf("counting dirs...\n"); 129 numdirs = 0; 130 for (i = 0; i < maxino; i++) { 131 inumber = dins[i]->ino; 132 if (inumber == 0 || dins[i]->daddr == 0) 133 continue; 134 tinode = ginode(inumber); 135 if (tinode && (tinode->di_mode & LFS_IFMT) == LFS_IFDIR) 136 numdirs++; 137 } 138 139 /* from setup.c */ 140 inplast = 0; 141 listmax = numdirs + 10; 142 inpsort = ecalloc(listmax, sizeof(struct inoinfo *)); 143 inphead = ecalloc(numdirs, sizeof(struct inoinfo *)); 144 if (debug) 145 printf("counting blocks...\n"); 146 147 for (i = 0; i < maxino; i++) { 148 inumber = dins[i]->ino; 149 if (inumber == 0 || dins[i]->daddr == 0) { 150 statemap[inumber] = USTATE; 151 continue; 152 } 153 if (dins[i]->daddr != LFS_UNUSED_DADDR) { 154 checkinode(inumber, &idesc); 155 } else { 156 statemap[inumber] = USTATE; 157 } 158 free(dins[i]); 159 } 160 free(dins); 161 } 162 163 void 164 checkinode(ino_t inumber, struct inodesc * idesc) 165 { 166 struct ulfs1_dinode *dp; 167 struct uvnode *vp; 168 struct zlncnt *zlnp; 169 struct ubuf *bp; 170 IFILE *ifp; 171 int ndb, j; 172 mode_t mode; 173 174 vp = vget(fs, inumber); 175 if (vp) 176 dp = VTOD(vp); 177 else 178 dp = NULL; 179 180 if (dp == NULL) { 181 statemap[inumber] = USTATE; 182 return; 183 } 184 mode = dp->di_mode & LFS_IFMT; 185 186 /* XXX - LFS doesn't have this particular problem (?) */ 187 if (mode == 0) { 188 if (memcmp(dp->di_db, zino.di_db, ULFS_NDADDR * sizeof(ulfs_daddr_t)) || 189 memcmp(dp->di_ib, zino.di_ib, ULFS_NIADDR * sizeof(ulfs_daddr_t)) || 190 dp->di_mode || dp->di_size) { 191 pwarn("mode=o%o, ifmt=o%o\n", dp->di_mode, mode); 192 pfatal("PARTIALLY ALLOCATED INODE I=%llu", 193 (unsigned long long)inumber); 194 if (reply("CLEAR") == 1) { 195 vp = vget(fs, inumber); 196 clearinode(inumber); 197 vnode_destroy(vp); 198 } 199 } 200 statemap[inumber] = USTATE; 201 return; 202 } 203 lastino = inumber; 204 if (/* dp->di_size < 0 || */ 205 dp->di_size + fs->lfs_bsize - 1 < dp->di_size) { 206 if (debug) 207 printf("bad size %llu:", 208 (unsigned long long) dp->di_size); 209 goto unknown; 210 } 211 if (!preen && mode == LFS_IFMT && reply("HOLD BAD BLOCK") == 1) { 212 vp = vget(fs, inumber); 213 dp = VTOD(vp); 214 dp->di_size = fs->lfs_fsize; 215 dp->di_mode = LFS_IFREG | 0600; 216 inodirty(VTOI(vp)); 217 } 218 ndb = howmany(dp->di_size, fs->lfs_bsize); 219 if (ndb < 0) { 220 if (debug) 221 printf("bad size %llu ndb %d:", 222 (unsigned long long) dp->di_size, ndb); 223 goto unknown; 224 } 225 if (mode == LFS_IFBLK || mode == LFS_IFCHR) 226 ndb++; 227 if (mode == LFS_IFLNK) { 228 /* 229 * Fake ndb value so direct/indirect block checks below 230 * will detect any garbage after symlink string. 231 */ 232 if (dp->di_size < fs->lfs_maxsymlinklen || 233 (fs->lfs_maxsymlinklen == 0 && dp->di_blocks == 0)) { 234 ndb = howmany(dp->di_size, sizeof(ulfs_daddr_t)); 235 if (ndb > ULFS_NDADDR) { 236 j = ndb - ULFS_NDADDR; 237 for (ndb = 1; j > 1; j--) 238 ndb *= NINDIR(fs); 239 ndb += ULFS_NDADDR; 240 } 241 } 242 } 243 for (j = ndb; j < ULFS_NDADDR; j++) 244 if (dp->di_db[j] != 0) { 245 if (debug) 246 printf("bad direct addr for size %lld lbn %d: 0x%x\n", 247 (long long)dp->di_size, j, (unsigned)dp->di_db[j]); 248 goto unknown; 249 } 250 for (j = 0, ndb -= ULFS_NDADDR; ndb > 0; j++) 251 ndb /= NINDIR(fs); 252 for (; j < ULFS_NIADDR; j++) 253 if (dp->di_ib[j] != 0) { 254 if (debug) 255 printf("bad indirect addr for size %lld # %d: 0x%x\n", 256 (long long)dp->di_size, j, (unsigned)dp->di_ib[j]); 257 goto unknown; 258 } 259 if (ftypeok(dp) == 0) 260 goto unknown; 261 n_files++; 262 lncntp[inumber] = dp->di_nlink; 263 if (dp->di_nlink <= 0) { 264 zlnp = emalloc(sizeof *zlnp); 265 zlnp->zlncnt = inumber; 266 zlnp->next = zlnhead; 267 zlnhead = zlnp; 268 } 269 if (mode == LFS_IFDIR) { 270 if (dp->di_size == 0) 271 statemap[inumber] = DCLEAR; 272 else 273 statemap[inumber] = DSTATE; 274 cacheino(dp, inumber); 275 } else 276 statemap[inumber] = FSTATE; 277 278 /* 279 * Check for an orphaned file. These happen when the cleaner has 280 * to rewrite blocks from a file whose directory operation (removal) 281 * is in progress. 282 */ 283 if (dp->di_nlink <= 0) { 284 LFS_IENTRY(ifp, fs, inumber, bp); 285 if (ifp->if_nextfree == LFS_ORPHAN_NEXTFREE) { 286 statemap[inumber] = (mode == LFS_IFDIR ? DCLEAR : FCLEAR); 287 /* Add this to our list of orphans */ 288 zlnp = emalloc(sizeof *zlnp); 289 zlnp->zlncnt = inumber; 290 zlnp->next = orphead; 291 orphead = zlnp; 292 } 293 brelse(bp, 0); 294 } 295 296 typemap[inumber] = IFTODT(mode); 297 badblk = dupblk = 0; 298 idesc->id_number = inumber; 299 (void) ckinode(VTOD(vp), idesc); 300 if (dp->di_blocks != idesc->id_entryno) { 301 pwarn("INCORRECT BLOCK COUNT I=%llu (%d SHOULD BE %d)", 302 (unsigned long long)inumber, dp->di_blocks, 303 idesc->id_entryno); 304 if (preen) 305 printf(" (CORRECTED)\n"); 306 else if (reply("CORRECT") == 0) 307 return; 308 VTOI(vp)->i_ffs1_blocks = idesc->id_entryno; 309 inodirty(VTOI(vp)); 310 } 311 return; 312 unknown: 313 pfatal("UNKNOWN FILE TYPE I=%llu", (unsigned long long)inumber); 314 statemap[inumber] = FCLEAR; 315 if (reply("CLEAR") == 1) { 316 statemap[inumber] = USTATE; 317 vp = vget(fs, inumber); 318 clearinode(inumber); 319 vnode_destroy(vp); 320 } 321 } 322 323 int 324 pass1check(struct inodesc *idesc) 325 { 326 int res = KEEPON; 327 int anyout, ndblks; 328 daddr_t blkno = idesc->id_blkno; 329 struct dups *dlp; 330 struct dups *new; 331 332 if ((anyout = chkrange(blkno, idesc->id_numfrags)) != 0) { 333 blkerror(idesc->id_number, "BAD", blkno); 334 if (badblk++ >= MAXBAD) { 335 pwarn("EXCESSIVE BAD BLKS I=%llu", 336 (unsigned long long)idesc->id_number); 337 if (preen) 338 printf(" (SKIPPING)\n"); 339 else if (reply("CONTINUE") == 0) 340 err(EEXIT, "%s", ""); 341 return (STOP); 342 } 343 } else if (!testbmap(blkno)) { 344 seg_table[dtosn(fs, blkno)].su_nbytes += idesc->id_numfrags * fs->lfs_fsize; 345 } 346 for (ndblks = idesc->id_numfrags; ndblks > 0; blkno++, ndblks--) { 347 if (anyout && chkrange(blkno, 1)) { 348 res = SKIP; 349 } else if (!testbmap(blkno)) { 350 n_blks++; 351 #ifndef VERBOSE_BLOCKMAP 352 setbmap(blkno); 353 #else 354 setbmap(blkno, idesc->id_number); 355 #endif 356 } else { 357 blkerror(idesc->id_number, "DUP", blkno); 358 #ifdef VERBOSE_BLOCKMAP 359 pwarn("(lbn %lld: Holder is %lld)\n", 360 (long long)idesc->id_lblkno, 361 (long long)testbmap(blkno)); 362 #endif 363 if (dupblk++ >= MAXDUP) { 364 pwarn("EXCESSIVE DUP BLKS I=%llu", 365 (unsigned long long)idesc->id_number); 366 if (preen) 367 printf(" (SKIPPING)\n"); 368 else if (reply("CONTINUE") == 0) 369 err(EEXIT, "%s", ""); 370 return (STOP); 371 } 372 new = emalloc(sizeof(struct dups)); 373 new->dup = blkno; 374 if (muldup == 0) { 375 duplist = muldup = new; 376 new->next = 0; 377 } else { 378 new->next = muldup->next; 379 muldup->next = new; 380 } 381 for (dlp = duplist; dlp != muldup; dlp = dlp->next) 382 if (dlp->dup == blkno) 383 break; 384 if (dlp == muldup && dlp->dup != blkno) 385 muldup = new; 386 } 387 /* 388 * count the number of blocks found in id_entryno 389 */ 390 idesc->id_entryno++; 391 } 392 return (res); 393 } 394
Indexes created Fri Oct 17 23:09:53 GMT 2025