2 * Copyright 2009, 2010 Jeffrey W. Roberson <jeff@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include <sys/param.h>
32 #include <sys/disklabel.h>
33 #include <sys/mount.h>
36 #include <ufs/ufs/ufsmount.h>
37 #include <ufs/ufs/dinode.h>
38 #include <ufs/ufs/dir.h>
39 #include <ufs/ffs/fs.h>
56 #define DOTDOT_OFFSET DIRECTSIZ(1)
57 #define SUJ_HASHSIZE 2048
58 #define SUJ_HASHMASK (SUJ_HASHSIZE - 1)
59 #define SUJ_HASH(x) ((x * 2654435761) & SUJ_HASHMASK)
62 TAILQ_ENTRY(suj_seg) ss_next;
63 struct jsegrec ss_rec;
68 TAILQ_ENTRY(suj_rec) sr_next;
71 TAILQ_HEAD(srechd, suj_rec);
74 LIST_ENTRY(suj_ino) si_next;
75 struct srechd si_recs;
76 struct srechd si_newrecs;
77 struct srechd si_movs;
78 struct jtrncrec *si_trunc;
89 LIST_HEAD(inohd, suj_ino);
92 LIST_ENTRY(suj_blk) sb_next;
93 struct srechd sb_recs;
96 LIST_HEAD(blkhd, suj_blk);
99 LIST_ENTRY(data_blk) db_next;
107 LIST_ENTRY(ino_blk) ib_next;
112 LIST_HEAD(iblkhd, ino_blk);
115 LIST_ENTRY(suj_cg) sc_next;
116 struct blkhd sc_blkhash[SUJ_HASHSIZE];
117 struct inohd sc_inohash[SUJ_HASHSIZE];
118 struct iblkhd sc_iblkhash[SUJ_HASHSIZE];
119 struct ino_blk *sc_lastiblk;
120 struct suj_ino *sc_lastino;
121 struct suj_blk *sc_lastblk;
128 LIST_HEAD(cghd, suj_cg) cghash[SUJ_HASHSIZE];
129 LIST_HEAD(dblkhd, data_blk) dbhash[SUJ_HASHSIZE];
130 struct suj_cg *lastcg;
131 struct data_blk *lastblk;
133 TAILQ_HEAD(seghd, suj_seg) allsegs;
135 static struct uufsd *disk = NULL;
136 static struct fs *fs = NULL;
140 * Summary statistics.
149 static jmp_buf jmpbuf;
151 typedef void (*ino_visitor)(ino_t, ufs_lbn_t, ufs2_daddr_t, int);
152 static void err_suj(const char *, ...) __dead2;
153 static void ino_trunc(ino_t, off_t);
154 static void ino_decr(ino_t);
155 static void ino_adjust(struct suj_ino *);
156 static void ino_build(struct suj_ino *);
157 static int blk_isfree(ufs2_daddr_t);
166 err(EX_OSERR, "malloc(%zu)", n);
171 * When hit a fatal error in journalling check, print out
172 * the error and then offer to fallback to normal fsck.
175 err_suj(const char * restrict fmt, ...)
180 (void)fprintf(stdout, "%s: ", cdevname);
183 (void)vfprintf(stdout, fmt, ap);
190 * Open the given provider, load superblock.
193 opendisk(const char *devnam)
197 disk = Malloc(sizeof(*disk));
199 err(EX_OSERR, "malloc(%zu)", sizeof(*disk));
200 if (ufs_disk_fillout(disk, devnam) == -1) {
201 err(EX_OSERR, "ufs_disk_fillout(%s) failed: %s", devnam,
205 if (real_dev_bsize == 0 && ioctl(disk->d_fd, DIOCGSECTORSIZE,
206 &real_dev_bsize) == -1)
207 real_dev_bsize = secsize;
209 printf("dev_bsize %u\n", real_dev_bsize);
213 * Mark file system as clean, write the super-block back, close the disk.
216 closedisk(const char *devnam)
222 * Recompute the fs summary info from correct cs summaries.
224 bzero(&fs->fs_cstotal, sizeof(struct csum_total));
225 for (i = 0; i < fs->fs_ncg; i++) {
226 cgsum = &fs->fs_cs(fs, i);
227 fs->fs_cstotal.cs_nffree += cgsum->cs_nffree;
228 fs->fs_cstotal.cs_nbfree += cgsum->cs_nbfree;
229 fs->fs_cstotal.cs_nifree += cgsum->cs_nifree;
230 fs->fs_cstotal.cs_ndir += cgsum->cs_ndir;
232 fs->fs_pendinginodes = 0;
233 fs->fs_pendingblocks = 0;
235 fs->fs_time = time(NULL);
236 fs->fs_mtime = time(NULL);
237 if (sbwrite(disk, 0) == -1)
238 err(EX_OSERR, "sbwrite(%s)", devnam);
239 if (ufs_disk_close(disk) == -1)
240 err(EX_OSERR, "ufs_disk_close(%s)", devnam);
247 * Lookup a cg by number in the hash so we can keep track of which cgs
248 * need stats rebuilt.
250 static struct suj_cg *
256 if (cgx < 0 || cgx >= fs->fs_ncg)
257 err_suj("Bad cg number %d\n", cgx);
258 if (lastcg && lastcg->sc_cgx == cgx)
260 hd = &cghash[SUJ_HASH(cgx)];
261 LIST_FOREACH(sc, hd, sc_next)
262 if (sc->sc_cgx == cgx) {
266 sc = errmalloc(sizeof(*sc));
267 bzero(sc, sizeof(*sc));
268 sc->sc_cgbuf = errmalloc(fs->fs_bsize);
269 sc->sc_cgp = (struct cg *)sc->sc_cgbuf;
271 LIST_INSERT_HEAD(hd, sc, sc_next);
272 if (bread(disk, fsbtodb(fs, cgtod(fs, sc->sc_cgx)), sc->sc_cgbuf,
274 err_suj("Unable to read cylinder group %d\n", sc->sc_cgx);
280 * Lookup an inode number in the hash and allocate a suj_ino if it does
283 static struct suj_ino *
284 ino_lookup(ino_t ino, int creat)
286 struct suj_ino *sino;
290 sc = cg_lookup(ino_to_cg(fs, ino));
291 if (sc->sc_lastino && sc->sc_lastino->si_ino == ino)
292 return (sc->sc_lastino);
293 hd = &sc->sc_inohash[SUJ_HASH(ino)];
294 LIST_FOREACH(sino, hd, si_next)
295 if (sino->si_ino == ino)
299 sino = errmalloc(sizeof(*sino));
300 bzero(sino, sizeof(*sino));
302 TAILQ_INIT(&sino->si_recs);
303 TAILQ_INIT(&sino->si_newrecs);
304 TAILQ_INIT(&sino->si_movs);
305 LIST_INSERT_HEAD(hd, sino, si_next);
311 * Lookup a block number in the hash and allocate a suj_blk if it does
314 static struct suj_blk *
315 blk_lookup(ufs2_daddr_t blk, int creat)
317 struct suj_blk *sblk;
321 sc = cg_lookup(dtog(fs, blk));
322 if (sc->sc_lastblk && sc->sc_lastblk->sb_blk == blk)
323 return (sc->sc_lastblk);
324 hd = &sc->sc_blkhash[SUJ_HASH(fragstoblks(fs, blk))];
325 LIST_FOREACH(sblk, hd, sb_next)
326 if (sblk->sb_blk == blk)
330 sblk = errmalloc(sizeof(*sblk));
331 bzero(sblk, sizeof(*sblk));
333 TAILQ_INIT(&sblk->sb_recs);
334 LIST_INSERT_HEAD(hd, sblk, sb_next);
339 static struct data_blk *
340 dblk_lookup(ufs2_daddr_t blk)
342 struct data_blk *dblk;
345 hd = &dbhash[SUJ_HASH(fragstoblks(fs, blk))];
346 if (lastblk && lastblk->db_blk == blk)
348 LIST_FOREACH(dblk, hd, db_next)
349 if (dblk->db_blk == blk)
352 * The inode block wasn't located, allocate a new one.
354 dblk = errmalloc(sizeof(*dblk));
355 bzero(dblk, sizeof(*dblk));
356 LIST_INSERT_HEAD(hd, dblk, db_next);
362 dblk_read(ufs2_daddr_t blk, int size)
364 struct data_blk *dblk;
366 dblk = dblk_lookup(blk);
368 * I doubt size mismatches can happen in practice but it is trivial
371 if (size != dblk->db_size) {
374 dblk->db_buf = errmalloc(size);
375 dblk->db_size = size;
376 if (bread(disk, fsbtodb(fs, blk), dblk->db_buf, size) == -1)
377 err_suj("Failed to read data block %jd\n", blk);
379 return (dblk->db_buf);
383 dblk_dirty(ufs2_daddr_t blk)
385 struct data_blk *dblk;
387 dblk = dblk_lookup(blk);
394 struct data_blk *dblk;
397 for (i = 0; i < SUJ_HASHSIZE; i++) {
398 LIST_FOREACH(dblk, &dbhash[i], db_next) {
399 if (dblk->db_dirty == 0 || dblk->db_size == 0)
401 if (bwrite(disk, fsbtodb(fs, dblk->db_blk),
402 dblk->db_buf, dblk->db_size) == -1)
403 err_suj("Unable to write block %jd\n",
409 static union dinode *
412 struct ino_blk *iblk;
418 blk = ino_to_fsba(fs, ino);
419 sc = cg_lookup(ino_to_cg(fs, ino));
420 iblk = sc->sc_lastiblk;
421 if (iblk && iblk->ib_blk == blk)
423 hd = &sc->sc_iblkhash[SUJ_HASH(fragstoblks(fs, blk))];
424 LIST_FOREACH(iblk, hd, ib_next)
425 if (iblk->ib_blk == blk)
428 * The inode block wasn't located, allocate a new one.
430 iblk = errmalloc(sizeof(*iblk));
431 bzero(iblk, sizeof(*iblk));
432 iblk->ib_buf = errmalloc(fs->fs_bsize);
434 LIST_INSERT_HEAD(hd, iblk, ib_next);
435 if (bread(disk, fsbtodb(fs, blk), iblk->ib_buf, fs->fs_bsize) == -1)
436 err_suj("Failed to read inode block %jd\n", blk);
438 sc->sc_lastiblk = iblk;
439 off = ino_to_fsbo(fs, ino);
440 if (fs->fs_magic == FS_UFS1_MAGIC)
441 return (union dinode *)&((struct ufs1_dinode *)iblk->ib_buf)[off];
443 return (union dinode *)&((struct ufs2_dinode *)iblk->ib_buf)[off];
449 struct ino_blk *iblk;
454 blk = ino_to_fsba(fs, ino);
455 sc = cg_lookup(ino_to_cg(fs, ino));
456 iblk = sc->sc_lastiblk;
457 if (iblk && iblk->ib_blk == blk) {
461 hd = &sc->sc_iblkhash[SUJ_HASH(fragstoblks(fs, blk))];
462 LIST_FOREACH(iblk, hd, ib_next) {
463 if (iblk->ib_blk == blk) {
473 iblk_write(struct ino_blk *iblk)
476 if (iblk->ib_dirty == 0)
478 if (bwrite(disk, fsbtodb(fs, iblk->ib_blk), iblk->ib_buf,
480 err_suj("Failed to write inode block %jd\n", iblk->ib_blk);
484 blk_overlaps(struct jblkrec *brec, ufs2_daddr_t start, int frags)
491 bstart = brec->jb_blkno + brec->jb_oldfrags;
492 bend = bstart + brec->jb_frags;
493 if (start < bend && end > bstart)
499 blk_equals(struct jblkrec *brec, ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t start,
503 if (brec->jb_ino != ino || brec->jb_lbn != lbn)
505 if (brec->jb_blkno + brec->jb_oldfrags != start)
507 if (brec->jb_frags < frags)
513 blk_setmask(struct jblkrec *brec, int *mask)
517 for (i = brec->jb_oldfrags; i < brec->jb_oldfrags + brec->jb_frags; i++)
522 * Determine whether a given block has been reallocated to a new location.
523 * Returns a mask of overlapping bits if any frags have been reused or
524 * zero if the block has not been re-used and the contents can be trusted.
526 * This is used to ensure that an orphaned pointer due to truncate is safe
527 * to be freed. The mask value can be used to free partial blocks.
530 blk_freemask(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t lbn, int frags)
532 struct suj_blk *sblk;
533 struct suj_rec *srec;
534 struct jblkrec *brec;
539 * To be certain we're not freeing a reallocated block we lookup
540 * this block in the blk hash and see if there is an allocation
541 * journal record that overlaps with any fragments in the block
542 * we're concerned with. If any fragments have ben reallocated
543 * the block has already been freed and re-used for another purpose.
546 sblk = blk_lookup(blknum(fs, blk), 0);
549 off = blk - sblk->sb_blk;
550 TAILQ_FOREACH(srec, &sblk->sb_recs, sr_next) {
551 brec = (struct jblkrec *)srec->sr_rec;
553 * If the block overlaps but does not match
554 * exactly this record refers to the current
557 if (blk_overlaps(brec, blk, frags) == 0)
559 if (blk_equals(brec, ino, lbn, blk, frags) == 1)
562 blk_setmask(brec, &mask);
565 printf("blk_freemask: blk %jd sblk %jd off %d mask 0x%X\n",
566 blk, sblk->sb_blk, off, mask);
567 return (mask >> off);
571 * Determine whether it is safe to follow an indirect. It is not safe
572 * if any part of the indirect has been reallocated or the last journal
573 * entry was an allocation. Just allocated indirects may not have valid
574 * pointers yet and all of their children will have their own records.
575 * It is also not safe to follow an indirect if the cg bitmap has been
576 * cleared as a new allocation may write to the block prior to the journal
579 * Returns 1 if it's safe to follow the indirect and 0 otherwise.
582 blk_isindir(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t lbn)
584 struct suj_blk *sblk;
585 struct jblkrec *brec;
587 sblk = blk_lookup(blk, 0);
590 if (TAILQ_EMPTY(&sblk->sb_recs))
592 brec = (struct jblkrec *)TAILQ_LAST(&sblk->sb_recs, srechd)->sr_rec;
593 if (blk_equals(brec, ino, lbn, blk, fs->fs_frag))
594 if (brec->jb_op == JOP_FREEBLK)
595 return (!blk_isfree(blk));
600 * Clear an inode from the cg bitmap. If the inode was already clear return
601 * 0 so the caller knows it does not have to check the inode contents.
604 ino_free(ino_t ino, int mode)
611 cg = ino_to_cg(fs, ino);
612 ino = ino % fs->fs_ipg;
615 inosused = cg_inosused(cgp);
617 * The bitmap may never have made it to the disk so we have to
618 * conditionally clear. We can avoid writing the cg in this case.
620 if (isclr(inosused, ino))
623 clrbit(inosused, ino);
624 if (ino < cgp->cg_irotor)
625 cgp->cg_irotor = ino;
626 cgp->cg_cs.cs_nifree++;
627 if ((mode & IFMT) == IFDIR) {
629 cgp->cg_cs.cs_ndir--;
637 * Free 'frags' frags starting at filesystem block 'bno' skipping any frags
641 blk_free(ufs2_daddr_t bno, int mask, int frags)
643 ufs1_daddr_t fragno, cgbno;
650 printf("Freeing %d frags at blk %jd mask 0x%x\n",
655 cgbno = dtogd(fs, bno);
656 blksfree = cg_blksfree(cgp);
659 * If it's not allocated we only wrote the journal entry
660 * and never the bitmaps. Here we unconditionally clear and
661 * resolve the cg summary later.
663 if (frags == fs->fs_frag && mask == 0) {
664 fragno = fragstoblks(fs, cgbno);
665 ffs_setblock(fs, blksfree, fragno);
669 * deallocate the fragment
671 for (i = 0; i < frags; i++)
672 if ((mask & (1 << i)) == 0 && isclr(blksfree, cgbno +i)) {
674 setbit(blksfree, cgbno + i);
681 * Returns 1 if the whole block starting at 'bno' is marked free and 0
685 blk_isfree(ufs2_daddr_t bno)
689 sc = cg_lookup(dtog(fs, bno));
690 return ffs_isblock(fs, cg_blksfree(sc->sc_cgp), dtogd(fs, bno));
694 * Fetch an indirect block to find the block at a given lbn. The lbn
695 * may be negative to fetch a specific indirect block pointer or positive
696 * to fetch a specific block.
699 indir_blkatoff(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t cur, ufs_lbn_t lbn)
710 level = lbn_level(cur);
712 err_suj("Invalid indir lbn %jd\n", lbn);
713 if (level == 0 && lbn < 0)
714 err_suj("Invalid lbn %jd\n", lbn);
715 bap2 = (void *)dblk_read(blk, fs->fs_bsize);
718 base = -(cur + level);
719 for (i = level; i > 0; i--)
720 lbnadd *= NINDIR(fs);
722 i = (lbn - base) / lbnadd;
724 i = (-lbn - base) / lbnadd;
725 if (i < 0 || i >= NINDIR(fs))
726 err_suj("Invalid indirect index %d produced by lbn %jd\n",
729 cur = base + (i * lbnadd);
731 cur = -(base + (i * lbnadd)) - (level - 1);
732 if (fs->fs_magic == FS_UFS1_MAGIC)
739 err_suj("Invalid lbn %jd at level 0\n", lbn);
740 return indir_blkatoff(blk, ino, cur, lbn);
744 * Finds the disk block address at the specified lbn within the inode
745 * specified by ip. This follows the whole tree and honors di_size and
746 * di_extsize so it is a true test of reachability. The lbn may be
747 * negative if an extattr or indirect block is requested.
750 ino_blkatoff(union dinode *ip, ino_t ino, ufs_lbn_t lbn, int *frags)
758 * Handle extattr blocks first.
760 if (lbn < 0 && lbn >= -NXADDR) {
762 if (lbn > lblkno(fs, ip->dp2.di_extsize - 1))
764 *frags = numfrags(fs, sblksize(fs, ip->dp2.di_extsize, lbn));
765 return (ip->dp2.di_extb[lbn]);
768 * Now direct and indirect.
770 if (DIP(ip, di_mode) == IFLNK &&
771 DIP(ip, di_size) < fs->fs_maxsymlinklen)
773 if (lbn >= 0 && lbn < NDADDR) {
774 *frags = numfrags(fs, sblksize(fs, DIP(ip, di_size), lbn));
775 return (DIP(ip, di_db[lbn]));
777 *frags = fs->fs_frag;
779 for (i = 0, tmpval = NINDIR(fs), cur = NDADDR; i < NIADDR; i++,
780 tmpval *= NINDIR(fs), cur = next) {
783 return (DIP(ip, di_ib[i]));
785 * Determine whether the lbn in question is within this tree.
787 if (lbn < 0 && -lbn >= next)
789 if (lbn > 0 && lbn >= next)
791 return indir_blkatoff(DIP(ip, di_ib[i]), ino, -cur - i, lbn);
793 err_suj("lbn %jd not in ino\n", lbn);
798 * Determine whether a block exists at a particular lbn in an inode.
799 * Returns 1 if found, 0 if not. lbn may be negative for indirects
803 blk_isat(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int *frags)
810 if (DIP(ip, di_nlink) == 0 || DIP(ip, di_mode) == 0)
812 nblk = ino_blkatoff(ip, ino, lbn, frags);
814 return (nblk == blk);
818 * Clear the directory entry at diroff that should point to child. Minimal
819 * checking is done and it is assumed that this path was verified with isat.
822 ino_clrat(ino_t parent, off_t diroff, ino_t child)
834 printf("Clearing inode %d from parent %d at offset %jd\n",
835 child, parent, diroff);
837 lbn = lblkno(fs, diroff);
838 doff = blkoff(fs, diroff);
839 dip = ino_read(parent);
840 blk = ino_blkatoff(dip, parent, lbn, &frags);
841 blksize = sblksize(fs, DIP(dip, di_size), lbn);
842 block = dblk_read(blk, blksize);
843 dp = (struct direct *)&block[doff];
844 if (dp->d_ino != child)
845 errx(1, "Inode %d does not exist in %d at %jd",
846 child, parent, diroff);
850 * The actual .. reference count will already have been removed
851 * from the parent by the .. remref record.
856 * Determines whether a pointer to an inode exists within a directory
857 * at a specified offset. Returns the mode of the found entry.
860 ino_isat(ino_t parent, off_t diroff, ino_t child, int *mode, int *isdot)
873 dip = ino_read(parent);
874 *mode = DIP(dip, di_mode);
875 if ((*mode & IFMT) != IFDIR) {
878 * This can happen if the parent inode
882 printf("Directory %d has bad mode %o\n",
885 printf("Directory %d has zero mode\n", parent);
889 lbn = lblkno(fs, diroff);
890 doff = blkoff(fs, diroff);
891 blksize = sblksize(fs, DIP(dip, di_size), lbn);
892 if (diroff + DIRECTSIZ(1) > DIP(dip, di_size) || doff >= blksize) {
894 printf("ino %d absent from %d due to offset %jd"
895 " exceeding size %jd\n",
896 child, parent, diroff, DIP(dip, di_size));
899 blk = ino_blkatoff(dip, parent, lbn, &frags);
902 printf("Sparse directory %d", parent);
905 block = dblk_read(blk, blksize);
907 * Walk through the records from the start of the block to be
908 * certain we hit a valid record and not some junk in the middle
909 * of a file name. Stop when we reach or pass the expected offset.
911 dpoff = (doff / DIRBLKSIZ) * DIRBLKSIZ;
913 dp = (struct direct *)&block[dpoff];
916 if (dp->d_reclen == 0)
918 dpoff += dp->d_reclen;
919 } while (dpoff <= doff);
920 if (dpoff > fs->fs_bsize)
921 err_suj("Corrupt directory block in dir ino %d\n", parent);
925 printf("ino %d not found in %d, lbn %jd, dpoff %d\n",
926 child, parent, lbn, dpoff);
930 * We found the item in question. Record the mode and whether it's
931 * a . or .. link for the caller.
933 if (dp->d_ino == child) {
936 else if (dp->d_namlen == 2 &&
937 dp->d_name[0] == '.' && dp->d_name[1] == '.')
939 *mode = DTTOIF(dp->d_type);
943 printf("ino %d doesn't match dirent ino %d in parent %d\n",
944 child, dp->d_ino, parent);
948 #define VISIT_INDIR 0x0001
949 #define VISIT_EXT 0x0002
950 #define VISIT_ROOT 0x0004 /* Operation came via root & valid pointers. */
953 * Read an indirect level which may or may not be linked into an inode.
956 indir_visit(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, uint64_t *frags,
957 ino_visitor visitor, int flags)
968 * Don't visit indirect blocks with contents we can't trust. This
969 * should only happen when indir_visit() is called to complete a
970 * truncate that never finished and not when a pointer is found via
975 level = lbn_level(lbn);
977 err_suj("Invalid level for lbn %jd\n", lbn);
978 if ((flags & VISIT_ROOT) == 0 && blk_isindir(blk, ino, lbn) == 0) {
980 printf("blk %jd ino %d lbn %jd(%d) is not indir.\n",
981 blk, ino, lbn, level);
985 for (i = level; i > 0; i--)
986 lbnadd *= NINDIR(fs);
987 bap1 = (void *)dblk_read(blk, fs->fs_bsize);
989 for (i = 0; i < NINDIR(fs); i++) {
990 if (fs->fs_magic == FS_UFS1_MAGIC)
997 nlbn = -lbn + i * lbnadd;
998 (*frags) += fs->fs_frag;
999 visitor(ino, nlbn, nblk, fs->fs_frag);
1001 nlbn = (lbn + 1) - (i * lbnadd);
1002 indir_visit(ino, nlbn, nblk, frags, visitor, flags);
1006 if (flags & VISIT_INDIR) {
1007 (*frags) += fs->fs_frag;
1008 visitor(ino, lbn, blk, fs->fs_frag);
1013 * Visit each block in an inode as specified by 'flags' and call a
1014 * callback function. The callback may inspect or free blocks. The
1015 * count of frags found according to the size in the file is returned.
1016 * This is not valid for sparse files but may be used to determine
1017 * the correct di_blocks for a file.
1020 ino_visit(union dinode *ip, ino_t ino, ino_visitor visitor, int flags)
1031 size = DIP(ip, di_size);
1032 mode = DIP(ip, di_mode) & IFMT;
1034 if ((flags & VISIT_EXT) &&
1035 fs->fs_magic == FS_UFS2_MAGIC && ip->dp2.di_extsize) {
1036 for (i = 0; i < NXADDR; i++) {
1037 if (ip->dp2.di_extb[i] == 0)
1039 frags = sblksize(fs, ip->dp2.di_extsize, i);
1040 frags = numfrags(fs, frags);
1042 visitor(ino, -1 - i, ip->dp2.di_extb[i], frags);
1045 /* Skip datablocks for short links and devices. */
1046 if (mode == IFBLK || mode == IFCHR ||
1047 (mode == IFLNK && size < fs->fs_maxsymlinklen))
1049 for (i = 0; i < NDADDR; i++) {
1050 if (DIP(ip, di_db[i]) == 0)
1052 frags = sblksize(fs, size, i);
1053 frags = numfrags(fs, frags);
1055 visitor(ino, i, DIP(ip, di_db[i]), frags);
1058 * We know the following indirects are real as we're following
1059 * real pointers to them.
1061 flags |= VISIT_ROOT;
1062 for (i = 0, tmpval = NINDIR(fs), lbn = NDADDR; i < NIADDR; i++,
1064 nextlbn = lbn + tmpval;
1065 tmpval *= NINDIR(fs);
1066 if (DIP(ip, di_ib[i]) == 0)
1068 indir_visit(ino, -lbn - i, DIP(ip, di_ib[i]), &fragcnt, visitor,
1075 * Null visitor function used when we just want to count blocks and
1080 null_visit(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
1087 * Recalculate di_blocks when we discover that a block allocation or
1088 * free was not successfully completed. The kernel does not roll this back
1089 * because it would be too expensive to compute which indirects were
1090 * reachable at the time the inode was written.
1093 ino_adjblks(struct suj_ino *sino)
1104 /* No need to adjust zero'd inodes. */
1105 if (DIP(ip, di_mode) == 0)
1108 * Visit all blocks and count them as well as recording the last
1109 * valid lbn in the file. If the file size doesn't agree with the
1110 * last lbn we need to truncate to fix it. Otherwise just adjust
1114 frags = ino_visit(ip, ino, null_visit, VISIT_INDIR | VISIT_EXT);
1115 blocks = fsbtodb(fs, frags);
1117 * We assume the size and direct block list is kept coherent by
1118 * softdep. For files that have extended into indirects we truncate
1119 * to the size in the inode or the maximum size permitted by
1120 * populated indirects.
1122 if (visitlbn >= NDADDR) {
1123 isize = DIP(ip, di_size);
1124 size = lblktosize(fs, visitlbn + 1);
1127 /* Always truncate to free any unpopulated indirects. */
1128 ino_trunc(sino->si_ino, isize);
1131 if (blocks == DIP(ip, di_blocks))
1134 printf("ino %d adjusting block count from %jd to %jd\n",
1135 ino, DIP(ip, di_blocks), blocks);
1136 DIP_SET(ip, di_blocks, blocks);
1141 blk_free_visit(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
1144 blk_free(blk, blk_freemask(blk, ino, lbn, frags), frags);
1148 * Free a block or tree of blocks that was previously rooted in ino at
1149 * the given lbn. If the lbn is an indirect all children are freed
1153 blk_free_lbn(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t lbn, int frags, int follow)
1158 mask = blk_freemask(blk, ino, lbn, frags);
1160 if (lbn <= -NDADDR && follow && mask == 0)
1161 indir_visit(ino, lbn, blk, &resid, blk_free_visit, VISIT_INDIR);
1163 blk_free(blk, mask, frags);
1167 ino_setskip(struct suj_ino *sino, ino_t parent)
1172 if (ino_isat(sino->si_ino, DOTDOT_OFFSET, parent, &mode, &isdot))
1173 sino->si_skipparent = 1;
1177 ino_remref(ino_t parent, ino_t child, uint64_t diroff, int isdotdot)
1179 struct suj_ino *sino;
1180 struct suj_rec *srec;
1181 struct jrefrec *rrec;
1184 * Lookup this inode to see if we have a record for it.
1186 sino = ino_lookup(child, 0);
1188 * Tell any child directories we've already removed their
1189 * parent link cnt. Don't try to adjust our link down again.
1191 if (sino != NULL && isdotdot == 0)
1192 ino_setskip(sino, parent);
1194 * No valid record for this inode. Just drop the on-disk
1197 if (sino == NULL || sino->si_hasrecs == 0) {
1202 * Use ino_adjust() if ino_check() has already processed this
1203 * child. If we lose the last non-dot reference to a
1204 * directory it will be discarded.
1206 if (sino->si_linkadj) {
1209 sino->si_dotlinks--;
1214 * If we haven't yet processed this inode we need to make
1215 * sure we will successfully discover the lost path. If not
1216 * use nlinkadj to remember.
1218 TAILQ_FOREACH(srec, &sino->si_recs, sr_next) {
1219 rrec = (struct jrefrec *)srec->sr_rec;
1220 if (rrec->jr_parent == parent &&
1221 rrec->jr_diroff == diroff)
1224 sino->si_nlinkadj++;
1228 * Free the children of a directory when the directory is discarded.
1231 ino_free_children(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
1233 struct suj_ino *sino;
1242 sino = ino_lookup(ino, 0);
1244 skipparent = sino->si_skipparent;
1247 size = lfragtosize(fs, frags);
1248 block = dblk_read(blk, size);
1249 dp = (struct direct *)&block[0];
1250 for (dpoff = 0; dpoff < size && dp->d_reclen; dpoff += dp->d_reclen) {
1251 dp = (struct direct *)&block[dpoff];
1252 if (dp->d_ino == 0 || dp->d_ino == WINO)
1254 if (dp->d_namlen == 1 && dp->d_name[0] == '.')
1256 isdotdot = dp->d_namlen == 2 && dp->d_name[0] == '.' &&
1257 dp->d_name[1] == '.';
1258 if (isdotdot && skipparent == 1)
1261 printf("Directory %d removing ino %d name %s\n",
1262 ino, dp->d_ino, dp->d_name);
1263 diroff = lblktosize(fs, lbn) + dpoff;
1264 ino_remref(ino, dp->d_ino, diroff, isdotdot);
1269 * Reclaim an inode, freeing all blocks and decrementing all children's
1270 * link counts. Free the inode back to the cg.
1273 ino_reclaim(union dinode *ip, ino_t ino, int mode)
1278 err_suj("Attempting to free ROOTINO\n");
1280 printf("Truncating and freeing ino %d, nlink %d, mode %o\n",
1281 ino, DIP(ip, di_nlink), DIP(ip, di_mode));
1283 /* We are freeing an inode or directory. */
1284 if ((DIP(ip, di_mode) & IFMT) == IFDIR)
1285 ino_visit(ip, ino, ino_free_children, 0);
1286 DIP_SET(ip, di_nlink, 0);
1287 ino_visit(ip, ino, blk_free_visit, VISIT_EXT | VISIT_INDIR);
1288 /* Here we have to clear the inode and release any blocks it holds. */
1289 gen = DIP(ip, di_gen);
1290 if (fs->fs_magic == FS_UFS1_MAGIC)
1291 bzero(ip, sizeof(struct ufs1_dinode));
1293 bzero(ip, sizeof(struct ufs2_dinode));
1294 DIP_SET(ip, di_gen, gen);
1296 ino_free(ino, mode);
1301 * Adjust an inode's link count down by one when a directory goes away.
1312 nlink = DIP(ip, di_nlink);
1313 mode = DIP(ip, di_mode);
1315 err_suj("Inode %d link count %d invalid\n", ino, nlink);
1317 err_suj("Inode %d has a link of %d with 0 mode\n", ino, nlink);
1319 if ((mode & IFMT) == IFDIR)
1323 if (nlink < reqlink) {
1325 printf("ino %d not enough links to live %d < %d\n",
1326 ino, nlink, reqlink);
1327 ino_reclaim(ip, ino, mode);
1330 DIP_SET(ip, di_nlink, nlink);
1335 * Adjust the inode link count to 'nlink'. If the count reaches zero
1339 ino_adjust(struct suj_ino *sino)
1341 struct jrefrec *rrec;
1342 struct suj_rec *srec;
1343 struct suj_ino *stmp;
1352 nlink = sino->si_nlink;
1354 mode = sino->si_mode & IFMT;
1356 * If it's a directory with no dot links, it was truncated before
1357 * the name was cleared. We need to clear the dirent that
1360 if (mode == IFDIR && nlink == 1 && sino->si_dotlinks == 0) {
1361 sino->si_nlink = nlink = 0;
1362 TAILQ_FOREACH(srec, &sino->si_recs, sr_next) {
1363 rrec = (struct jrefrec *)srec->sr_rec;
1364 if (ino_isat(rrec->jr_parent, rrec->jr_diroff, ino,
1365 &recmode, &isdot) == 0)
1367 ino_clrat(rrec->jr_parent, rrec->jr_diroff, ino);
1371 errx(1, "Directory %d name not found", ino);
1374 * If it's a directory with no real names pointing to it go ahead
1375 * and truncate it. This will free any children.
1377 if (mode == IFDIR && nlink - sino->si_dotlinks == 0) {
1378 sino->si_nlink = nlink = 0;
1380 * Mark any .. links so they know not to free this inode
1381 * when they are removed.
1383 TAILQ_FOREACH(srec, &sino->si_recs, sr_next) {
1384 rrec = (struct jrefrec *)srec->sr_rec;
1385 if (rrec->jr_diroff == DOTDOT_OFFSET) {
1386 stmp = ino_lookup(rrec->jr_parent, 0);
1388 ino_setskip(stmp, ino);
1393 mode = DIP(ip, di_mode) & IFMT;
1394 if (nlink > LINK_MAX)
1396 "ino %d nlink manipulation error, new link %d, old link %d\n",
1397 ino, nlink, DIP(ip, di_nlink));
1399 printf("Adjusting ino %d, nlink %d, old link %d lastmode %o\n",
1400 ino, nlink, DIP(ip, di_nlink), sino->si_mode);
1403 printf("ino %d, zero inode freeing bitmap\n", ino);
1404 ino_free(ino, sino->si_mode);
1407 /* XXX Should be an assert? */
1408 if (mode != sino->si_mode && debug)
1409 printf("ino %d, mode %o != %o\n", ino, mode, sino->si_mode);
1410 if ((mode & IFMT) == IFDIR)
1414 /* If the inode doesn't have enough links to live, free it. */
1415 if (nlink < reqlink) {
1417 printf("ino %d not enough links to live %d < %d\n",
1418 ino, nlink, reqlink);
1419 ino_reclaim(ip, ino, mode);
1422 /* If required write the updated link count. */
1423 if (DIP(ip, di_nlink) == nlink) {
1425 printf("ino %d, link matches, skipping.\n", ino);
1428 DIP_SET(ip, di_nlink, nlink);
1433 * Truncate some or all blocks in an indirect, freeing any that are required
1434 * and zeroing the indirect.
1437 indir_trunc(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, ufs_lbn_t lastlbn)
1452 level = lbn_level(lbn);
1454 err_suj("Invalid level for lbn %jd\n", lbn);
1456 for (i = level; i > 0; i--)
1457 lbnadd *= NINDIR(fs);
1458 bap1 = (void *)dblk_read(blk, fs->fs_bsize);
1459 bap2 = (void *)bap1;
1460 for (i = 0; i < NINDIR(fs); i++) {
1461 if (fs->fs_magic == FS_UFS1_MAGIC)
1468 nlbn = (lbn + 1) - (i * lbnadd);
1470 * Calculate the lbn of the next indirect to
1471 * determine if any of this indirect must be
1474 next = -(lbn + level) + ((i+1) * lbnadd);
1475 if (next <= lastlbn)
1477 indir_trunc(ino, nlbn, nblk, lastlbn);
1478 /* If all of this indirect was reclaimed, free it. */
1479 nlbn = next - lbnadd;
1483 nlbn = -lbn + i * lbnadd;
1488 blk_free(nblk, 0, fs->fs_frag);
1489 if (fs->fs_magic == FS_UFS1_MAGIC)
1499 * Truncate an inode to the minimum of the given size or the last populated
1500 * block after any over size have been discarded. The kernel would allocate
1501 * the last block in the file but fsck does not and neither do we. This
1502 * code never extends files, only shrinks them.
1505 ino_trunc(ino_t ino, off_t size)
1509 uint64_t totalfrags;
1521 mode = DIP(ip, di_mode) & IFMT;
1522 cursize = DIP(ip, di_size);
1524 printf("Truncating ino %d, mode %o to size %jd from size %jd\n",
1525 ino, mode, size, cursize);
1527 /* Skip datablocks for short links and devices. */
1528 if (mode == 0 || mode == IFBLK || mode == IFCHR ||
1529 (mode == IFLNK && cursize < fs->fs_maxsymlinklen))
1534 lastlbn = lblkno(fs, blkroundup(fs, size));
1535 for (i = lastlbn; i < NDADDR; i++) {
1536 if (DIP(ip, di_db[i]) == 0)
1538 frags = sblksize(fs, cursize, i);
1539 frags = numfrags(fs, frags);
1540 blk_free(DIP(ip, di_db[i]), 0, frags);
1541 DIP_SET(ip, di_db[i], 0);
1544 * Follow indirect blocks, freeing anything required.
1546 for (i = 0, tmpval = NINDIR(fs), lbn = NDADDR; i < NIADDR; i++,
1548 nextlbn = lbn + tmpval;
1549 tmpval *= NINDIR(fs);
1550 /* If we're not freeing any in this indirect range skip it. */
1551 if (lastlbn >= nextlbn)
1553 if (DIP(ip, di_ib[i]) == 0)
1555 indir_trunc(ino, -lbn - i, DIP(ip, di_ib[i]), lastlbn);
1556 /* If we freed everything in this indirect free the indir. */
1559 blk_free(DIP(ip, di_ib[i]), 0, frags);
1560 DIP_SET(ip, di_ib[i], 0);
1564 * Now that we've freed any whole blocks that exceed the desired
1565 * truncation size, figure out how many blocks remain and what the
1566 * last populated lbn is. We will set the size to this last lbn
1567 * rather than worrying about allocating the final lbn as the kernel
1568 * would've done. This is consistent with normal fsck behavior.
1571 totalfrags = ino_visit(ip, ino, null_visit, VISIT_INDIR | VISIT_EXT);
1572 if (size > lblktosize(fs, visitlbn + 1))
1573 size = lblktosize(fs, visitlbn + 1);
1575 * If we're truncating direct blocks we have to adjust frags
1578 if (visitlbn < NDADDR && totalfrags) {
1579 long oldspace, newspace;
1581 bn = DIP(ip, di_db[visitlbn]);
1583 err_suj("Bad blk at ino %d lbn %jd\n", ino, visitlbn);
1584 oldspace = sblksize(fs, cursize, visitlbn);
1585 newspace = sblksize(fs, size, visitlbn);
1586 if (oldspace != newspace) {
1587 bn += numfrags(fs, newspace);
1588 frags = numfrags(fs, oldspace - newspace);
1589 blk_free(bn, 0, frags);
1590 totalfrags -= frags;
1593 DIP_SET(ip, di_blocks, fsbtodb(fs, totalfrags));
1594 DIP_SET(ip, di_size, size);
1596 * If we've truncated into the middle of a block or frag we have
1597 * to zero it here. Otherwise the file could extend into
1598 * uninitialized space later.
1600 off = blkoff(fs, size);
1601 if (off && DIP(ip, di_mode) != IFDIR) {
1605 bn = ino_blkatoff(ip, ino, visitlbn, &frags);
1607 err_suj("Block missing from ino %d at lbn %jd\n",
1609 clrsize = frags * fs->fs_fsize;
1610 buf = dblk_read(bn, clrsize);
1613 bzero(buf, clrsize);
1620 * Process records available for one inode and determine whether the
1621 * link count is correct or needs adjusting.
1624 ino_check(struct suj_ino *sino)
1626 struct suj_rec *srec;
1627 struct jrefrec *rrec;
1637 if (sino->si_hasrecs == 0)
1640 rrec = (struct jrefrec *)TAILQ_FIRST(&sino->si_recs)->sr_rec;
1641 nlink = rrec->jr_nlink;
1644 removes = sino->si_nlinkadj;
1645 TAILQ_FOREACH(srec, &sino->si_recs, sr_next) {
1646 rrec = (struct jrefrec *)srec->sr_rec;
1647 isat = ino_isat(rrec->jr_parent, rrec->jr_diroff,
1648 rrec->jr_ino, &mode, &isdot);
1649 if (isat && (mode & IFMT) != (rrec->jr_mode & IFMT))
1650 err_suj("Inode mode/directory type mismatch %o != %o\n",
1651 mode, rrec->jr_mode);
1653 printf("jrefrec: op %d ino %d, nlink %d, parent %d, "
1654 "diroff %jd, mode %o, isat %d, isdot %d\n",
1655 rrec->jr_op, rrec->jr_ino, rrec->jr_nlink,
1656 rrec->jr_parent, rrec->jr_diroff, rrec->jr_mode,
1658 mode = rrec->jr_mode & IFMT;
1659 if (rrec->jr_op == JOP_REMREF)
1666 * The number of links that remain are the starting link count
1667 * subtracted by the total number of removes with the total
1668 * links discovered back in. An incomplete remove thus
1669 * makes no change to the link count but an add increases
1673 printf("ino %d nlink %d newlinks %d removes %d dotlinks %d\n",
1674 ino, nlink, newlinks, removes, dotlinks);
1677 sino->si_linkadj = 1;
1678 sino->si_nlink = nlink;
1679 sino->si_dotlinks = dotlinks;
1680 sino->si_mode = mode;
1685 * Process records available for one block and determine whether it is
1686 * still allocated and whether the owning inode needs to be updated or
1690 blk_check(struct suj_blk *sblk)
1692 struct suj_rec *srec;
1693 struct jblkrec *brec;
1694 struct suj_ino *sino;
1701 * Each suj_blk actually contains records for any fragments in that
1702 * block. As a result we must evaluate each record individually.
1705 TAILQ_FOREACH(srec, &sblk->sb_recs, sr_next) {
1706 brec = (struct jblkrec *)srec->sr_rec;
1707 frags = brec->jb_frags;
1708 blk = brec->jb_blkno + brec->jb_oldfrags;
1709 isat = blk_isat(brec->jb_ino, brec->jb_lbn, blk, &frags);
1710 if (sino == NULL || sino->si_ino != brec->jb_ino) {
1711 sino = ino_lookup(brec->jb_ino, 1);
1712 sino->si_blkadj = 1;
1715 printf("op %d blk %jd ino %d lbn %jd frags %d isat %d (%d)\n",
1716 brec->jb_op, blk, brec->jb_ino, brec->jb_lbn,
1717 brec->jb_frags, isat, frags);
1719 * If we found the block at this address we still have to
1720 * determine if we need to free the tail end that was
1721 * added by adding contiguous fragments from the same block.
1724 if (frags == brec->jb_frags)
1726 mask = blk_freemask(blk, brec->jb_ino, brec->jb_lbn,
1730 frags = brec->jb_frags - frags;
1731 blk_free(blk, mask, frags);
1735 * The block wasn't found, attempt to free it. It won't be
1736 * freed if it was actually reallocated. If this was an
1737 * allocation we don't want to follow indirects as they
1738 * may not be written yet. Any children of the indirect will
1739 * have their own records. If it's a free we need to
1740 * recursively free children.
1742 blk_free_lbn(blk, brec->jb_ino, brec->jb_lbn, brec->jb_frags,
1743 brec->jb_op == JOP_FREEBLK);
1748 * Walk the list of inode records for this cg and resolve moved and duplicate
1749 * inode references now that we have a complete picture.
1752 cg_build(struct suj_cg *sc)
1754 struct suj_ino *sino;
1757 for (i = 0; i < SUJ_HASHSIZE; i++)
1758 LIST_FOREACH(sino, &sc->sc_inohash[i], si_next)
1763 * Handle inodes requiring truncation. This must be done prior to
1764 * looking up any inodes in directories.
1767 cg_trunc(struct suj_cg *sc)
1769 struct suj_ino *sino;
1772 for (i = 0; i < SUJ_HASHSIZE; i++) {
1773 LIST_FOREACH(sino, &sc->sc_inohash[i], si_next) {
1774 if (sino->si_trunc) {
1775 ino_trunc(sino->si_ino,
1776 sino->si_trunc->jt_size);
1777 sino->si_blkadj = 0;
1778 sino->si_trunc = NULL;
1780 if (sino->si_blkadj)
1787 cg_adj_blk(struct suj_cg *sc)
1789 struct suj_ino *sino;
1792 for (i = 0; i < SUJ_HASHSIZE; i++) {
1793 LIST_FOREACH(sino, &sc->sc_inohash[i], si_next) {
1794 if (sino->si_blkadj)
1801 * Free any partially allocated blocks and then resolve inode block
1805 cg_check_blk(struct suj_cg *sc)
1807 struct suj_blk *sblk;
1811 for (i = 0; i < SUJ_HASHSIZE; i++)
1812 LIST_FOREACH(sblk, &sc->sc_blkhash[i], sb_next)
1817 * Walk the list of inode records for this cg, recovering any
1818 * changes which were not complete at the time of crash.
1821 cg_check_ino(struct suj_cg *sc)
1823 struct suj_ino *sino;
1826 for (i = 0; i < SUJ_HASHSIZE; i++)
1827 LIST_FOREACH(sino, &sc->sc_inohash[i], si_next)
1832 * Write a potentially dirty cg. Recalculate the summary information and
1833 * update the superblock summary.
1836 cg_write(struct suj_cg *sc)
1838 ufs1_daddr_t fragno, cgbno, maxbno;
1844 if (sc->sc_dirty == 0)
1847 * Fix the frag and cluster summary.
1850 cgp->cg_cs.cs_nbfree = 0;
1851 cgp->cg_cs.cs_nffree = 0;
1852 bzero(&cgp->cg_frsum, sizeof(cgp->cg_frsum));
1853 maxbno = fragstoblks(fs, fs->fs_fpg);
1854 if (fs->fs_contigsumsize > 0) {
1855 for (i = 1; i <= fs->fs_contigsumsize; i++)
1856 cg_clustersum(cgp)[i] = 0;
1857 bzero(cg_clustersfree(cgp), howmany(maxbno, CHAR_BIT));
1859 blksfree = cg_blksfree(cgp);
1860 for (cgbno = 0; cgbno < maxbno; cgbno++) {
1861 if (ffs_isfreeblock(fs, blksfree, cgbno))
1863 if (ffs_isblock(fs, blksfree, cgbno)) {
1864 ffs_clusteracct(fs, cgp, cgbno, 1);
1865 cgp->cg_cs.cs_nbfree++;
1868 fragno = blkstofrags(fs, cgbno);
1869 blk = blkmap(fs, blksfree, fragno);
1870 ffs_fragacct(fs, blk, cgp->cg_frsum, 1);
1871 for (i = 0; i < fs->fs_frag; i++)
1872 if (isset(blksfree, fragno + i))
1873 cgp->cg_cs.cs_nffree++;
1876 * Update the superblock cg summary from our now correct values
1877 * before writing the block.
1879 fs->fs_cs(fs, sc->sc_cgx) = cgp->cg_cs;
1880 if (bwrite(disk, fsbtodb(fs, cgtod(fs, sc->sc_cgx)), sc->sc_cgbuf,
1881 fs->fs_bsize) == -1)
1882 err_suj("Unable to write cylinder group %d\n", sc->sc_cgx);
1886 * Write out any modified inodes.
1889 cg_write_inos(struct suj_cg *sc)
1891 struct ino_blk *iblk;
1894 for (i = 0; i < SUJ_HASHSIZE; i++)
1895 LIST_FOREACH(iblk, &sc->sc_iblkhash[i], ib_next)
1901 cg_apply(void (*apply)(struct suj_cg *))
1906 for (i = 0; i < SUJ_HASHSIZE; i++)
1907 LIST_FOREACH(scg, &cghash[i], sc_next)
1912 * Process the unlinked but referenced file list. Freeing all inodes.
1922 ino = fs->fs_sujfree;
1926 mode = DIP(ip, di_mode) & IFMT;
1927 inon = DIP(ip, di_freelink);
1928 DIP_SET(ip, di_freelink, 0);
1930 * XXX Should this be an errx?
1932 if (DIP(ip, di_nlink) == 0) {
1934 printf("Freeing unlinked ino %d mode %o\n",
1936 ino_reclaim(ip, ino, mode);
1938 printf("Skipping ino %d mode %o with link %d\n",
1939 ino, mode, DIP(ip, di_nlink));
1945 * Append a new record to the list of records requiring processing.
1948 ino_append(union jrec *rec)
1950 struct jrefrec *refrec;
1951 struct jmvrec *mvrec;
1952 struct suj_ino *sino;
1953 struct suj_rec *srec;
1955 mvrec = &rec->rec_jmvrec;
1956 refrec = &rec->rec_jrefrec;
1957 if (debug && mvrec->jm_op == JOP_MVREF)
1958 printf("ino move: ino %d, parent %d, diroff %jd, oldoff %jd\n",
1959 mvrec->jm_ino, mvrec->jm_parent, mvrec->jm_newoff,
1962 (refrec->jr_op == JOP_ADDREF || refrec->jr_op == JOP_REMREF))
1963 printf("ino ref: op %d, ino %d, nlink %d, "
1964 "parent %d, diroff %jd\n",
1965 refrec->jr_op, refrec->jr_ino, refrec->jr_nlink,
1966 refrec->jr_parent, refrec->jr_diroff);
1967 sino = ino_lookup(((struct jrefrec *)rec)->jr_ino, 1);
1968 sino->si_hasrecs = 1;
1969 srec = errmalloc(sizeof(*srec));
1971 TAILQ_INSERT_TAIL(&sino->si_newrecs, srec, sr_next);
1975 * Add a reference adjustment to the sino list and eliminate dups. The
1976 * primary loop in ino_build_ref() checks for dups but new ones may be
1977 * created as a result of offset adjustments.
1980 ino_add_ref(struct suj_ino *sino, struct suj_rec *srec)
1982 struct jrefrec *refrec;
1983 struct suj_rec *srn;
1984 struct jrefrec *rrn;
1986 refrec = (struct jrefrec *)srec->sr_rec;
1988 * We walk backwards so that the oldest link count is preserved. If
1989 * an add record conflicts with a remove keep the remove. Redundant
1990 * removes are eliminated in ino_build_ref. Otherwise we keep the
1991 * oldest record at a given location.
1993 for (srn = TAILQ_LAST(&sino->si_recs, srechd); srn;
1994 srn = TAILQ_PREV(srn, srechd, sr_next)) {
1995 rrn = (struct jrefrec *)srn->sr_rec;
1996 if (rrn->jr_parent != refrec->jr_parent ||
1997 rrn->jr_diroff != refrec->jr_diroff)
1999 if (rrn->jr_op == JOP_REMREF || refrec->jr_op == JOP_ADDREF) {
2000 rrn->jr_mode = refrec->jr_mode;
2006 * Replace the record in place with the old nlink in case
2007 * we replace the head of the list. Abandon srec as a dup.
2009 refrec->jr_nlink = rrn->jr_nlink;
2010 srn->sr_rec = srec->sr_rec;
2013 TAILQ_INSERT_TAIL(&sino->si_recs, srec, sr_next);
2017 * Create a duplicate of a reference at a previous location.
2020 ino_dup_ref(struct suj_ino *sino, struct jrefrec *refrec, off_t diroff)
2022 struct jrefrec *rrn;
2023 struct suj_rec *srn;
2025 rrn = errmalloc(sizeof(*refrec));
2027 rrn->jr_op = JOP_ADDREF;
2028 rrn->jr_diroff = diroff;
2029 srn = errmalloc(sizeof(*srn));
2030 srn->sr_rec = (union jrec *)rrn;
2031 ino_add_ref(sino, srn);
2035 * Add a reference to the list at all known locations. We follow the offset
2036 * changes for a single instance and create duplicate add refs at each so
2037 * that we can tolerate any version of the directory block. Eliminate
2038 * removes which collide with adds that are seen in the journal. They should
2039 * not adjust the link count down.
2042 ino_build_ref(struct suj_ino *sino, struct suj_rec *srec)
2044 struct jrefrec *refrec;
2045 struct jmvrec *mvrec;
2046 struct suj_rec *srp;
2047 struct suj_rec *srn;
2048 struct jrefrec *rrn;
2051 refrec = (struct jrefrec *)srec->sr_rec;
2053 * Search for a mvrec that matches this offset. Whether it's an add
2054 * or a remove we can delete the mvref after creating a dup record in
2057 if (!TAILQ_EMPTY(&sino->si_movs)) {
2058 diroff = refrec->jr_diroff;
2059 for (srn = TAILQ_LAST(&sino->si_movs, srechd); srn; srn = srp) {
2060 srp = TAILQ_PREV(srn, srechd, sr_next);
2061 mvrec = (struct jmvrec *)srn->sr_rec;
2062 if (mvrec->jm_parent != refrec->jr_parent ||
2063 mvrec->jm_newoff != diroff)
2065 diroff = mvrec->jm_oldoff;
2066 TAILQ_REMOVE(&sino->si_movs, srn, sr_next);
2068 ino_dup_ref(sino, refrec, diroff);
2072 * If a remove wasn't eliminated by an earlier add just append it to
2075 if (refrec->jr_op == JOP_REMREF) {
2076 ino_add_ref(sino, srec);
2080 * Walk the list of records waiting to be added to the list. We
2081 * must check for moves that apply to our current offset and remove
2082 * them from the list. Remove any duplicates to eliminate removes
2083 * with corresponding adds.
2085 TAILQ_FOREACH_SAFE(srn, &sino->si_newrecs, sr_next, srp) {
2086 switch (srn->sr_rec->rec_jrefrec.jr_op) {
2089 * This should actually be an error we should
2090 * have a remove for every add journaled.
2092 rrn = (struct jrefrec *)srn->sr_rec;
2093 if (rrn->jr_parent != refrec->jr_parent ||
2094 rrn->jr_diroff != refrec->jr_diroff)
2096 TAILQ_REMOVE(&sino->si_newrecs, srn, sr_next);
2100 * Once we remove the current iteration of the
2101 * record at this address we're done.
2103 rrn = (struct jrefrec *)srn->sr_rec;
2104 if (rrn->jr_parent != refrec->jr_parent ||
2105 rrn->jr_diroff != refrec->jr_diroff)
2107 TAILQ_REMOVE(&sino->si_newrecs, srn, sr_next);
2108 ino_add_ref(sino, srec);
2112 * Update our diroff based on any moves that match
2113 * and remove the move.
2115 mvrec = (struct jmvrec *)srn->sr_rec;
2116 if (mvrec->jm_parent != refrec->jr_parent ||
2117 mvrec->jm_oldoff != refrec->jr_diroff)
2119 ino_dup_ref(sino, refrec, mvrec->jm_oldoff);
2120 refrec->jr_diroff = mvrec->jm_newoff;
2121 TAILQ_REMOVE(&sino->si_newrecs, srn, sr_next);
2124 err_suj("ino_build_ref: Unknown op %d\n",
2125 srn->sr_rec->rec_jrefrec.jr_op);
2128 ino_add_ref(sino, srec);
2132 * Walk the list of new records and add them in-order resolving any
2133 * dups and adjusted offsets.
2136 ino_build(struct suj_ino *sino)
2138 struct suj_rec *srec;
2140 while ((srec = TAILQ_FIRST(&sino->si_newrecs)) != NULL) {
2141 TAILQ_REMOVE(&sino->si_newrecs, srec, sr_next);
2142 switch (srec->sr_rec->rec_jrefrec.jr_op) {
2145 ino_build_ref(sino, srec);
2149 * Add this mvrec to the queue of pending mvs.
2151 TAILQ_INSERT_TAIL(&sino->si_movs, srec, sr_next);
2154 err_suj("ino_build: Unknown op %d\n",
2155 srec->sr_rec->rec_jrefrec.jr_op);
2158 if (TAILQ_EMPTY(&sino->si_recs))
2159 sino->si_hasrecs = 0;
2163 * Modify journal records so they refer to the base block number
2164 * and a start and end frag range. This is to facilitate the discovery
2165 * of overlapping fragment allocations.
2168 blk_build(struct jblkrec *blkrec)
2170 struct suj_rec *srec;
2171 struct suj_blk *sblk;
2172 struct jblkrec *blkrn;
2177 printf("blk_build: op %d blkno %jd frags %d oldfrags %d "
2179 blkrec->jb_op, blkrec->jb_blkno, blkrec->jb_frags,
2180 blkrec->jb_oldfrags, blkrec->jb_ino, blkrec->jb_lbn);
2182 blk = blknum(fs, blkrec->jb_blkno);
2183 frag = fragnum(fs, blkrec->jb_blkno);
2184 sblk = blk_lookup(blk, 1);
2186 * Rewrite the record using oldfrags to indicate the offset into
2187 * the block. Leave jb_frags as the actual allocated count.
2189 blkrec->jb_blkno -= frag;
2190 blkrec->jb_oldfrags = frag;
2191 if (blkrec->jb_oldfrags + blkrec->jb_frags > fs->fs_frag)
2192 err_suj("Invalid fragment count %d oldfrags %d\n",
2193 blkrec->jb_frags, frag);
2195 * Detect dups. If we detect a dup we always discard the oldest
2196 * record as it is superseded by the new record. This speeds up
2197 * later stages but also eliminates free records which are used
2198 * to indicate that the contents of indirects can be trusted.
2200 TAILQ_FOREACH(srec, &sblk->sb_recs, sr_next) {
2201 blkrn = (struct jblkrec *)srec->sr_rec;
2202 if (blkrn->jb_ino != blkrec->jb_ino ||
2203 blkrn->jb_lbn != blkrec->jb_lbn ||
2204 blkrn->jb_blkno != blkrec->jb_blkno ||
2205 blkrn->jb_frags != blkrec->jb_frags ||
2206 blkrn->jb_oldfrags != blkrec->jb_oldfrags)
2209 printf("Removed dup.\n");
2210 /* Discard the free which is a dup with an alloc. */
2211 if (blkrec->jb_op == JOP_FREEBLK)
2213 TAILQ_REMOVE(&sblk->sb_recs, srec, sr_next);
2217 srec = errmalloc(sizeof(*srec));
2218 srec->sr_rec = (union jrec *)blkrec;
2219 TAILQ_INSERT_TAIL(&sblk->sb_recs, srec, sr_next);
2223 ino_build_trunc(struct jtrncrec *rec)
2225 struct suj_ino *sino;
2228 printf("ino_build_trunc: op %d ino %d, size %jd\n",
2229 rec->jt_op, rec->jt_ino, rec->jt_size);
2230 sino = ino_lookup(rec->jt_ino, 1);
2231 if (rec->jt_op == JOP_SYNC) {
2232 sino->si_trunc = NULL;
2235 if (sino->si_trunc == NULL || sino->si_trunc->jt_size > rec->jt_size)
2236 sino->si_trunc = rec;
2240 * Build up tables of the operations we need to recover.
2245 struct suj_seg *seg;
2250 TAILQ_FOREACH(seg, &allsegs, ss_next) {
2252 printf("seg %jd has %d records, oldseq %jd.\n",
2253 seg->ss_rec.jsr_seq, seg->ss_rec.jsr_cnt,
2254 seg->ss_rec.jsr_oldest);
2256 rec = (union jrec *)seg->ss_blk;
2257 for (i = 0; i < seg->ss_rec.jsr_cnt; off += JREC_SIZE, rec++) {
2258 /* skip the segrec. */
2259 if ((off % real_dev_bsize) == 0)
2261 switch (rec->rec_jrefrec.jr_op) {
2269 blk_build((struct jblkrec *)rec);
2273 ino_build_trunc((struct jtrncrec *)rec);
2276 err_suj("Unknown journal operation %d (%d)\n",
2277 rec->rec_jrefrec.jr_op, off);
2285 * Prune the journal segments to those we care about based on the
2286 * oldest sequence in the newest segment. Order the segment list
2287 * based on sequence number.
2292 struct suj_seg *seg;
2293 struct suj_seg *segn;
2298 printf("Pruning up to %jd\n", oldseq);
2299 /* First free the expired segments. */
2300 TAILQ_FOREACH_SAFE(seg, &allsegs, ss_next, segn) {
2301 if (seg->ss_rec.jsr_seq >= oldseq)
2303 TAILQ_REMOVE(&allsegs, seg, ss_next);
2307 /* Next ensure that segments are ordered properly. */
2308 seg = TAILQ_FIRST(&allsegs);
2311 printf("Empty journal\n");
2314 newseq = seg->ss_rec.jsr_seq;
2316 seg = TAILQ_LAST(&allsegs, seghd);
2317 if (seg->ss_rec.jsr_seq >= newseq)
2319 TAILQ_REMOVE(&allsegs, seg, ss_next);
2320 TAILQ_INSERT_HEAD(&allsegs, seg, ss_next);
2321 newseq = seg->ss_rec.jsr_seq;
2324 if (newseq != oldseq) {
2325 TAILQ_FOREACH(seg, &allsegs, ss_next) {
2326 printf("%jd, ", seg->ss_rec.jsr_seq);
2329 err_suj("Journal file sequence mismatch %jd != %jd\n",
2333 * The kernel may asynchronously write segments which can create
2334 * gaps in the sequence space. Throw away any segments after the
2335 * gap as the kernel guarantees only those that are contiguously
2336 * reachable are marked as completed.
2339 TAILQ_FOREACH_SAFE(seg, &allsegs, ss_next, segn) {
2340 if (!discard && newseq++ == seg->ss_rec.jsr_seq) {
2341 jrecs += seg->ss_rec.jsr_cnt;
2342 jbytes += seg->ss_rec.jsr_blocks * real_dev_bsize;
2347 printf("Journal order mismatch %jd != %jd pruning\n",
2348 newseq-1, seg->ss_rec.jsr_seq);
2349 TAILQ_REMOVE(&allsegs, seg, ss_next);
2354 printf("Processing journal segments from %jd to %jd\n",
2359 * Verify the journal inode before attempting to read records.
2362 suj_verifyino(union dinode *ip)
2365 if (DIP(ip, di_nlink) != 1) {
2366 printf("Invalid link count %d for journal inode %d\n",
2367 DIP(ip, di_nlink), sujino);
2371 if ((DIP(ip, di_flags) & (SF_IMMUTABLE | SF_NOUNLINK)) !=
2372 (SF_IMMUTABLE | SF_NOUNLINK)) {
2373 printf("Invalid flags 0x%X for journal inode %d\n",
2374 DIP(ip, di_flags), sujino);
2378 if (DIP(ip, di_mode) != (IFREG | IREAD)) {
2379 printf("Invalid mode %o for journal inode %d\n",
2380 DIP(ip, di_mode), sujino);
2384 if (DIP(ip, di_size) < SUJ_MIN) {
2385 printf("Invalid size %jd for journal inode %d\n",
2386 DIP(ip, di_size), sujino);
2390 if (DIP(ip, di_modrev) != fs->fs_mtime) {
2391 printf("Journal timestamp does not match fs mount time\n");
2399 struct jextent *jb_extent; /* Extent array. */
2400 int jb_avail; /* Available extents. */
2401 int jb_used; /* Last used extent. */
2402 int jb_head; /* Allocator head. */
2403 int jb_off; /* Allocator extent offset. */
2406 ufs2_daddr_t je_daddr; /* Disk block address. */
2407 int je_blocks; /* Disk block count. */
2410 struct jblocks *suj_jblocks;
2412 static struct jblocks *
2413 jblocks_create(void)
2415 struct jblocks *jblocks;
2418 jblocks = errmalloc(sizeof(*jblocks));
2419 jblocks->jb_avail = 10;
2420 jblocks->jb_used = 0;
2421 jblocks->jb_head = 0;
2422 jblocks->jb_off = 0;
2423 size = sizeof(struct jextent) * jblocks->jb_avail;
2424 jblocks->jb_extent = errmalloc(size);
2425 bzero(jblocks->jb_extent, size);
2431 * Return the next available disk block and the amount of contiguous
2432 * free space it contains.
2435 jblocks_next(struct jblocks *jblocks, int bytes, int *actual)
2437 struct jextent *jext;
2442 blocks = bytes / disk->d_bsize;
2443 jext = &jblocks->jb_extent[jblocks->jb_head];
2444 freecnt = jext->je_blocks - jblocks->jb_off;
2446 jblocks->jb_off = 0;
2447 if (++jblocks->jb_head > jblocks->jb_used)
2449 jext = &jblocks->jb_extent[jblocks->jb_head];
2450 freecnt = jext->je_blocks;
2452 if (freecnt > blocks)
2454 *actual = freecnt * disk->d_bsize;
2455 daddr = jext->je_daddr + jblocks->jb_off;
2461 * Advance the allocation head by a specified number of bytes, consuming
2462 * one journal segment.
2465 jblocks_advance(struct jblocks *jblocks, int bytes)
2468 jblocks->jb_off += bytes / disk->d_bsize;
2472 jblocks_destroy(struct jblocks *jblocks)
2475 free(jblocks->jb_extent);
2480 jblocks_add(struct jblocks *jblocks, ufs2_daddr_t daddr, int blocks)
2482 struct jextent *jext;
2485 jext = &jblocks->jb_extent[jblocks->jb_used];
2486 /* Adding the first block. */
2487 if (jext->je_daddr == 0) {
2488 jext->je_daddr = daddr;
2489 jext->je_blocks = blocks;
2492 /* Extending the last extent. */
2493 if (jext->je_daddr + jext->je_blocks == daddr) {
2494 jext->je_blocks += blocks;
2497 /* Adding a new extent. */
2498 if (++jblocks->jb_used == jblocks->jb_avail) {
2499 jblocks->jb_avail *= 2;
2500 size = sizeof(struct jextent) * jblocks->jb_avail;
2501 jext = errmalloc(size);
2503 bcopy(jblocks->jb_extent, jext,
2504 sizeof(struct jextent) * jblocks->jb_used);
2505 free(jblocks->jb_extent);
2506 jblocks->jb_extent = jext;
2508 jext = &jblocks->jb_extent[jblocks->jb_used];
2509 jext->je_daddr = daddr;
2510 jext->je_blocks = blocks;
2516 * Add a file block from the journal to the extent map. We can't read
2517 * each file block individually because the kernel treats it as a circular
2518 * buffer and segments may span mutliple contiguous blocks.
2521 suj_add_block(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
2524 jblocks_add(suj_jblocks, fsbtodb(fs, blk), fsbtodb(fs, frags));
2530 uint8_t block[1 * 1024 * 1024];
2531 struct suj_seg *seg;
2532 struct jsegrec *recn;
2533 struct jsegrec *rec;
2542 * Read records until we exhaust the journal space. If we find
2543 * an invalid record we start searching for a valid segment header
2544 * at the next block. This is because we don't have a head/tail
2545 * pointer and must recover the information indirectly. At the gap
2546 * between the head and tail we won't necessarily have a valid
2551 size = sizeof(block);
2552 blk = jblocks_next(suj_jblocks, size, &readsize);
2557 * Read 1MB at a time and scan for records within this block.
2559 if (bread(disk, blk, &block, size) == -1) {
2560 err_suj("Error reading journal block %jd\n",
2563 for (rec = (void *)block; size; size -= recsize,
2564 rec = (struct jsegrec *)((uintptr_t)rec + recsize)) {
2565 recsize = real_dev_bsize;
2566 if (rec->jsr_time != fs->fs_mtime) {
2568 printf("Rec time %jd != fs mtime %jd\n",
2569 rec->jsr_time, fs->fs_mtime);
2570 jblocks_advance(suj_jblocks, recsize);
2573 if (rec->jsr_cnt == 0) {
2575 printf("Found illegal count %d\n",
2577 jblocks_advance(suj_jblocks, recsize);
2580 blocks = rec->jsr_blocks;
2581 recsize = blocks * real_dev_bsize;
2582 if (recsize > size) {
2584 * We may just have run out of buffer, restart
2585 * the loop to re-read from this spot.
2587 if (size < fs->fs_bsize &&
2589 recsize <= fs->fs_bsize)
2592 printf("Found invalid segsize %d > %d\n",
2594 recsize = real_dev_bsize;
2595 jblocks_advance(suj_jblocks, recsize);
2599 * Verify that all blocks in the segment are present.
2601 for (i = 1; i < blocks; i++) {
2602 recn = (void *)((uintptr_t)rec) + i *
2604 if (recn->jsr_seq == rec->jsr_seq &&
2605 recn->jsr_time == rec->jsr_time)
2608 printf("Incomplete record %jd (%d)\n",
2610 recsize = i * real_dev_bsize;
2611 jblocks_advance(suj_jblocks, recsize);
2614 seg = errmalloc(sizeof(*seg));
2615 seg->ss_blk = errmalloc(recsize);
2617 bcopy((void *)rec, seg->ss_blk, recsize);
2618 if (rec->jsr_oldest > oldseq)
2619 oldseq = rec->jsr_oldest;
2620 TAILQ_INSERT_TAIL(&allsegs, seg, ss_next);
2621 jblocks_advance(suj_jblocks, recsize);
2627 * Search a directory block for the SUJ_FILE.
2630 suj_find(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
2632 char block[MAXBSIZE];
2639 bytes = lfragtosize(fs, frags);
2640 if (bread(disk, fsbtodb(fs, blk), block, bytes) <= 0)
2641 err_suj("Failed to read ROOTINO directory block %jd\n", blk);
2642 for (off = 0; off < bytes; off += dp->d_reclen) {
2643 dp = (struct direct *)&block[off];
2644 if (dp->d_reclen == 0)
2648 if (dp->d_namlen != strlen(SUJ_FILE))
2650 if (bcmp(dp->d_name, SUJ_FILE, dp->d_namlen) != 0)
2658 * Orchestrate the verification of a filesystem via the softupdates journal.
2661 suj_check(const char *filesys)
2667 struct suj_seg *seg;
2668 struct suj_seg *segn;
2671 TAILQ_INIT(&allsegs);
2674 * Set an exit point when SUJ check failed
2676 retval = setjmp(jmpbuf);
2678 pwarn("UNEXPECTED SU+J INCONSISTENCY\n");
2679 TAILQ_FOREACH_SAFE(seg, &allsegs, ss_next, segn) {
2680 TAILQ_REMOVE(&allsegs, seg, ss_next);
2684 if (reply("FALLBACK TO FULL FSCK") == 0) {
2692 * Find the journal inode.
2694 ip = ino_read(ROOTINO);
2696 ino_visit(ip, ROOTINO, suj_find, 0);
2698 printf("Journal inode removed. Use tunefs to re-create.\n");
2699 sblock.fs_flags &= ~FS_SUJ;
2700 sblock.fs_sujfree = 0;
2704 * Fetch the journal inode and verify it.
2706 jip = ino_read(sujino);
2707 printf("** SU+J Recovering %s\n", filesys);
2708 if (suj_verifyino(jip) != 0)
2711 * Build a list of journal blocks in jblocks before parsing the
2712 * available journal blocks in with suj_read().
2714 printf("** Reading %jd byte journal from inode %d.\n",
2715 DIP(jip, di_size), sujino);
2716 suj_jblocks = jblocks_create();
2717 blocks = ino_visit(jip, sujino, suj_add_block, 0);
2718 if (blocks != numfrags(fs, DIP(jip, di_size))) {
2719 printf("Sparse journal inode %d.\n", sujino);
2723 jblocks_destroy(suj_jblocks);
2725 if (preen || reply("RECOVER")) {
2726 printf("** Building recovery table.\n");
2730 printf("** Resolving unreferenced inode list.\n");
2732 printf("** Processing journal entries.\n");
2734 cg_apply(cg_check_blk);
2735 cg_apply(cg_adj_blk);
2736 cg_apply(cg_check_ino);
2738 if (preen == 0 && (jrecs > 0 || jbytes > 0) && reply("WRITE CHANGES") == 0)
2741 * To remain idempotent with partial truncations the free bitmaps
2742 * must be written followed by indirect blocks and lastly inode
2743 * blocks. This preserves access to the modified pointers until
2748 cg_apply(cg_write_inos);
2749 /* Write back superblock. */
2751 if (jrecs > 0 || jbytes > 0) {
2752 printf("** %jd journal records in %jd bytes for %.2f%% utilization\n",
2753 jrecs, jbytes, ((float)jrecs / (float)(jbytes / JREC_SIZE)) * 100);
2754 printf("** Freed %jd inodes (%jd dirs) %jd blocks, and %jd frags.\n",
2755 freeinos, freedir, freeblocks, freefrags);