2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright 2009, 2010 Jeffrey W. Roberson <jeff@FreeBSD.org>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
34 #include <sys/disklabel.h>
35 #include <sys/mount.h>
38 #include <ufs/ufs/ufsmount.h>
39 #include <ufs/ufs/dinode.h>
40 #include <ufs/ufs/dir.h>
41 #include <ufs/ffs/fs.h>
58 #define DOTDOT_OFFSET DIRECTSIZ(1)
59 #define SUJ_HASHSIZE 2048
60 #define SUJ_HASHMASK (SUJ_HASHSIZE - 1)
61 #define SUJ_HASH(x) ((x * 2654435761) & SUJ_HASHMASK)
64 TAILQ_ENTRY(suj_seg) ss_next;
65 struct jsegrec ss_rec;
70 TAILQ_ENTRY(suj_rec) sr_next;
73 TAILQ_HEAD(srechd, suj_rec);
76 LIST_ENTRY(suj_ino) si_next;
77 struct srechd si_recs;
78 struct srechd si_newrecs;
79 struct srechd si_movs;
80 struct jtrncrec *si_trunc;
91 LIST_HEAD(inohd, suj_ino);
94 LIST_ENTRY(suj_blk) sb_next;
95 struct srechd sb_recs;
98 LIST_HEAD(blkhd, suj_blk);
101 LIST_ENTRY(data_blk) db_next;
109 LIST_ENTRY(ino_blk) ib_next;
112 ino_t ib_startinginum;
115 LIST_HEAD(iblkhd, ino_blk);
118 LIST_ENTRY(suj_cg) sc_next;
119 struct blkhd sc_blkhash[SUJ_HASHSIZE];
120 struct inohd sc_inohash[SUJ_HASHSIZE];
121 struct iblkhd sc_iblkhash[SUJ_HASHSIZE];
122 struct ino_blk *sc_lastiblk;
123 struct suj_ino *sc_lastino;
124 struct suj_blk *sc_lastblk;
131 static LIST_HEAD(cghd, suj_cg) cghash[SUJ_HASHSIZE];
132 static LIST_HEAD(dblkhd, data_blk) dbhash[SUJ_HASHSIZE];
133 static struct suj_cg *lastcg;
134 static struct data_blk *lastblk;
136 static TAILQ_HEAD(seghd, suj_seg) allsegs;
137 static uint64_t oldseq;
138 static struct fs *fs = NULL;
142 * Summary statistics.
144 static uint64_t freefrags;
145 static uint64_t freeblocks;
146 static uint64_t freeinos;
147 static uint64_t freedir;
148 static uint64_t jbytes;
149 static uint64_t jrecs;
151 static jmp_buf jmpbuf;
153 typedef void (*ino_visitor)(ino_t, ufs_lbn_t, ufs2_daddr_t, int);
154 static void err_suj(const char *, ...) __dead2;
155 static void ino_trunc(ino_t, off_t);
156 static void ino_decr(ino_t);
157 static void ino_adjust(struct suj_ino *);
158 static void ino_build(struct suj_ino *);
159 static int blk_isfree(ufs2_daddr_t);
160 static void initsuj(void);
161 static void ino_dirty(ino_t);
170 err(EX_OSERR, "malloc(%zu)", n);
175 * When hit a fatal error in journalling check, print out
176 * the error and then offer to fallback to normal fsck.
179 err_suj(const char * restrict fmt, ...)
184 (void)fprintf(stdout, "%s: ", cdevname);
187 (void)vfprintf(stdout, fmt, ap);
194 * Mark file system as clean, write the super-block back, close the disk.
197 closedisk(const char *devnam)
203 * Recompute the fs summary info from correct cs summaries.
205 bzero(&fs->fs_cstotal, sizeof(struct csum_total));
206 for (i = 0; i < fs->fs_ncg; i++) {
207 cgsum = &fs->fs_cs(fs, i);
208 fs->fs_cstotal.cs_nffree += cgsum->cs_nffree;
209 fs->fs_cstotal.cs_nbfree += cgsum->cs_nbfree;
210 fs->fs_cstotal.cs_nifree += cgsum->cs_nifree;
211 fs->fs_cstotal.cs_ndir += cgsum->cs_ndir;
213 fs->fs_pendinginodes = 0;
214 fs->fs_pendingblocks = 0;
216 fs->fs_time = time(NULL);
217 fs->fs_mtime = time(NULL);
218 if (sbput(disk.d_fd, fs, 0) == -1)
219 err(EX_OSERR, "sbput(%s)", devnam);
220 if (ufs_disk_close(&disk) == -1)
221 err(EX_OSERR, "ufs_disk_close(%s)", devnam);
226 * Lookup a cg by number in the hash so we can keep track of which cgs
227 * need stats rebuilt.
229 static struct suj_cg *
235 if (cgx < 0 || cgx >= fs->fs_ncg)
236 err_suj("Bad cg number %d\n", cgx);
237 if (lastcg && lastcg->sc_cgx == cgx)
239 hd = &cghash[SUJ_HASH(cgx)];
240 LIST_FOREACH(sc, hd, sc_next)
241 if (sc->sc_cgx == cgx) {
245 sc = errmalloc(sizeof(*sc));
246 bzero(sc, sizeof(*sc));
247 sc->sc_cgbuf = errmalloc(fs->fs_bsize);
248 sc->sc_cgp = (struct cg *)sc->sc_cgbuf;
250 LIST_INSERT_HEAD(hd, sc, sc_next);
252 * Use bread() here rather than cgget() because the cylinder group
253 * may be corrupted but we want it anyway so we can fix it.
255 if (bread(&disk, fsbtodb(fs, cgtod(fs, sc->sc_cgx)), sc->sc_cgbuf,
257 err_suj("Unable to read cylinder group %d\n", sc->sc_cgx);
263 * Lookup an inode number in the hash and allocate a suj_ino if it does
266 static struct suj_ino *
267 ino_lookup(ino_t ino, int creat)
269 struct suj_ino *sino;
273 sc = cg_lookup(ino_to_cg(fs, ino));
274 if (sc->sc_lastino && sc->sc_lastino->si_ino == ino)
275 return (sc->sc_lastino);
276 hd = &sc->sc_inohash[SUJ_HASH(ino)];
277 LIST_FOREACH(sino, hd, si_next)
278 if (sino->si_ino == ino)
282 sino = errmalloc(sizeof(*sino));
283 bzero(sino, sizeof(*sino));
285 TAILQ_INIT(&sino->si_recs);
286 TAILQ_INIT(&sino->si_newrecs);
287 TAILQ_INIT(&sino->si_movs);
288 LIST_INSERT_HEAD(hd, sino, si_next);
294 * Lookup a block number in the hash and allocate a suj_blk if it does
297 static struct suj_blk *
298 blk_lookup(ufs2_daddr_t blk, int creat)
300 struct suj_blk *sblk;
304 sc = cg_lookup(dtog(fs, blk));
305 if (sc->sc_lastblk && sc->sc_lastblk->sb_blk == blk)
306 return (sc->sc_lastblk);
307 hd = &sc->sc_blkhash[SUJ_HASH(fragstoblks(fs, blk))];
308 LIST_FOREACH(sblk, hd, sb_next)
309 if (sblk->sb_blk == blk)
313 sblk = errmalloc(sizeof(*sblk));
314 bzero(sblk, sizeof(*sblk));
316 TAILQ_INIT(&sblk->sb_recs);
317 LIST_INSERT_HEAD(hd, sblk, sb_next);
322 static struct data_blk *
323 dblk_lookup(ufs2_daddr_t blk)
325 struct data_blk *dblk;
328 hd = &dbhash[SUJ_HASH(fragstoblks(fs, blk))];
329 if (lastblk && lastblk->db_blk == blk)
331 LIST_FOREACH(dblk, hd, db_next)
332 if (dblk->db_blk == blk)
335 * The inode block wasn't located, allocate a new one.
337 dblk = errmalloc(sizeof(*dblk));
338 bzero(dblk, sizeof(*dblk));
339 LIST_INSERT_HEAD(hd, dblk, db_next);
345 dblk_read(ufs2_daddr_t blk, int size)
347 struct data_blk *dblk;
349 dblk = dblk_lookup(blk);
351 * I doubt size mismatches can happen in practice but it is trivial
354 if (size != dblk->db_size) {
357 dblk->db_buf = errmalloc(size);
358 dblk->db_size = size;
359 if (bread(&disk, fsbtodb(fs, blk), dblk->db_buf, size) == -1)
360 err_suj("Failed to read data block %jd\n", blk);
362 return (dblk->db_buf);
366 dblk_dirty(ufs2_daddr_t blk)
368 struct data_blk *dblk;
370 dblk = dblk_lookup(blk);
377 struct data_blk *dblk;
380 for (i = 0; i < SUJ_HASHSIZE; i++) {
381 LIST_FOREACH(dblk, &dbhash[i], db_next) {
382 if (dblk->db_dirty == 0 || dblk->db_size == 0)
384 if (bwrite(&disk, fsbtodb(fs, dblk->db_blk),
385 dblk->db_buf, dblk->db_size) == -1)
386 err_suj("Unable to write block %jd\n",
392 static union dinode *
395 struct ino_blk *iblk;
402 blk = ino_to_fsba(fs, ino);
403 sc = cg_lookup(ino_to_cg(fs, ino));
404 iblk = sc->sc_lastiblk;
405 if (iblk && iblk->ib_blk == blk)
407 hd = &sc->sc_iblkhash[SUJ_HASH(fragstoblks(fs, blk))];
408 LIST_FOREACH(iblk, hd, ib_next)
409 if (iblk->ib_blk == blk)
412 * The inode block wasn't located, allocate a new one.
414 iblk = errmalloc(sizeof(*iblk));
415 bzero(iblk, sizeof(*iblk));
416 iblk->ib_buf = errmalloc(fs->fs_bsize);
418 iblk->ib_startinginum = rounddown(ino, INOPB(fs));
419 LIST_INSERT_HEAD(hd, iblk, ib_next);
420 if (bread(&disk, fsbtodb(fs, blk), iblk->ib_buf, fs->fs_bsize) == -1)
421 err_suj("Failed to read inode block %jd\n", blk);
423 sc->sc_lastiblk = iblk;
424 off = ino_to_fsbo(fs, ino);
425 if (fs->fs_magic == FS_UFS1_MAGIC)
426 return (union dinode *)&((struct ufs1_dinode *)iblk->ib_buf)[off];
427 dp = (union dinode *)&((struct ufs2_dinode *)iblk->ib_buf)[off];
429 ffs_verify_dinode_ckhash(fs, (struct ufs2_dinode *)dp) != 0) {
430 pwarn("ino_read: INODE CHECK-HASH FAILED");
432 if (preen || reply("FIX") != 0) {
434 printf(" (FIXED)\n");
444 struct ino_blk *iblk;
450 blk = ino_to_fsba(fs, ino);
451 sc = cg_lookup(ino_to_cg(fs, ino));
452 iblk = sc->sc_lastiblk;
453 if (iblk && iblk->ib_blk == blk) {
454 if (fs->fs_magic == FS_UFS2_MAGIC) {
455 off = ino_to_fsbo(fs, ino);
456 ffs_update_dinode_ckhash(fs,
457 &((struct ufs2_dinode *)iblk->ib_buf)[off]);
462 hd = &sc->sc_iblkhash[SUJ_HASH(fragstoblks(fs, blk))];
463 LIST_FOREACH(iblk, hd, ib_next) {
464 if (iblk->ib_blk == blk) {
465 if (fs->fs_magic == FS_UFS2_MAGIC) {
466 off = ino_to_fsbo(fs, ino);
467 ffs_update_dinode_ckhash(fs,
468 &((struct ufs2_dinode *)iblk->ib_buf)[off]);
479 iblk_write(struct ino_blk *iblk)
481 struct ufs2_dinode *dp;
484 if (iblk->ib_dirty == 0)
486 if (debug && fs->fs_magic == FS_UFS2_MAGIC) {
487 dp = (struct ufs2_dinode *)iblk->ib_buf;
488 for (i = 0; i < INOPB(fs); dp++, i++) {
489 if (ffs_verify_dinode_ckhash(fs, dp) == 0)
491 pwarn("iblk_write: INODE CHECK-HASH FAILED");
492 prtinode(iblk->ib_startinginum + i, (union dinode *)dp);
493 if (preen || reply("FIX") != 0) {
495 printf(" (FIXED)\n");
496 ino_dirty(iblk->ib_startinginum + i);
500 if (bwrite(&disk, fsbtodb(fs, iblk->ib_blk), iblk->ib_buf,
502 err_suj("Failed to write inode block %jd\n", iblk->ib_blk);
506 blk_overlaps(struct jblkrec *brec, ufs2_daddr_t start, int frags)
513 bstart = brec->jb_blkno + brec->jb_oldfrags;
514 bend = bstart + brec->jb_frags;
515 if (start < bend && end > bstart)
521 blk_equals(struct jblkrec *brec, ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t start,
525 if (brec->jb_ino != ino || brec->jb_lbn != lbn)
527 if (brec->jb_blkno + brec->jb_oldfrags != start)
529 if (brec->jb_frags < frags)
535 blk_setmask(struct jblkrec *brec, int *mask)
539 for (i = brec->jb_oldfrags; i < brec->jb_oldfrags + brec->jb_frags; i++)
544 * Determine whether a given block has been reallocated to a new location.
545 * Returns a mask of overlapping bits if any frags have been reused or
546 * zero if the block has not been re-used and the contents can be trusted.
548 * This is used to ensure that an orphaned pointer due to truncate is safe
549 * to be freed. The mask value can be used to free partial blocks.
552 blk_freemask(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t lbn, int frags)
554 struct suj_blk *sblk;
555 struct suj_rec *srec;
556 struct jblkrec *brec;
561 * To be certain we're not freeing a reallocated block we lookup
562 * this block in the blk hash and see if there is an allocation
563 * journal record that overlaps with any fragments in the block
564 * we're concerned with. If any fragments have ben reallocated
565 * the block has already been freed and re-used for another purpose.
568 sblk = blk_lookup(blknum(fs, blk), 0);
571 off = blk - sblk->sb_blk;
572 TAILQ_FOREACH(srec, &sblk->sb_recs, sr_next) {
573 brec = (struct jblkrec *)srec->sr_rec;
575 * If the block overlaps but does not match
576 * exactly this record refers to the current
579 if (blk_overlaps(brec, blk, frags) == 0)
581 if (blk_equals(brec, ino, lbn, blk, frags) == 1)
584 blk_setmask(brec, &mask);
587 printf("blk_freemask: blk %jd sblk %jd off %d mask 0x%X\n",
588 blk, sblk->sb_blk, off, mask);
589 return (mask >> off);
593 * Determine whether it is safe to follow an indirect. It is not safe
594 * if any part of the indirect has been reallocated or the last journal
595 * entry was an allocation. Just allocated indirects may not have valid
596 * pointers yet and all of their children will have their own records.
597 * It is also not safe to follow an indirect if the cg bitmap has been
598 * cleared as a new allocation may write to the block prior to the journal
601 * Returns 1 if it's safe to follow the indirect and 0 otherwise.
604 blk_isindir(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t lbn)
606 struct suj_blk *sblk;
607 struct jblkrec *brec;
609 sblk = blk_lookup(blk, 0);
612 if (TAILQ_EMPTY(&sblk->sb_recs))
614 brec = (struct jblkrec *)TAILQ_LAST(&sblk->sb_recs, srechd)->sr_rec;
615 if (blk_equals(brec, ino, lbn, blk, fs->fs_frag))
616 if (brec->jb_op == JOP_FREEBLK)
617 return (!blk_isfree(blk));
622 * Clear an inode from the cg bitmap. If the inode was already clear return
623 * 0 so the caller knows it does not have to check the inode contents.
626 ino_free(ino_t ino, int mode)
633 cg = ino_to_cg(fs, ino);
634 ino = ino % fs->fs_ipg;
637 inosused = cg_inosused(cgp);
639 * The bitmap may never have made it to the disk so we have to
640 * conditionally clear. We can avoid writing the cg in this case.
642 if (isclr(inosused, ino))
645 clrbit(inosused, ino);
646 if (ino < cgp->cg_irotor)
647 cgp->cg_irotor = ino;
648 cgp->cg_cs.cs_nifree++;
649 if ((mode & IFMT) == IFDIR) {
651 cgp->cg_cs.cs_ndir--;
659 * Free 'frags' frags starting at filesystem block 'bno' skipping any frags
663 blk_free(ufs2_daddr_t bno, int mask, int frags)
665 ufs1_daddr_t fragno, cgbno;
672 printf("Freeing %d frags at blk %jd mask 0x%x\n",
677 cgbno = dtogd(fs, bno);
678 blksfree = cg_blksfree(cgp);
681 * If it's not allocated we only wrote the journal entry
682 * and never the bitmaps. Here we unconditionally clear and
683 * resolve the cg summary later.
685 if (frags == fs->fs_frag && mask == 0) {
686 fragno = fragstoblks(fs, cgbno);
687 ffs_setblock(fs, blksfree, fragno);
691 * deallocate the fragment
693 for (i = 0; i < frags; i++)
694 if ((mask & (1 << i)) == 0 && isclr(blksfree, cgbno +i)) {
696 setbit(blksfree, cgbno + i);
703 * Returns 1 if the whole block starting at 'bno' is marked free and 0
707 blk_isfree(ufs2_daddr_t bno)
711 sc = cg_lookup(dtog(fs, bno));
712 return ffs_isblock(fs, cg_blksfree(sc->sc_cgp), dtogd(fs, bno));
716 * Fetch an indirect block to find the block at a given lbn. The lbn
717 * may be negative to fetch a specific indirect block pointer or positive
718 * to fetch a specific block.
721 indir_blkatoff(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t cur, ufs_lbn_t lbn)
732 level = lbn_level(cur);
734 err_suj("Invalid indir lbn %jd\n", lbn);
735 if (level == 0 && lbn < 0)
736 err_suj("Invalid lbn %jd\n", lbn);
737 bap2 = (void *)dblk_read(blk, fs->fs_bsize);
740 base = -(cur + level);
741 for (i = level; i > 0; i--)
742 lbnadd *= NINDIR(fs);
744 i = (lbn - base) / lbnadd;
746 i = (-lbn - base) / lbnadd;
747 if (i < 0 || i >= NINDIR(fs))
748 err_suj("Invalid indirect index %d produced by lbn %jd\n",
751 cur = base + (i * lbnadd);
753 cur = -(base + (i * lbnadd)) - (level - 1);
754 if (fs->fs_magic == FS_UFS1_MAGIC)
761 err_suj("Invalid lbn %jd at level 0\n", lbn);
762 return indir_blkatoff(blk, ino, cur, lbn);
766 * Finds the disk block address at the specified lbn within the inode
767 * specified by ip. This follows the whole tree and honors di_size and
768 * di_extsize so it is a true test of reachability. The lbn may be
769 * negative if an extattr or indirect block is requested.
772 ino_blkatoff(union dinode *ip, ino_t ino, ufs_lbn_t lbn, int *frags)
780 * Handle extattr blocks first.
782 if (lbn < 0 && lbn >= -UFS_NXADDR) {
784 if (lbn > lblkno(fs, ip->dp2.di_extsize - 1))
786 *frags = numfrags(fs, sblksize(fs, ip->dp2.di_extsize, lbn));
787 return (ip->dp2.di_extb[lbn]);
790 * Now direct and indirect.
792 if (DIP(ip, di_mode) == IFLNK &&
793 DIP(ip, di_size) < fs->fs_maxsymlinklen)
795 if (lbn >= 0 && lbn < UFS_NDADDR) {
796 *frags = numfrags(fs, sblksize(fs, DIP(ip, di_size), lbn));
797 return (DIP(ip, di_db[lbn]));
799 *frags = fs->fs_frag;
801 for (i = 0, tmpval = NINDIR(fs), cur = UFS_NDADDR; i < UFS_NIADDR; i++,
802 tmpval *= NINDIR(fs), cur = next) {
805 return (DIP(ip, di_ib[i]));
807 * Determine whether the lbn in question is within this tree.
809 if (lbn < 0 && -lbn >= next)
811 if (lbn > 0 && lbn >= next)
813 return indir_blkatoff(DIP(ip, di_ib[i]), ino, -cur - i, lbn);
815 err_suj("lbn %jd not in ino\n", lbn);
820 * Determine whether a block exists at a particular lbn in an inode.
821 * Returns 1 if found, 0 if not. lbn may be negative for indirects
825 blk_isat(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int *frags)
832 if (DIP(ip, di_nlink) == 0 || DIP(ip, di_mode) == 0)
834 nblk = ino_blkatoff(ip, ino, lbn, frags);
836 return (nblk == blk);
840 * Clear the directory entry at diroff that should point to child. Minimal
841 * checking is done and it is assumed that this path was verified with isat.
844 ino_clrat(ino_t parent, off_t diroff, ino_t child)
856 printf("Clearing inode %ju from parent %ju at offset %jd\n",
857 (uintmax_t)child, (uintmax_t)parent, diroff);
859 lbn = lblkno(fs, diroff);
860 doff = blkoff(fs, diroff);
861 dip = ino_read(parent);
862 blk = ino_blkatoff(dip, parent, lbn, &frags);
863 blksize = sblksize(fs, DIP(dip, di_size), lbn);
864 block = dblk_read(blk, blksize);
865 dp = (struct direct *)&block[doff];
866 if (dp->d_ino != child)
867 errx(1, "Inode %ju does not exist in %ju at %jd",
868 (uintmax_t)child, (uintmax_t)parent, diroff);
872 * The actual .. reference count will already have been removed
873 * from the parent by the .. remref record.
878 * Determines whether a pointer to an inode exists within a directory
879 * at a specified offset. Returns the mode of the found entry.
882 ino_isat(ino_t parent, off_t diroff, ino_t child, int *mode, int *isdot)
895 dip = ino_read(parent);
896 *mode = DIP(dip, di_mode);
897 if ((*mode & IFMT) != IFDIR) {
900 * This can happen if the parent inode
904 printf("Directory %ju has bad mode %o\n",
905 (uintmax_t)parent, *mode);
907 printf("Directory %ju has zero mode\n",
912 lbn = lblkno(fs, diroff);
913 doff = blkoff(fs, diroff);
914 blksize = sblksize(fs, DIP(dip, di_size), lbn);
915 if (diroff + DIRECTSIZ(1) > DIP(dip, di_size) || doff >= blksize) {
917 printf("ino %ju absent from %ju due to offset %jd"
918 " exceeding size %jd\n",
919 (uintmax_t)child, (uintmax_t)parent, diroff,
923 blk = ino_blkatoff(dip, parent, lbn, &frags);
926 printf("Sparse directory %ju", (uintmax_t)parent);
929 block = dblk_read(blk, blksize);
931 * Walk through the records from the start of the block to be
932 * certain we hit a valid record and not some junk in the middle
933 * of a file name. Stop when we reach or pass the expected offset.
935 dpoff = rounddown(doff, DIRBLKSIZ);
937 dp = (struct direct *)&block[dpoff];
940 if (dp->d_reclen == 0)
942 dpoff += dp->d_reclen;
943 } while (dpoff <= doff);
944 if (dpoff > fs->fs_bsize)
945 err_suj("Corrupt directory block in dir ino %ju\n",
950 printf("ino %ju not found in %ju, lbn %jd, dpoff %d\n",
951 (uintmax_t)child, (uintmax_t)parent, lbn, dpoff);
955 * We found the item in question. Record the mode and whether it's
956 * a . or .. link for the caller.
958 if (dp->d_ino == child) {
961 else if (dp->d_namlen == 2 &&
962 dp->d_name[0] == '.' && dp->d_name[1] == '.')
964 *mode = DTTOIF(dp->d_type);
968 printf("ino %ju doesn't match dirent ino %ju in parent %ju\n",
969 (uintmax_t)child, (uintmax_t)dp->d_ino, (uintmax_t)parent);
973 #define VISIT_INDIR 0x0001
974 #define VISIT_EXT 0x0002
975 #define VISIT_ROOT 0x0004 /* Operation came via root & valid pointers. */
978 * Read an indirect level which may or may not be linked into an inode.
981 indir_visit(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, uint64_t *frags,
982 ino_visitor visitor, int flags)
993 * Don't visit indirect blocks with contents we can't trust. This
994 * should only happen when indir_visit() is called to complete a
995 * truncate that never finished and not when a pointer is found via
1000 level = lbn_level(lbn);
1002 err_suj("Invalid level for lbn %jd\n", lbn);
1003 if ((flags & VISIT_ROOT) == 0 && blk_isindir(blk, ino, lbn) == 0) {
1005 printf("blk %jd ino %ju lbn %jd(%d) is not indir.\n",
1006 blk, (uintmax_t)ino, lbn, level);
1010 for (i = level; i > 0; i--)
1011 lbnadd *= NINDIR(fs);
1012 bap1 = (void *)dblk_read(blk, fs->fs_bsize);
1013 bap2 = (void *)bap1;
1014 for (i = 0; i < NINDIR(fs); i++) {
1015 if (fs->fs_magic == FS_UFS1_MAGIC)
1022 nlbn = -lbn + i * lbnadd;
1023 (*frags) += fs->fs_frag;
1024 visitor(ino, nlbn, nblk, fs->fs_frag);
1026 nlbn = (lbn + 1) - (i * lbnadd);
1027 indir_visit(ino, nlbn, nblk, frags, visitor, flags);
1031 if (flags & VISIT_INDIR) {
1032 (*frags) += fs->fs_frag;
1033 visitor(ino, lbn, blk, fs->fs_frag);
1038 * Visit each block in an inode as specified by 'flags' and call a
1039 * callback function. The callback may inspect or free blocks. The
1040 * count of frags found according to the size in the file is returned.
1041 * This is not valid for sparse files but may be used to determine
1042 * the correct di_blocks for a file.
1045 ino_visit(union dinode *ip, ino_t ino, ino_visitor visitor, int flags)
1056 size = DIP(ip, di_size);
1057 mode = DIP(ip, di_mode) & IFMT;
1059 if ((flags & VISIT_EXT) &&
1060 fs->fs_magic == FS_UFS2_MAGIC && ip->dp2.di_extsize) {
1061 for (i = 0; i < UFS_NXADDR; i++) {
1062 if (ip->dp2.di_extb[i] == 0)
1064 frags = sblksize(fs, ip->dp2.di_extsize, i);
1065 frags = numfrags(fs, frags);
1067 visitor(ino, -1 - i, ip->dp2.di_extb[i], frags);
1070 /* Skip datablocks for short links and devices. */
1071 if (mode == IFBLK || mode == IFCHR ||
1072 (mode == IFLNK && size < fs->fs_maxsymlinklen))
1074 for (i = 0; i < UFS_NDADDR; i++) {
1075 if (DIP(ip, di_db[i]) == 0)
1077 frags = sblksize(fs, size, i);
1078 frags = numfrags(fs, frags);
1080 visitor(ino, i, DIP(ip, di_db[i]), frags);
1083 * We know the following indirects are real as we're following
1084 * real pointers to them.
1086 flags |= VISIT_ROOT;
1087 for (i = 0, tmpval = NINDIR(fs), lbn = UFS_NDADDR; i < UFS_NIADDR; i++,
1089 nextlbn = lbn + tmpval;
1090 tmpval *= NINDIR(fs);
1091 if (DIP(ip, di_ib[i]) == 0)
1093 indir_visit(ino, -lbn - i, DIP(ip, di_ib[i]), &fragcnt, visitor,
1100 * Null visitor function used when we just want to count blocks and
1105 null_visit(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
1112 * Recalculate di_blocks when we discover that a block allocation or
1113 * free was not successfully completed. The kernel does not roll this back
1114 * because it would be too expensive to compute which indirects were
1115 * reachable at the time the inode was written.
1118 ino_adjblks(struct suj_ino *sino)
1129 /* No need to adjust zero'd inodes. */
1130 if (DIP(ip, di_mode) == 0)
1133 * Visit all blocks and count them as well as recording the last
1134 * valid lbn in the file. If the file size doesn't agree with the
1135 * last lbn we need to truncate to fix it. Otherwise just adjust
1139 frags = ino_visit(ip, ino, null_visit, VISIT_INDIR | VISIT_EXT);
1140 blocks = fsbtodb(fs, frags);
1142 * We assume the size and direct block list is kept coherent by
1143 * softdep. For files that have extended into indirects we truncate
1144 * to the size in the inode or the maximum size permitted by
1145 * populated indirects.
1147 if (visitlbn >= UFS_NDADDR) {
1148 isize = DIP(ip, di_size);
1149 size = lblktosize(fs, visitlbn + 1);
1152 /* Always truncate to free any unpopulated indirects. */
1153 ino_trunc(sino->si_ino, isize);
1156 if (blocks == DIP(ip, di_blocks))
1159 printf("ino %ju adjusting block count from %jd to %jd\n",
1160 (uintmax_t)ino, DIP(ip, di_blocks), blocks);
1161 DIP_SET(ip, di_blocks, blocks);
1166 blk_free_visit(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
1169 blk_free(blk, blk_freemask(blk, ino, lbn, frags), frags);
1173 * Free a block or tree of blocks that was previously rooted in ino at
1174 * the given lbn. If the lbn is an indirect all children are freed
1178 blk_free_lbn(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t lbn, int frags, int follow)
1183 mask = blk_freemask(blk, ino, lbn, frags);
1185 if (lbn <= -UFS_NDADDR && follow && mask == 0)
1186 indir_visit(ino, lbn, blk, &resid, blk_free_visit, VISIT_INDIR);
1188 blk_free(blk, mask, frags);
1192 ino_setskip(struct suj_ino *sino, ino_t parent)
1197 if (ino_isat(sino->si_ino, DOTDOT_OFFSET, parent, &mode, &isdot))
1198 sino->si_skipparent = 1;
1202 ino_remref(ino_t parent, ino_t child, uint64_t diroff, int isdotdot)
1204 struct suj_ino *sino;
1205 struct suj_rec *srec;
1206 struct jrefrec *rrec;
1209 * Lookup this inode to see if we have a record for it.
1211 sino = ino_lookup(child, 0);
1213 * Tell any child directories we've already removed their
1214 * parent link cnt. Don't try to adjust our link down again.
1216 if (sino != NULL && isdotdot == 0)
1217 ino_setskip(sino, parent);
1219 * No valid record for this inode. Just drop the on-disk
1222 if (sino == NULL || sino->si_hasrecs == 0) {
1227 * Use ino_adjust() if ino_check() has already processed this
1228 * child. If we lose the last non-dot reference to a
1229 * directory it will be discarded.
1231 if (sino->si_linkadj) {
1234 sino->si_dotlinks--;
1239 * If we haven't yet processed this inode we need to make
1240 * sure we will successfully discover the lost path. If not
1241 * use nlinkadj to remember.
1243 TAILQ_FOREACH(srec, &sino->si_recs, sr_next) {
1244 rrec = (struct jrefrec *)srec->sr_rec;
1245 if (rrec->jr_parent == parent &&
1246 rrec->jr_diroff == diroff)
1249 sino->si_nlinkadj++;
1253 * Free the children of a directory when the directory is discarded.
1256 ino_free_children(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
1258 struct suj_ino *sino;
1267 sino = ino_lookup(ino, 0);
1269 skipparent = sino->si_skipparent;
1272 size = lfragtosize(fs, frags);
1273 block = dblk_read(blk, size);
1274 dp = (struct direct *)&block[0];
1275 for (dpoff = 0; dpoff < size && dp->d_reclen; dpoff += dp->d_reclen) {
1276 dp = (struct direct *)&block[dpoff];
1277 if (dp->d_ino == 0 || dp->d_ino == UFS_WINO)
1279 if (dp->d_namlen == 1 && dp->d_name[0] == '.')
1281 isdotdot = dp->d_namlen == 2 && dp->d_name[0] == '.' &&
1282 dp->d_name[1] == '.';
1283 if (isdotdot && skipparent == 1)
1286 printf("Directory %ju removing ino %ju name %s\n",
1287 (uintmax_t)ino, (uintmax_t)dp->d_ino, dp->d_name);
1288 diroff = lblktosize(fs, lbn) + dpoff;
1289 ino_remref(ino, dp->d_ino, diroff, isdotdot);
1294 * Reclaim an inode, freeing all blocks and decrementing all children's
1295 * link counts. Free the inode back to the cg.
1298 ino_reclaim(union dinode *ip, ino_t ino, int mode)
1302 if (ino == UFS_ROOTINO)
1303 err_suj("Attempting to free UFS_ROOTINO\n");
1305 printf("Truncating and freeing ino %ju, nlink %d, mode %o\n",
1306 (uintmax_t)ino, DIP(ip, di_nlink), DIP(ip, di_mode));
1308 /* We are freeing an inode or directory. */
1309 if ((DIP(ip, di_mode) & IFMT) == IFDIR)
1310 ino_visit(ip, ino, ino_free_children, 0);
1311 DIP_SET(ip, di_nlink, 0);
1312 ino_visit(ip, ino, blk_free_visit, VISIT_EXT | VISIT_INDIR);
1313 /* Here we have to clear the inode and release any blocks it holds. */
1314 gen = DIP(ip, di_gen);
1315 if (fs->fs_magic == FS_UFS1_MAGIC)
1316 bzero(ip, sizeof(struct ufs1_dinode));
1318 bzero(ip, sizeof(struct ufs2_dinode));
1319 DIP_SET(ip, di_gen, gen);
1321 ino_free(ino, mode);
1326 * Adjust an inode's link count down by one when a directory goes away.
1337 nlink = DIP(ip, di_nlink);
1338 mode = DIP(ip, di_mode);
1340 err_suj("Inode %d link count %d invalid\n", ino, nlink);
1342 err_suj("Inode %d has a link of %d with 0 mode\n", ino, nlink);
1344 if ((mode & IFMT) == IFDIR)
1348 if (nlink < reqlink) {
1350 printf("ino %ju not enough links to live %d < %d\n",
1351 (uintmax_t)ino, nlink, reqlink);
1352 ino_reclaim(ip, ino, mode);
1355 DIP_SET(ip, di_nlink, nlink);
1360 * Adjust the inode link count to 'nlink'. If the count reaches zero
1364 ino_adjust(struct suj_ino *sino)
1366 struct jrefrec *rrec;
1367 struct suj_rec *srec;
1368 struct suj_ino *stmp;
1377 nlink = sino->si_nlink;
1379 mode = sino->si_mode & IFMT;
1381 * If it's a directory with no dot links, it was truncated before
1382 * the name was cleared. We need to clear the dirent that
1385 if (mode == IFDIR && nlink == 1 && sino->si_dotlinks == 0) {
1386 sino->si_nlink = nlink = 0;
1387 TAILQ_FOREACH(srec, &sino->si_recs, sr_next) {
1388 rrec = (struct jrefrec *)srec->sr_rec;
1389 if (ino_isat(rrec->jr_parent, rrec->jr_diroff, ino,
1390 &recmode, &isdot) == 0)
1392 ino_clrat(rrec->jr_parent, rrec->jr_diroff, ino);
1396 errx(1, "Directory %ju name not found", (uintmax_t)ino);
1399 * If it's a directory with no real names pointing to it go ahead
1400 * and truncate it. This will free any children.
1402 if (mode == IFDIR && nlink - sino->si_dotlinks == 0) {
1403 sino->si_nlink = nlink = 0;
1405 * Mark any .. links so they know not to free this inode
1406 * when they are removed.
1408 TAILQ_FOREACH(srec, &sino->si_recs, sr_next) {
1409 rrec = (struct jrefrec *)srec->sr_rec;
1410 if (rrec->jr_diroff == DOTDOT_OFFSET) {
1411 stmp = ino_lookup(rrec->jr_parent, 0);
1413 ino_setskip(stmp, ino);
1418 mode = DIP(ip, di_mode) & IFMT;
1419 if (nlink > UFS_LINK_MAX)
1420 err_suj("ino %ju nlink manipulation error, new %ju, old %d\n",
1421 (uintmax_t)ino, (uintmax_t)nlink, DIP(ip, di_nlink));
1423 printf("Adjusting ino %ju, nlink %ju, old link %d lastmode %o\n",
1424 (uintmax_t)ino, (uintmax_t)nlink, DIP(ip, di_nlink),
1428 printf("ino %ju, zero inode freeing bitmap\n",
1430 ino_free(ino, sino->si_mode);
1433 /* XXX Should be an assert? */
1434 if (mode != sino->si_mode && debug)
1435 printf("ino %ju, mode %o != %o\n",
1436 (uintmax_t)ino, mode, sino->si_mode);
1437 if ((mode & IFMT) == IFDIR)
1441 /* If the inode doesn't have enough links to live, free it. */
1442 if (nlink < reqlink) {
1444 printf("ino %ju not enough links to live %ju < %ju\n",
1445 (uintmax_t)ino, (uintmax_t)nlink,
1446 (uintmax_t)reqlink);
1447 ino_reclaim(ip, ino, mode);
1450 /* If required write the updated link count. */
1451 if (DIP(ip, di_nlink) == nlink) {
1453 printf("ino %ju, link matches, skipping.\n",
1457 DIP_SET(ip, di_nlink, nlink);
1462 * Truncate some or all blocks in an indirect, freeing any that are required
1463 * and zeroing the indirect.
1466 indir_trunc(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, ufs_lbn_t lastlbn)
1481 level = lbn_level(lbn);
1483 err_suj("Invalid level for lbn %jd\n", lbn);
1485 for (i = level; i > 0; i--)
1486 lbnadd *= NINDIR(fs);
1487 bap1 = (void *)dblk_read(blk, fs->fs_bsize);
1488 bap2 = (void *)bap1;
1489 for (i = 0; i < NINDIR(fs); i++) {
1490 if (fs->fs_magic == FS_UFS1_MAGIC)
1497 nlbn = (lbn + 1) - (i * lbnadd);
1499 * Calculate the lbn of the next indirect to
1500 * determine if any of this indirect must be
1503 next = -(lbn + level) + ((i+1) * lbnadd);
1504 if (next <= lastlbn)
1506 indir_trunc(ino, nlbn, nblk, lastlbn);
1507 /* If all of this indirect was reclaimed, free it. */
1508 nlbn = next - lbnadd;
1512 nlbn = -lbn + i * lbnadd;
1517 blk_free(nblk, 0, fs->fs_frag);
1518 if (fs->fs_magic == FS_UFS1_MAGIC)
1528 * Truncate an inode to the minimum of the given size or the last populated
1529 * block after any over size have been discarded. The kernel would allocate
1530 * the last block in the file but fsck does not and neither do we. This
1531 * code never extends files, only shrinks them.
1534 ino_trunc(ino_t ino, off_t size)
1538 uint64_t totalfrags;
1550 mode = DIP(ip, di_mode) & IFMT;
1551 cursize = DIP(ip, di_size);
1553 printf("Truncating ino %ju, mode %o to size %jd from size %jd\n",
1554 (uintmax_t)ino, mode, size, cursize);
1556 /* Skip datablocks for short links and devices. */
1557 if (mode == 0 || mode == IFBLK || mode == IFCHR ||
1558 (mode == IFLNK && cursize < fs->fs_maxsymlinklen))
1563 lastlbn = lblkno(fs, blkroundup(fs, size));
1564 for (i = lastlbn; i < UFS_NDADDR; i++) {
1565 if (DIP(ip, di_db[i]) == 0)
1567 frags = sblksize(fs, cursize, i);
1568 frags = numfrags(fs, frags);
1569 blk_free(DIP(ip, di_db[i]), 0, frags);
1570 DIP_SET(ip, di_db[i], 0);
1573 * Follow indirect blocks, freeing anything required.
1575 for (i = 0, tmpval = NINDIR(fs), lbn = UFS_NDADDR; i < UFS_NIADDR; i++,
1577 nextlbn = lbn + tmpval;
1578 tmpval *= NINDIR(fs);
1579 /* If we're not freeing any in this indirect range skip it. */
1580 if (lastlbn >= nextlbn)
1582 if (DIP(ip, di_ib[i]) == 0)
1584 indir_trunc(ino, -lbn - i, DIP(ip, di_ib[i]), lastlbn);
1585 /* If we freed everything in this indirect free the indir. */
1588 blk_free(DIP(ip, di_ib[i]), 0, fs->fs_frag);
1589 DIP_SET(ip, di_ib[i], 0);
1593 * Now that we've freed any whole blocks that exceed the desired
1594 * truncation size, figure out how many blocks remain and what the
1595 * last populated lbn is. We will set the size to this last lbn
1596 * rather than worrying about allocating the final lbn as the kernel
1597 * would've done. This is consistent with normal fsck behavior.
1600 totalfrags = ino_visit(ip, ino, null_visit, VISIT_INDIR | VISIT_EXT);
1601 if (size > lblktosize(fs, visitlbn + 1))
1602 size = lblktosize(fs, visitlbn + 1);
1604 * If we're truncating direct blocks we have to adjust frags
1607 if (visitlbn < UFS_NDADDR && totalfrags) {
1608 long oldspace, newspace;
1610 bn = DIP(ip, di_db[visitlbn]);
1612 err_suj("Bad blk at ino %ju lbn %jd\n",
1613 (uintmax_t)ino, visitlbn);
1614 oldspace = sblksize(fs, cursize, visitlbn);
1615 newspace = sblksize(fs, size, visitlbn);
1616 if (oldspace != newspace) {
1617 bn += numfrags(fs, newspace);
1618 frags = numfrags(fs, oldspace - newspace);
1619 blk_free(bn, 0, frags);
1620 totalfrags -= frags;
1623 DIP_SET(ip, di_blocks, fsbtodb(fs, totalfrags));
1624 DIP_SET(ip, di_size, size);
1627 * If we've truncated into the middle of a block or frag we have
1628 * to zero it here. Otherwise the file could extend into
1629 * uninitialized space later.
1631 off = blkoff(fs, size);
1632 if (off && DIP(ip, di_mode) != IFDIR) {
1636 bn = ino_blkatoff(ip, ino, visitlbn, &frags);
1638 err_suj("Block missing from ino %ju at lbn %jd\n",
1639 (uintmax_t)ino, visitlbn);
1640 clrsize = frags * fs->fs_fsize;
1641 buf = dblk_read(bn, clrsize);
1644 bzero(buf, clrsize);
1651 * Process records available for one inode and determine whether the
1652 * link count is correct or needs adjusting.
1655 ino_check(struct suj_ino *sino)
1657 struct suj_rec *srec;
1658 struct jrefrec *rrec;
1668 if (sino->si_hasrecs == 0)
1671 rrec = (struct jrefrec *)TAILQ_FIRST(&sino->si_recs)->sr_rec;
1672 nlink = rrec->jr_nlink;
1675 removes = sino->si_nlinkadj;
1676 TAILQ_FOREACH(srec, &sino->si_recs, sr_next) {
1677 rrec = (struct jrefrec *)srec->sr_rec;
1678 isat = ino_isat(rrec->jr_parent, rrec->jr_diroff,
1679 rrec->jr_ino, &mode, &isdot);
1680 if (isat && (mode & IFMT) != (rrec->jr_mode & IFMT))
1681 err_suj("Inode mode/directory type mismatch %o != %o\n",
1682 mode, rrec->jr_mode);
1684 printf("jrefrec: op %d ino %ju, nlink %ju, parent %ju, "
1685 "diroff %jd, mode %o, isat %d, isdot %d\n",
1686 rrec->jr_op, (uintmax_t)rrec->jr_ino,
1687 (uintmax_t)rrec->jr_nlink,
1688 (uintmax_t)rrec->jr_parent,
1689 (uintmax_t)rrec->jr_diroff,
1690 rrec->jr_mode, isat, isdot);
1691 mode = rrec->jr_mode & IFMT;
1692 if (rrec->jr_op == JOP_REMREF)
1699 * The number of links that remain are the starting link count
1700 * subtracted by the total number of removes with the total
1701 * links discovered back in. An incomplete remove thus
1702 * makes no change to the link count but an add increases
1707 "ino %ju nlink %ju newlinks %ju removes %ju dotlinks %ju\n",
1708 (uintmax_t)ino, (uintmax_t)nlink, (uintmax_t)newlinks,
1709 (uintmax_t)removes, (uintmax_t)dotlinks);
1712 sino->si_linkadj = 1;
1713 sino->si_nlink = nlink;
1714 sino->si_dotlinks = dotlinks;
1715 sino->si_mode = mode;
1720 * Process records available for one block and determine whether it is
1721 * still allocated and whether the owning inode needs to be updated or
1725 blk_check(struct suj_blk *sblk)
1727 struct suj_rec *srec;
1728 struct jblkrec *brec;
1729 struct suj_ino *sino;
1736 * Each suj_blk actually contains records for any fragments in that
1737 * block. As a result we must evaluate each record individually.
1740 TAILQ_FOREACH(srec, &sblk->sb_recs, sr_next) {
1741 brec = (struct jblkrec *)srec->sr_rec;
1742 frags = brec->jb_frags;
1743 blk = brec->jb_blkno + brec->jb_oldfrags;
1744 isat = blk_isat(brec->jb_ino, brec->jb_lbn, blk, &frags);
1745 if (sino == NULL || sino->si_ino != brec->jb_ino) {
1746 sino = ino_lookup(brec->jb_ino, 1);
1747 sino->si_blkadj = 1;
1750 printf("op %d blk %jd ino %ju lbn %jd frags %d isat %d (%d)\n",
1751 brec->jb_op, blk, (uintmax_t)brec->jb_ino,
1752 brec->jb_lbn, brec->jb_frags, isat, frags);
1754 * If we found the block at this address we still have to
1755 * determine if we need to free the tail end that was
1756 * added by adding contiguous fragments from the same block.
1759 if (frags == brec->jb_frags)
1761 mask = blk_freemask(blk, brec->jb_ino, brec->jb_lbn,
1765 frags = brec->jb_frags - frags;
1766 blk_free(blk, mask, frags);
1770 * The block wasn't found, attempt to free it. It won't be
1771 * freed if it was actually reallocated. If this was an
1772 * allocation we don't want to follow indirects as they
1773 * may not be written yet. Any children of the indirect will
1774 * have their own records. If it's a free we need to
1775 * recursively free children.
1777 blk_free_lbn(blk, brec->jb_ino, brec->jb_lbn, brec->jb_frags,
1778 brec->jb_op == JOP_FREEBLK);
1783 * Walk the list of inode records for this cg and resolve moved and duplicate
1784 * inode references now that we have a complete picture.
1787 cg_build(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)
1798 * Handle inodes requiring truncation. This must be done prior to
1799 * looking up any inodes in directories.
1802 cg_trunc(struct suj_cg *sc)
1804 struct suj_ino *sino;
1807 for (i = 0; i < SUJ_HASHSIZE; i++) {
1808 LIST_FOREACH(sino, &sc->sc_inohash[i], si_next) {
1809 if (sino->si_trunc) {
1810 ino_trunc(sino->si_ino,
1811 sino->si_trunc->jt_size);
1812 sino->si_blkadj = 0;
1813 sino->si_trunc = NULL;
1815 if (sino->si_blkadj)
1822 cg_adj_blk(struct suj_cg *sc)
1824 struct suj_ino *sino;
1827 for (i = 0; i < SUJ_HASHSIZE; i++) {
1828 LIST_FOREACH(sino, &sc->sc_inohash[i], si_next) {
1829 if (sino->si_blkadj)
1836 * Free any partially allocated blocks and then resolve inode block
1840 cg_check_blk(struct suj_cg *sc)
1842 struct suj_blk *sblk;
1846 for (i = 0; i < SUJ_HASHSIZE; i++)
1847 LIST_FOREACH(sblk, &sc->sc_blkhash[i], sb_next)
1852 * Walk the list of inode records for this cg, recovering any
1853 * changes which were not complete at the time of crash.
1856 cg_check_ino(struct suj_cg *sc)
1858 struct suj_ino *sino;
1861 for (i = 0; i < SUJ_HASHSIZE; i++)
1862 LIST_FOREACH(sino, &sc->sc_inohash[i], si_next)
1867 * Write a potentially dirty cg. Recalculate the summary information and
1868 * update the superblock summary.
1871 cg_write(struct suj_cg *sc)
1873 ufs1_daddr_t fragno, cgbno, maxbno;
1879 if (sc->sc_dirty == 0)
1882 * Fix the frag and cluster summary.
1885 cgp->cg_cs.cs_nbfree = 0;
1886 cgp->cg_cs.cs_nffree = 0;
1887 bzero(&cgp->cg_frsum, sizeof(cgp->cg_frsum));
1888 maxbno = fragstoblks(fs, fs->fs_fpg);
1889 if (fs->fs_contigsumsize > 0) {
1890 for (i = 1; i <= fs->fs_contigsumsize; i++)
1891 cg_clustersum(cgp)[i] = 0;
1892 bzero(cg_clustersfree(cgp), howmany(maxbno, CHAR_BIT));
1894 blksfree = cg_blksfree(cgp);
1895 for (cgbno = 0; cgbno < maxbno; cgbno++) {
1896 if (ffs_isfreeblock(fs, blksfree, cgbno))
1898 if (ffs_isblock(fs, blksfree, cgbno)) {
1899 ffs_clusteracct(fs, cgp, cgbno, 1);
1900 cgp->cg_cs.cs_nbfree++;
1903 fragno = blkstofrags(fs, cgbno);
1904 blk = blkmap(fs, blksfree, fragno);
1905 ffs_fragacct(fs, blk, cgp->cg_frsum, 1);
1906 for (i = 0; i < fs->fs_frag; i++)
1907 if (isset(blksfree, fragno + i))
1908 cgp->cg_cs.cs_nffree++;
1911 * Update the superblock cg summary from our now correct values
1912 * before writing the block.
1914 fs->fs_cs(fs, sc->sc_cgx) = cgp->cg_cs;
1915 if (cgput(fswritefd, fs, cgp) == -1)
1916 err_suj("Unable to write cylinder group %d\n", sc->sc_cgx);
1920 * Write out any modified inodes.
1923 cg_write_inos(struct suj_cg *sc)
1925 struct ino_blk *iblk;
1928 for (i = 0; i < SUJ_HASHSIZE; i++)
1929 LIST_FOREACH(iblk, &sc->sc_iblkhash[i], ib_next)
1935 cg_apply(void (*apply)(struct suj_cg *))
1940 for (i = 0; i < SUJ_HASHSIZE; i++)
1941 LIST_FOREACH(scg, &cghash[i], sc_next)
1946 * Process the unlinked but referenced file list. Freeing all inodes.
1956 ino = fs->fs_sujfree;
1960 mode = DIP(ip, di_mode) & IFMT;
1961 inon = DIP(ip, di_freelink);
1962 DIP_SET(ip, di_freelink, 0);
1965 * XXX Should this be an errx?
1967 if (DIP(ip, di_nlink) == 0) {
1969 printf("Freeing unlinked ino %ju mode %o\n",
1970 (uintmax_t)ino, mode);
1971 ino_reclaim(ip, ino, mode);
1973 printf("Skipping ino %ju mode %o with link %d\n",
1974 (uintmax_t)ino, mode, DIP(ip, di_nlink));
1980 * Append a new record to the list of records requiring processing.
1983 ino_append(union jrec *rec)
1985 struct jrefrec *refrec;
1986 struct jmvrec *mvrec;
1987 struct suj_ino *sino;
1988 struct suj_rec *srec;
1990 mvrec = &rec->rec_jmvrec;
1991 refrec = &rec->rec_jrefrec;
1992 if (debug && mvrec->jm_op == JOP_MVREF)
1993 printf("ino move: ino %ju, parent %ju, "
1994 "diroff %jd, oldoff %jd\n",
1995 (uintmax_t)mvrec->jm_ino, (uintmax_t)mvrec->jm_parent,
1996 (uintmax_t)mvrec->jm_newoff, (uintmax_t)mvrec->jm_oldoff);
1998 (refrec->jr_op == JOP_ADDREF || refrec->jr_op == JOP_REMREF))
1999 printf("ino ref: op %d, ino %ju, nlink %ju, "
2000 "parent %ju, diroff %jd\n",
2001 refrec->jr_op, (uintmax_t)refrec->jr_ino,
2002 (uintmax_t)refrec->jr_nlink,
2003 (uintmax_t)refrec->jr_parent, (uintmax_t)refrec->jr_diroff);
2004 sino = ino_lookup(((struct jrefrec *)rec)->jr_ino, 1);
2005 sino->si_hasrecs = 1;
2006 srec = errmalloc(sizeof(*srec));
2008 TAILQ_INSERT_TAIL(&sino->si_newrecs, srec, sr_next);
2012 * Add a reference adjustment to the sino list and eliminate dups. The
2013 * primary loop in ino_build_ref() checks for dups but new ones may be
2014 * created as a result of offset adjustments.
2017 ino_add_ref(struct suj_ino *sino, struct suj_rec *srec)
2019 struct jrefrec *refrec;
2020 struct suj_rec *srn;
2021 struct jrefrec *rrn;
2023 refrec = (struct jrefrec *)srec->sr_rec;
2025 * We walk backwards so that the oldest link count is preserved. If
2026 * an add record conflicts with a remove keep the remove. Redundant
2027 * removes are eliminated in ino_build_ref. Otherwise we keep the
2028 * oldest record at a given location.
2030 for (srn = TAILQ_LAST(&sino->si_recs, srechd); srn;
2031 srn = TAILQ_PREV(srn, srechd, sr_next)) {
2032 rrn = (struct jrefrec *)srn->sr_rec;
2033 if (rrn->jr_parent != refrec->jr_parent ||
2034 rrn->jr_diroff != refrec->jr_diroff)
2036 if (rrn->jr_op == JOP_REMREF || refrec->jr_op == JOP_ADDREF) {
2037 rrn->jr_mode = refrec->jr_mode;
2043 * Replace the record in place with the old nlink in case
2044 * we replace the head of the list. Abandon srec as a dup.
2046 refrec->jr_nlink = rrn->jr_nlink;
2047 srn->sr_rec = srec->sr_rec;
2050 TAILQ_INSERT_TAIL(&sino->si_recs, srec, sr_next);
2054 * Create a duplicate of a reference at a previous location.
2057 ino_dup_ref(struct suj_ino *sino, struct jrefrec *refrec, off_t diroff)
2059 struct jrefrec *rrn;
2060 struct suj_rec *srn;
2062 rrn = errmalloc(sizeof(*refrec));
2064 rrn->jr_op = JOP_ADDREF;
2065 rrn->jr_diroff = diroff;
2066 srn = errmalloc(sizeof(*srn));
2067 srn->sr_rec = (union jrec *)rrn;
2068 ino_add_ref(sino, srn);
2072 * Add a reference to the list at all known locations. We follow the offset
2073 * changes for a single instance and create duplicate add refs at each so
2074 * that we can tolerate any version of the directory block. Eliminate
2075 * removes which collide with adds that are seen in the journal. They should
2076 * not adjust the link count down.
2079 ino_build_ref(struct suj_ino *sino, struct suj_rec *srec)
2081 struct jrefrec *refrec;
2082 struct jmvrec *mvrec;
2083 struct suj_rec *srp;
2084 struct suj_rec *srn;
2085 struct jrefrec *rrn;
2088 refrec = (struct jrefrec *)srec->sr_rec;
2090 * Search for a mvrec that matches this offset. Whether it's an add
2091 * or a remove we can delete the mvref after creating a dup record in
2094 if (!TAILQ_EMPTY(&sino->si_movs)) {
2095 diroff = refrec->jr_diroff;
2096 for (srn = TAILQ_LAST(&sino->si_movs, srechd); srn; srn = srp) {
2097 srp = TAILQ_PREV(srn, srechd, sr_next);
2098 mvrec = (struct jmvrec *)srn->sr_rec;
2099 if (mvrec->jm_parent != refrec->jr_parent ||
2100 mvrec->jm_newoff != diroff)
2102 diroff = mvrec->jm_oldoff;
2103 TAILQ_REMOVE(&sino->si_movs, srn, sr_next);
2105 ino_dup_ref(sino, refrec, diroff);
2109 * If a remove wasn't eliminated by an earlier add just append it to
2112 if (refrec->jr_op == JOP_REMREF) {
2113 ino_add_ref(sino, srec);
2117 * Walk the list of records waiting to be added to the list. We
2118 * must check for moves that apply to our current offset and remove
2119 * them from the list. Remove any duplicates to eliminate removes
2120 * with corresponding adds.
2122 TAILQ_FOREACH_SAFE(srn, &sino->si_newrecs, sr_next, srp) {
2123 switch (srn->sr_rec->rec_jrefrec.jr_op) {
2126 * This should actually be an error we should
2127 * have a remove for every add journaled.
2129 rrn = (struct jrefrec *)srn->sr_rec;
2130 if (rrn->jr_parent != refrec->jr_parent ||
2131 rrn->jr_diroff != refrec->jr_diroff)
2133 TAILQ_REMOVE(&sino->si_newrecs, srn, sr_next);
2137 * Once we remove the current iteration of the
2138 * record at this address we're done.
2140 rrn = (struct jrefrec *)srn->sr_rec;
2141 if (rrn->jr_parent != refrec->jr_parent ||
2142 rrn->jr_diroff != refrec->jr_diroff)
2144 TAILQ_REMOVE(&sino->si_newrecs, srn, sr_next);
2145 ino_add_ref(sino, srec);
2149 * Update our diroff based on any moves that match
2150 * and remove the move.
2152 mvrec = (struct jmvrec *)srn->sr_rec;
2153 if (mvrec->jm_parent != refrec->jr_parent ||
2154 mvrec->jm_oldoff != refrec->jr_diroff)
2156 ino_dup_ref(sino, refrec, mvrec->jm_oldoff);
2157 refrec->jr_diroff = mvrec->jm_newoff;
2158 TAILQ_REMOVE(&sino->si_newrecs, srn, sr_next);
2161 err_suj("ino_build_ref: Unknown op %d\n",
2162 srn->sr_rec->rec_jrefrec.jr_op);
2165 ino_add_ref(sino, srec);
2169 * Walk the list of new records and add them in-order resolving any
2170 * dups and adjusted offsets.
2173 ino_build(struct suj_ino *sino)
2175 struct suj_rec *srec;
2177 while ((srec = TAILQ_FIRST(&sino->si_newrecs)) != NULL) {
2178 TAILQ_REMOVE(&sino->si_newrecs, srec, sr_next);
2179 switch (srec->sr_rec->rec_jrefrec.jr_op) {
2182 ino_build_ref(sino, srec);
2186 * Add this mvrec to the queue of pending mvs.
2188 TAILQ_INSERT_TAIL(&sino->si_movs, srec, sr_next);
2191 err_suj("ino_build: Unknown op %d\n",
2192 srec->sr_rec->rec_jrefrec.jr_op);
2195 if (TAILQ_EMPTY(&sino->si_recs))
2196 sino->si_hasrecs = 0;
2200 * Modify journal records so they refer to the base block number
2201 * and a start and end frag range. This is to facilitate the discovery
2202 * of overlapping fragment allocations.
2205 blk_build(struct jblkrec *blkrec)
2207 struct suj_rec *srec;
2208 struct suj_blk *sblk;
2209 struct jblkrec *blkrn;
2214 printf("blk_build: op %d blkno %jd frags %d oldfrags %d "
2215 "ino %ju lbn %jd\n",
2216 blkrec->jb_op, (uintmax_t)blkrec->jb_blkno,
2217 blkrec->jb_frags, blkrec->jb_oldfrags,
2218 (uintmax_t)blkrec->jb_ino, (uintmax_t)blkrec->jb_lbn);
2220 blk = blknum(fs, blkrec->jb_blkno);
2221 frag = fragnum(fs, blkrec->jb_blkno);
2222 sblk = blk_lookup(blk, 1);
2224 * Rewrite the record using oldfrags to indicate the offset into
2225 * the block. Leave jb_frags as the actual allocated count.
2227 blkrec->jb_blkno -= frag;
2228 blkrec->jb_oldfrags = frag;
2229 if (blkrec->jb_oldfrags + blkrec->jb_frags > fs->fs_frag)
2230 err_suj("Invalid fragment count %d oldfrags %d\n",
2231 blkrec->jb_frags, frag);
2233 * Detect dups. If we detect a dup we always discard the oldest
2234 * record as it is superseded by the new record. This speeds up
2235 * later stages but also eliminates free records which are used
2236 * to indicate that the contents of indirects can be trusted.
2238 TAILQ_FOREACH(srec, &sblk->sb_recs, sr_next) {
2239 blkrn = (struct jblkrec *)srec->sr_rec;
2240 if (blkrn->jb_ino != blkrec->jb_ino ||
2241 blkrn->jb_lbn != blkrec->jb_lbn ||
2242 blkrn->jb_blkno != blkrec->jb_blkno ||
2243 blkrn->jb_frags != blkrec->jb_frags ||
2244 blkrn->jb_oldfrags != blkrec->jb_oldfrags)
2247 printf("Removed dup.\n");
2248 /* Discard the free which is a dup with an alloc. */
2249 if (blkrec->jb_op == JOP_FREEBLK)
2251 TAILQ_REMOVE(&sblk->sb_recs, srec, sr_next);
2255 srec = errmalloc(sizeof(*srec));
2256 srec->sr_rec = (union jrec *)blkrec;
2257 TAILQ_INSERT_TAIL(&sblk->sb_recs, srec, sr_next);
2261 ino_build_trunc(struct jtrncrec *rec)
2263 struct suj_ino *sino;
2266 printf("ino_build_trunc: op %d ino %ju, size %jd\n",
2267 rec->jt_op, (uintmax_t)rec->jt_ino,
2268 (uintmax_t)rec->jt_size);
2269 sino = ino_lookup(rec->jt_ino, 1);
2270 if (rec->jt_op == JOP_SYNC) {
2271 sino->si_trunc = NULL;
2274 if (sino->si_trunc == NULL || sino->si_trunc->jt_size > rec->jt_size)
2275 sino->si_trunc = rec;
2279 * Build up tables of the operations we need to recover.
2284 struct suj_seg *seg;
2289 TAILQ_FOREACH(seg, &allsegs, ss_next) {
2291 printf("seg %jd has %d records, oldseq %jd.\n",
2292 seg->ss_rec.jsr_seq, seg->ss_rec.jsr_cnt,
2293 seg->ss_rec.jsr_oldest);
2295 rec = (union jrec *)seg->ss_blk;
2296 for (i = 0; i < seg->ss_rec.jsr_cnt; off += JREC_SIZE, rec++) {
2297 /* skip the segrec. */
2298 if ((off % real_dev_bsize) == 0)
2300 switch (rec->rec_jrefrec.jr_op) {
2308 blk_build((struct jblkrec *)rec);
2312 ino_build_trunc((struct jtrncrec *)rec);
2315 err_suj("Unknown journal operation %d (%d)\n",
2316 rec->rec_jrefrec.jr_op, off);
2324 * Prune the journal segments to those we care about based on the
2325 * oldest sequence in the newest segment. Order the segment list
2326 * based on sequence number.
2331 struct suj_seg *seg;
2332 struct suj_seg *segn;
2337 printf("Pruning up to %jd\n", oldseq);
2338 /* First free the expired segments. */
2339 TAILQ_FOREACH_SAFE(seg, &allsegs, ss_next, segn) {
2340 if (seg->ss_rec.jsr_seq >= oldseq)
2342 TAILQ_REMOVE(&allsegs, seg, ss_next);
2346 /* Next ensure that segments are ordered properly. */
2347 seg = TAILQ_FIRST(&allsegs);
2350 printf("Empty journal\n");
2353 newseq = seg->ss_rec.jsr_seq;
2355 seg = TAILQ_LAST(&allsegs, seghd);
2356 if (seg->ss_rec.jsr_seq >= newseq)
2358 TAILQ_REMOVE(&allsegs, seg, ss_next);
2359 TAILQ_INSERT_HEAD(&allsegs, seg, ss_next);
2360 newseq = seg->ss_rec.jsr_seq;
2363 if (newseq != oldseq) {
2364 TAILQ_FOREACH(seg, &allsegs, ss_next) {
2365 printf("%jd, ", seg->ss_rec.jsr_seq);
2368 err_suj("Journal file sequence mismatch %jd != %jd\n",
2372 * The kernel may asynchronously write segments which can create
2373 * gaps in the sequence space. Throw away any segments after the
2374 * gap as the kernel guarantees only those that are contiguously
2375 * reachable are marked as completed.
2378 TAILQ_FOREACH_SAFE(seg, &allsegs, ss_next, segn) {
2379 if (!discard && newseq++ == seg->ss_rec.jsr_seq) {
2380 jrecs += seg->ss_rec.jsr_cnt;
2381 jbytes += seg->ss_rec.jsr_blocks * real_dev_bsize;
2386 printf("Journal order mismatch %jd != %jd pruning\n",
2387 newseq-1, seg->ss_rec.jsr_seq);
2388 TAILQ_REMOVE(&allsegs, seg, ss_next);
2393 printf("Processing journal segments from %jd to %jd\n",
2398 * Verify the journal inode before attempting to read records.
2401 suj_verifyino(union dinode *ip)
2404 if (DIP(ip, di_nlink) != 1) {
2405 printf("Invalid link count %d for journal inode %ju\n",
2406 DIP(ip, di_nlink), (uintmax_t)sujino);
2410 if ((DIP(ip, di_flags) & (SF_IMMUTABLE | SF_NOUNLINK)) !=
2411 (SF_IMMUTABLE | SF_NOUNLINK)) {
2412 printf("Invalid flags 0x%X for journal inode %ju\n",
2413 DIP(ip, di_flags), (uintmax_t)sujino);
2417 if (DIP(ip, di_mode) != (IFREG | IREAD)) {
2418 printf("Invalid mode %o for journal inode %ju\n",
2419 DIP(ip, di_mode), (uintmax_t)sujino);
2423 if (DIP(ip, di_size) < SUJ_MIN) {
2424 printf("Invalid size %jd for journal inode %ju\n",
2425 DIP(ip, di_size), (uintmax_t)sujino);
2429 if (DIP(ip, di_modrev) != fs->fs_mtime) {
2430 printf("Journal timestamp does not match fs mount time\n");
2438 struct jextent *jb_extent; /* Extent array. */
2439 int jb_avail; /* Available extents. */
2440 int jb_used; /* Last used extent. */
2441 int jb_head; /* Allocator head. */
2442 int jb_off; /* Allocator extent offset. */
2445 ufs2_daddr_t je_daddr; /* Disk block address. */
2446 int je_blocks; /* Disk block count. */
2449 static struct jblocks *suj_jblocks;
2451 static struct jblocks *
2452 jblocks_create(void)
2454 struct jblocks *jblocks;
2457 jblocks = errmalloc(sizeof(*jblocks));
2458 jblocks->jb_avail = 10;
2459 jblocks->jb_used = 0;
2460 jblocks->jb_head = 0;
2461 jblocks->jb_off = 0;
2462 size = sizeof(struct jextent) * jblocks->jb_avail;
2463 jblocks->jb_extent = errmalloc(size);
2464 bzero(jblocks->jb_extent, size);
2470 * Return the next available disk block and the amount of contiguous
2471 * free space it contains.
2474 jblocks_next(struct jblocks *jblocks, int bytes, int *actual)
2476 struct jextent *jext;
2481 blocks = bytes / disk.d_bsize;
2482 jext = &jblocks->jb_extent[jblocks->jb_head];
2483 freecnt = jext->je_blocks - jblocks->jb_off;
2485 jblocks->jb_off = 0;
2486 if (++jblocks->jb_head > jblocks->jb_used)
2488 jext = &jblocks->jb_extent[jblocks->jb_head];
2489 freecnt = jext->je_blocks;
2491 if (freecnt > blocks)
2493 *actual = freecnt * disk.d_bsize;
2494 daddr = jext->je_daddr + jblocks->jb_off;
2500 * Advance the allocation head by a specified number of bytes, consuming
2501 * one journal segment.
2504 jblocks_advance(struct jblocks *jblocks, int bytes)
2507 jblocks->jb_off += bytes / disk.d_bsize;
2511 jblocks_destroy(struct jblocks *jblocks)
2514 free(jblocks->jb_extent);
2519 jblocks_add(struct jblocks *jblocks, ufs2_daddr_t daddr, int blocks)
2521 struct jextent *jext;
2524 jext = &jblocks->jb_extent[jblocks->jb_used];
2525 /* Adding the first block. */
2526 if (jext->je_daddr == 0) {
2527 jext->je_daddr = daddr;
2528 jext->je_blocks = blocks;
2531 /* Extending the last extent. */
2532 if (jext->je_daddr + jext->je_blocks == daddr) {
2533 jext->je_blocks += blocks;
2536 /* Adding a new extent. */
2537 if (++jblocks->jb_used == jblocks->jb_avail) {
2538 jblocks->jb_avail *= 2;
2539 size = sizeof(struct jextent) * jblocks->jb_avail;
2540 jext = errmalloc(size);
2542 bcopy(jblocks->jb_extent, jext,
2543 sizeof(struct jextent) * jblocks->jb_used);
2544 free(jblocks->jb_extent);
2545 jblocks->jb_extent = jext;
2547 jext = &jblocks->jb_extent[jblocks->jb_used];
2548 jext->je_daddr = daddr;
2549 jext->je_blocks = blocks;
2555 * Add a file block from the journal to the extent map. We can't read
2556 * each file block individually because the kernel treats it as a circular
2557 * buffer and segments may span mutliple contiguous blocks.
2560 suj_add_block(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
2563 jblocks_add(suj_jblocks, fsbtodb(fs, blk), fsbtodb(fs, frags));
2569 uint8_t block[1 * 1024 * 1024];
2570 struct suj_seg *seg;
2571 struct jsegrec *recn;
2572 struct jsegrec *rec;
2581 * Read records until we exhaust the journal space. If we find
2582 * an invalid record we start searching for a valid segment header
2583 * at the next block. This is because we don't have a head/tail
2584 * pointer and must recover the information indirectly. At the gap
2585 * between the head and tail we won't necessarily have a valid
2590 size = sizeof(block);
2591 blk = jblocks_next(suj_jblocks, size, &readsize);
2596 * Read 1MB at a time and scan for records within this block.
2598 if (bread(&disk, blk, &block, size) == -1) {
2599 err_suj("Error reading journal block %jd\n",
2602 for (rec = (void *)block; size; size -= recsize,
2603 rec = (struct jsegrec *)((uintptr_t)rec + recsize)) {
2604 recsize = real_dev_bsize;
2605 if (rec->jsr_time != fs->fs_mtime) {
2607 printf("Rec time %jd != fs mtime %jd\n",
2608 rec->jsr_time, fs->fs_mtime);
2609 jblocks_advance(suj_jblocks, recsize);
2612 if (rec->jsr_cnt == 0) {
2614 printf("Found illegal count %d\n",
2616 jblocks_advance(suj_jblocks, recsize);
2619 blocks = rec->jsr_blocks;
2620 recsize = blocks * real_dev_bsize;
2621 if (recsize > size) {
2623 * We may just have run out of buffer, restart
2624 * the loop to re-read from this spot.
2626 if (size < fs->fs_bsize &&
2628 recsize <= fs->fs_bsize)
2631 printf("Found invalid segsize %d > %d\n",
2633 recsize = real_dev_bsize;
2634 jblocks_advance(suj_jblocks, recsize);
2638 * Verify that all blocks in the segment are present.
2640 for (i = 1; i < blocks; i++) {
2641 recn = (void *)((uintptr_t)rec) + i *
2643 if (recn->jsr_seq == rec->jsr_seq &&
2644 recn->jsr_time == rec->jsr_time)
2647 printf("Incomplete record %jd (%d)\n",
2649 recsize = i * real_dev_bsize;
2650 jblocks_advance(suj_jblocks, recsize);
2653 seg = errmalloc(sizeof(*seg));
2654 seg->ss_blk = errmalloc(recsize);
2656 bcopy((void *)rec, seg->ss_blk, recsize);
2657 if (rec->jsr_oldest > oldseq)
2658 oldseq = rec->jsr_oldest;
2659 TAILQ_INSERT_TAIL(&allsegs, seg, ss_next);
2660 jblocks_advance(suj_jblocks, recsize);
2666 * Search a directory block for the SUJ_FILE.
2669 suj_find(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
2671 char block[MAXBSIZE];
2678 bytes = lfragtosize(fs, frags);
2679 if (bread(&disk, fsbtodb(fs, blk), block, bytes) <= 0)
2680 err_suj("Failed to read UFS_ROOTINO directory block %jd\n",
2682 for (off = 0; off < bytes; off += dp->d_reclen) {
2683 dp = (struct direct *)&block[off];
2684 if (dp->d_reclen == 0)
2688 if (dp->d_namlen != strlen(SUJ_FILE))
2690 if (bcmp(dp->d_name, SUJ_FILE, dp->d_namlen) != 0)
2698 * Orchestrate the verification of a filesystem via the softupdates journal.
2701 suj_check(const char *filesys)
2707 struct suj_seg *seg;
2708 struct suj_seg *segn;
2712 if (real_dev_bsize == 0 && ioctl(disk.d_fd, DIOCGSECTORSIZE,
2713 &real_dev_bsize) == -1)
2714 real_dev_bsize = secsize;
2716 printf("dev_bsize %u\n", real_dev_bsize);
2719 * Set an exit point when SUJ check failed
2721 retval = setjmp(jmpbuf);
2723 pwarn("UNEXPECTED SU+J INCONSISTENCY\n");
2724 TAILQ_FOREACH_SAFE(seg, &allsegs, ss_next, segn) {
2725 TAILQ_REMOVE(&allsegs, seg, ss_next);
2729 if (reply("FALLBACK TO FULL FSCK") == 0) {
2737 * Find the journal inode.
2739 ip = ino_read(UFS_ROOTINO);
2741 ino_visit(ip, UFS_ROOTINO, suj_find, 0);
2743 printf("Journal inode removed. Use tunefs to re-create.\n");
2744 sblock.fs_flags &= ~FS_SUJ;
2745 sblock.fs_sujfree = 0;
2749 * Fetch the journal inode and verify it.
2751 jip = ino_read(sujino);
2752 printf("** SU+J Recovering %s\n", filesys);
2753 if (suj_verifyino(jip) != 0)
2755 if (!preen && !reply("USE JOURNAL"))
2758 * Build a list of journal blocks in jblocks before parsing the
2759 * available journal blocks in with suj_read().
2761 printf("** Reading %jd byte journal from inode %ju.\n",
2762 DIP(jip, di_size), (uintmax_t)sujino);
2763 suj_jblocks = jblocks_create();
2764 blocks = ino_visit(jip, sujino, suj_add_block, 0);
2765 if (blocks != numfrags(fs, DIP(jip, di_size))) {
2766 printf("Sparse journal inode %ju.\n", (uintmax_t)sujino);
2770 jblocks_destroy(suj_jblocks);
2772 if (preen || reply("RECOVER")) {
2773 printf("** Building recovery table.\n");
2777 printf("** Resolving unreferenced inode list.\n");
2779 printf("** Processing journal entries.\n");
2781 cg_apply(cg_check_blk);
2782 cg_apply(cg_adj_blk);
2783 cg_apply(cg_check_ino);
2785 if (preen == 0 && (jrecs > 0 || jbytes > 0) && reply("WRITE CHANGES") == 0)
2788 * To remain idempotent with partial truncations the free bitmaps
2789 * must be written followed by indirect blocks and lastly inode
2790 * blocks. This preserves access to the modified pointers until
2795 cg_apply(cg_write_inos);
2796 /* Write back superblock. */
2798 if (jrecs > 0 || jbytes > 0) {
2799 printf("** %jd journal records in %jd bytes for %.2f%% utilization\n",
2800 jrecs, jbytes, ((float)jrecs / (float)(jbytes / JREC_SIZE)) * 100);
2801 printf("** Freed %jd inodes (%jd dirs) %jd blocks, and %jd frags.\n",
2802 freeinos, freedir, freeblocks, freefrags);
2813 for (i = 0; i < SUJ_HASHSIZE; i++) {
2814 LIST_INIT(&cghash[i]);
2815 LIST_INIT(&dbhash[i]);
2819 TAILQ_INIT(&allsegs);