1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause AND BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2006 Pawel Jakub Dawidek <pjd@FreeBSD.org> 5 * 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 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * Copyright (c) 1982, 1986, 1989, 1993 29 * The Regents of the University of California. All rights reserved. 30 * 31 * Redistribution and use in source and binary forms, with or without 32 * modification, are permitted provided that the following conditions 33 * are met: 34 * 1. Redistributions of source code must retain the above copyright 35 * notice, this list of conditions and the following disclaimer. 36 * 2. Redistributions in binary form must reproduce the above copyright 37 * notice, this list of conditions and the following disclaimer in the 38 * documentation and/or other materials provided with the distribution. 39 * 3. Neither the name of the University nor the names of its contributors 40 * may be used to endorse or promote products derived from this software 41 * without specific prior written permission. 42 * 43 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 44 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 46 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 47 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 48 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 49 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 50 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 51 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 52 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 53 * SUCH DAMAGE. 54 */ 55 56 #include <sys/cdefs.h> 57 __FBSDID("$FreeBSD$"); 58 59 #include <sys/param.h> 60 #include <sys/disklabel.h> 61 #include <sys/mount.h> 62 #include <sys/stat.h> 63 64 #include <ufs/ufs/ufsmount.h> 65 #include <ufs/ufs/dinode.h> 66 #include <ufs/ffs/fs.h> 67 68 #include <stdio.h> 69 #include <stdlib.h> 70 #include <stdint.h> 71 #include <libufs.h> 72 #include <strings.h> 73 #include <err.h> 74 #include <assert.h> 75 76 #include "fsck.h" 77 78 struct cgchain { 79 union { 80 struct cg cgcu_cg; 81 char cgcu_buf[MAXBSIZE]; 82 } cgc_union; 83 int cgc_busy; 84 int cgc_dirty; 85 LIST_ENTRY(cgchain) cgc_next; 86 }; 87 #define cgc_cg cgc_union.cgcu_cg 88 89 #define MAX_CACHED_CGS 1024 90 static unsigned ncgs = 0; 91 static LIST_HEAD(, cgchain) cglist = LIST_HEAD_INITIALIZER(cglist); 92 93 static const char *devnam; 94 static struct uufsd *disk = NULL; 95 static struct fs *fs = NULL; 96 struct ufs2_dinode ufs2_zino; 97 98 static void putcgs(void); 99 100 /* 101 * Return cylinder group from the cache or load it if it is not in the 102 * cache yet. 103 * Don't cache more than MAX_CACHED_CGS cylinder groups. 104 */ 105 static struct cgchain * 106 getcg(int cg) 107 { 108 struct cgchain *cgc; 109 110 assert(disk != NULL && fs != NULL); 111 LIST_FOREACH(cgc, &cglist, cgc_next) { 112 if (cgc->cgc_cg.cg_cgx == cg) { 113 //printf("%s: Found cg=%d\n", __func__, cg); 114 return (cgc); 115 } 116 } 117 /* 118 * Our cache is full? Let's clean it up. 119 */ 120 if (ncgs >= MAX_CACHED_CGS) { 121 //printf("%s: Flushing CGs.\n", __func__); 122 putcgs(); 123 } 124 cgc = malloc(sizeof(*cgc)); 125 if (cgc == NULL) { 126 /* 127 * Cannot allocate memory? 128 * Let's put all currently loaded and not busy cylinder groups 129 * on disk and try again. 130 */ 131 //printf("%s: No memory, flushing CGs.\n", __func__); 132 putcgs(); 133 cgc = malloc(sizeof(*cgc)); 134 if (cgc == NULL) 135 err(1, "malloc(%zu)", sizeof(*cgc)); 136 } 137 if (cgget(disk, cg, &cgc->cgc_cg) == -1) 138 err(1, "cgget(%d)", cg); 139 cgc->cgc_busy = 0; 140 cgc->cgc_dirty = 0; 141 LIST_INSERT_HEAD(&cglist, cgc, cgc_next); 142 ncgs++; 143 //printf("%s: Read cg=%d\n", __func__, cg); 144 return (cgc); 145 } 146 147 /* 148 * Mark cylinder group as dirty - it will be written back on putcgs(). 149 */ 150 static void 151 dirtycg(struct cgchain *cgc) 152 { 153 154 cgc->cgc_dirty = 1; 155 } 156 157 /* 158 * Mark cylinder group as busy - it will not be freed on putcgs(). 159 */ 160 static void 161 busycg(struct cgchain *cgc) 162 { 163 164 cgc->cgc_busy = 1; 165 } 166 167 /* 168 * Unmark the given cylinder group as busy. 169 */ 170 static void 171 unbusycg(struct cgchain *cgc) 172 { 173 174 cgc->cgc_busy = 0; 175 } 176 177 /* 178 * Write back all dirty cylinder groups. 179 * Free all non-busy cylinder groups. 180 */ 181 static void 182 putcgs(void) 183 { 184 struct cgchain *cgc, *cgc2; 185 186 assert(disk != NULL && fs != NULL); 187 LIST_FOREACH_SAFE(cgc, &cglist, cgc_next, cgc2) { 188 if (cgc->cgc_busy) 189 continue; 190 LIST_REMOVE(cgc, cgc_next); 191 ncgs--; 192 if (cgc->cgc_dirty) { 193 if (cgput(disk, &cgc->cgc_cg) == -1) 194 err(1, "cgput(%d)", cgc->cgc_cg.cg_cgx); 195 //printf("%s: Wrote cg=%d\n", __func__, 196 // cgc->cgc_cg.cg_cgx); 197 } 198 free(cgc); 199 } 200 } 201 202 #if 0 203 /* 204 * Free all non-busy cylinder groups without storing the dirty ones. 205 */ 206 static void 207 cancelcgs(void) 208 { 209 struct cgchain *cgc; 210 211 assert(disk != NULL && fs != NULL); 212 while ((cgc = LIST_FIRST(&cglist)) != NULL) { 213 if (cgc->cgc_busy) 214 continue; 215 LIST_REMOVE(cgc, cgc_next); 216 //printf("%s: Canceled cg=%d\n", __func__, cgc->cgc_cg.cg_cgx); 217 free(cgc); 218 } 219 } 220 #endif 221 222 /* 223 * Open the given provider, load superblock. 224 */ 225 static void 226 opendisk(void) 227 { 228 if (disk != NULL) 229 return; 230 disk = malloc(sizeof(*disk)); 231 if (disk == NULL) 232 err(1, "malloc(%zu)", sizeof(*disk)); 233 if (ufs_disk_fillout(disk, devnam) == -1) { 234 err(1, "ufs_disk_fillout(%s) failed: %s", devnam, 235 disk->d_error); 236 } 237 fs = &disk->d_fs; 238 } 239 240 /* 241 * Mark file system as clean, write the super-block back, close the disk. 242 */ 243 static void 244 closedisk(void) 245 { 246 247 fs->fs_clean = 1; 248 if (sbwrite(disk, 0) == -1) 249 err(1, "sbwrite(%s)", devnam); 250 if (ufs_disk_close(disk) == -1) 251 err(1, "ufs_disk_close(%s)", devnam); 252 free(disk); 253 disk = NULL; 254 fs = NULL; 255 } 256 257 static void 258 blkfree(ufs2_daddr_t bno, long size) 259 { 260 struct cgchain *cgc; 261 struct cg *cgp; 262 ufs1_daddr_t fragno, cgbno; 263 int i, cg, blk, frags, bbase; 264 u_int8_t *blksfree; 265 266 cg = dtog(fs, bno); 267 cgc = getcg(cg); 268 dirtycg(cgc); 269 cgp = &cgc->cgc_cg; 270 cgbno = dtogd(fs, bno); 271 blksfree = cg_blksfree(cgp); 272 if (size == fs->fs_bsize) { 273 fragno = fragstoblks(fs, cgbno); 274 if (!ffs_isfreeblock(fs, blksfree, fragno)) 275 assert(!"blkfree: freeing free block"); 276 ffs_setblock(fs, blksfree, fragno); 277 ffs_clusteracct(fs, cgp, fragno, 1); 278 cgp->cg_cs.cs_nbfree++; 279 fs->fs_cstotal.cs_nbfree++; 280 fs->fs_cs(fs, cg).cs_nbfree++; 281 } else { 282 bbase = cgbno - fragnum(fs, cgbno); 283 /* 284 * decrement the counts associated with the old frags 285 */ 286 blk = blkmap(fs, blksfree, bbase); 287 ffs_fragacct(fs, blk, cgp->cg_frsum, -1); 288 /* 289 * deallocate the fragment 290 */ 291 frags = numfrags(fs, size); 292 for (i = 0; i < frags; i++) { 293 if (isset(blksfree, cgbno + i)) 294 assert(!"blkfree: freeing free frag"); 295 setbit(blksfree, cgbno + i); 296 } 297 cgp->cg_cs.cs_nffree += i; 298 fs->fs_cstotal.cs_nffree += i; 299 fs->fs_cs(fs, cg).cs_nffree += i; 300 /* 301 * add back in counts associated with the new frags 302 */ 303 blk = blkmap(fs, blksfree, bbase); 304 ffs_fragacct(fs, blk, cgp->cg_frsum, 1); 305 /* 306 * if a complete block has been reassembled, account for it 307 */ 308 fragno = fragstoblks(fs, bbase); 309 if (ffs_isblock(fs, blksfree, fragno)) { 310 cgp->cg_cs.cs_nffree -= fs->fs_frag; 311 fs->fs_cstotal.cs_nffree -= fs->fs_frag; 312 fs->fs_cs(fs, cg).cs_nffree -= fs->fs_frag; 313 ffs_clusteracct(fs, cgp, fragno, 1); 314 cgp->cg_cs.cs_nbfree++; 315 fs->fs_cstotal.cs_nbfree++; 316 fs->fs_cs(fs, cg).cs_nbfree++; 317 } 318 } 319 } 320 321 /* 322 * Recursively free all indirect blocks. 323 */ 324 static void 325 freeindir(ufs2_daddr_t blk, int level) 326 { 327 char sblks[MAXBSIZE]; 328 ufs2_daddr_t *blks; 329 int i; 330 331 if (bread(disk, fsbtodb(fs, blk), (void *)&sblks, (size_t)fs->fs_bsize) == -1) 332 err(1, "bread: %s", disk->d_error); 333 blks = (ufs2_daddr_t *)&sblks; 334 for (i = 0; i < NINDIR(fs); i++) { 335 if (blks[i] == 0) 336 break; 337 if (level == 0) 338 blkfree(blks[i], fs->fs_bsize); 339 else 340 freeindir(blks[i], level - 1); 341 } 342 blkfree(blk, fs->fs_bsize); 343 } 344 345 #define dblksize(fs, dino, lbn) \ 346 ((dino)->di_size >= smalllblktosize(fs, (lbn) + 1) \ 347 ? (fs)->fs_bsize \ 348 : fragroundup(fs, blkoff(fs, (dino)->di_size))) 349 350 /* 351 * Free all blocks associated with the given inode. 352 */ 353 static void 354 clear_inode(struct ufs2_dinode *dino) 355 { 356 ufs2_daddr_t bn; 357 int extblocks, i, level; 358 off_t osize; 359 long bsize; 360 361 extblocks = 0; 362 if (fs->fs_magic == FS_UFS2_MAGIC && dino->di_extsize > 0) 363 extblocks = btodb(fragroundup(fs, dino->di_extsize)); 364 /* deallocate external attributes blocks */ 365 if (extblocks > 0) { 366 osize = dino->di_extsize; 367 dino->di_blocks -= extblocks; 368 dino->di_extsize = 0; 369 for (i = 0; i < UFS_NXADDR; i++) { 370 if (dino->di_extb[i] == 0) 371 continue; 372 blkfree(dino->di_extb[i], sblksize(fs, osize, i)); 373 } 374 } 375 #define SINGLE 0 /* index of single indirect block */ 376 #define DOUBLE 1 /* index of double indirect block */ 377 #define TRIPLE 2 /* index of triple indirect block */ 378 /* deallocate indirect blocks */ 379 for (level = SINGLE; level <= TRIPLE; level++) { 380 if (dino->di_ib[level] == 0) 381 break; 382 freeindir(dino->di_ib[level], level); 383 } 384 /* deallocate direct blocks and fragments */ 385 for (i = 0; i < UFS_NDADDR; i++) { 386 bn = dino->di_db[i]; 387 if (bn == 0) 388 continue; 389 bsize = dblksize(fs, dino, i); 390 blkfree(bn, bsize); 391 } 392 } 393 394 void 395 gjournal_check(const char *filesys) 396 { 397 struct ufs2_dinode *dino; 398 void *p; 399 struct cgchain *cgc; 400 struct cg *cgp; 401 uint8_t *inosused; 402 ino_t cino, ino; 403 int cg, mode; 404 405 devnam = filesys; 406 opendisk(); 407 /* Are there any unreferenced inodes in this file system? */ 408 if (fs->fs_unrefs == 0) { 409 //printf("No unreferenced inodes.\n"); 410 closedisk(); 411 return; 412 } 413 414 for (cg = 0; cg < fs->fs_ncg; cg++) { 415 /* Show progress if requested. */ 416 if (got_siginfo) { 417 printf("%s: phase j: cyl group %d of %d (%d%%)\n", 418 cdevname, cg, fs->fs_ncg, cg * 100 / fs->fs_ncg); 419 got_siginfo = 0; 420 } 421 if (got_sigalarm) { 422 setproctitle("%s pj %d%%", cdevname, 423 cg * 100 / fs->fs_ncg); 424 got_sigalarm = 0; 425 } 426 cgc = getcg(cg); 427 cgp = &cgc->cgc_cg; 428 /* Are there any unreferenced inodes in this cylinder group? */ 429 if (cgp->cg_unrefs == 0) 430 continue; 431 //printf("Analizing cylinder group %d (count=%d)\n", cg, cgp->cg_unrefs); 432 /* 433 * We are going to modify this cylinder group, so we want it to 434 * be written back. 435 */ 436 dirtycg(cgc); 437 /* We don't want it to be freed in the meantime. */ 438 busycg(cgc); 439 inosused = cg_inosused(cgp); 440 /* 441 * Now go through the list of all inodes in this cylinder group 442 * to find unreferenced ones. 443 */ 444 for (cino = 0; cino < fs->fs_ipg; cino++) { 445 ino = fs->fs_ipg * cg + cino; 446 /* Unallocated? Skip it. */ 447 if (isclr(inosused, cino)) 448 continue; 449 if (getino(disk, &p, ino, &mode) == -1) 450 err(1, "getino(cg=%d ino=%ju)", 451 cg, (uintmax_t)ino); 452 dino = p; 453 /* Not a regular file nor directory? Skip it. */ 454 if (!S_ISREG(dino->di_mode) && !S_ISDIR(dino->di_mode)) 455 continue; 456 /* Has reference(s)? Skip it. */ 457 if (dino->di_nlink > 0) 458 continue; 459 //printf("Clearing inode=%d (size=%jd)\n", ino, (intmax_t)dino->di_size); 460 /* Free inode's blocks. */ 461 clear_inode(dino); 462 /* Deallocate it. */ 463 clrbit(inosused, cino); 464 /* Update position of last used inode. */ 465 if (ino < cgp->cg_irotor) 466 cgp->cg_irotor = ino; 467 /* Update statistics. */ 468 cgp->cg_cs.cs_nifree++; 469 fs->fs_cs(fs, cg).cs_nifree++; 470 fs->fs_cstotal.cs_nifree++; 471 cgp->cg_unrefs--; 472 fs->fs_unrefs--; 473 /* If this is directory, update related statistics. */ 474 if (S_ISDIR(dino->di_mode)) { 475 cgp->cg_cs.cs_ndir--; 476 fs->fs_cs(fs, cg).cs_ndir--; 477 fs->fs_cstotal.cs_ndir--; 478 } 479 /* Zero-fill the inode. */ 480 *dino = ufs2_zino; 481 /* Write the inode back. */ 482 if (putino(disk) == -1) 483 err(1, "putino(cg=%d ino=%ju)", 484 cg, (uintmax_t)ino); 485 if (cgp->cg_unrefs == 0) { 486 //printf("No more unreferenced inodes in cg=%d.\n", cg); 487 break; 488 } 489 } 490 /* 491 * We don't need this cylinder group anymore, so feel free to 492 * free it if needed. 493 */ 494 unbusycg(cgc); 495 /* 496 * If there are no more unreferenced inodes, there is no need to 497 * check other cylinder groups. 498 */ 499 if (fs->fs_unrefs == 0) { 500 //printf("No more unreferenced inodes (cg=%d/%d).\n", cg, 501 // fs->fs_ncg); 502 break; 503 } 504 } 505 /* Write back modified cylinder groups. */ 506 putcgs(); 507 /* Write back updated statistics and super-block. */ 508 closedisk(); 509 } 510