sbin/fsck_ffs/gjournal.c

   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 }