FreeBSD
/
src
mirror of https://git.FreeBSD.org/src.git
1
0
Fork 0
Code Releases Activity
Browse Source

When a superblock integrity check fails, report the cause of the failure. 

No functional change intended.

MFC after:   1 month (with 076002f24d)
Differential Revision: https://reviews.freebsd.org/D35219
main
Kirk McKusick 2 weeks ago
parent
746974c061
commit
50dc4c7df4
1 changed files with 111 additions and 91 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 202
      sys/ufs/ffs/ffs_subr.c

202
sys/ufs/ffs/ffs_subr.c
Unescape View File

@ -309,6 +309,22 @@ readsuper(void *devfd, struct fs **fsp, off_t sblockloc, int isaltsblk,
* Verify the filesystem values.
*/
#define ILOG2(num) (fls(num) - 1)
#define CHK(lhs, op, rhs, fmt) \
if (lhs op rhs) { \
printf("UFS%d superblock failed: %s (" #fmt ") %s %s (" \
#fmt ")\n", fs->fs_magic == FS_UFS1_MAGIC ? 1 : 2, \
#lhs, (intmax_t)lhs, #op, #rhs, (intmax_t)rhs); \
return (ENOENT); \
}
#define CHK2(lhs1, op1, rhs1, lhs2, op2, rhs2, fmt) \
if (lhs1 op1 rhs1 && lhs2 op2 rhs2) { \
printf("UFS%d superblock failed: %s (" #fmt ") %s %s (" \
#fmt ") && %s (" #fmt ") %s %s (" #fmt ")\n", \
fs->fs_magic == FS_UFS1_MAGIC ? 1 : 2, #lhs1, \
(intmax_t)lhs1, #op1, #rhs1, (intmax_t)rhs1, #lhs2, \
(intmax_t)lhs2, #op2, #rhs2, (intmax_t)rhs2); \
return (ENOENT); \
}
static int
validate_sblock(struct fs *fs, int isaltsblk)
@ -318,91 +334,95 @@ validate_sblock(struct fs *fs, int isaltsblk)
sectorsize = dbtob(1);
if (fs->fs_magic == FS_UFS2_MAGIC) {
if ((!isaltsblk && (fs->fs_sblockloc != SBLOCK_UFS2 ||
!(fs->fs_sblockactualloc == 0 ||
fs->fs_sblockactualloc == SBLOCK_UFS2))) ||
fs->fs_maxsymlinklen != ((UFS_NDADDR + UFS_NIADDR) *
sizeof(ufs2_daddr_t)) ||
fs->fs_nindir != fs->fs_bsize / sizeof(ufs2_daddr_t) ||
fs->fs_inopb != fs->fs_bsize / sizeof(struct ufs2_dinode))
return (ENOENT);
if (!isaltsblk) {
CHK(fs->fs_sblockloc, !=, SBLOCK_UFS2, %#jx);
CHK2(fs->fs_sblockactualloc, !=, SBLOCK_UFS2,
fs->fs_sblockactualloc, !=, 0, %jd);
}
CHK(fs->fs_maxsymlinklen, !=, ((UFS_NDADDR + UFS_NIADDR) *
sizeof(ufs2_daddr_t)), %jd);
CHK(fs->fs_nindir, !=, fs->fs_bsize / sizeof(ufs2_daddr_t),
%jd);
CHK(fs->fs_inopb, !=, fs->fs_bsize / sizeof(struct ufs2_dinode),
%jd);
} else if (fs->fs_magic == FS_UFS1_MAGIC) {
if ((!isaltsblk && (fs->fs_sblockloc > SBLOCK_UFS1 ||
!(fs->fs_sblockactualloc == SBLOCK_UFS1 ||
fs->fs_sblockactualloc == 0))) ||
fs->fs_nindir != fs->fs_bsize / sizeof(ufs1_daddr_t) ||
fs->fs_inopb != fs->fs_bsize / sizeof(struct ufs1_dinode) ||
fs->fs_maxsymlinklen != ((UFS_NDADDR + UFS_NIADDR) *
sizeof(ufs1_daddr_t)) ||
fs->fs_old_inodefmt != FS_44INODEFMT ||
fs->fs_old_cgoffset != 0 ||
fs->fs_old_cgmask != 0xffffffff ||
fs->fs_old_size != fs->fs_size ||
fs->fs_old_rotdelay != 0 ||
fs->fs_old_rps != 60 ||
fs->fs_old_nspf != fs->fs_fsize / sectorsize ||
fs->fs_old_cpg != 1 ||
fs->fs_old_interleave != 1 ||
fs->fs_old_trackskew != 0 ||
fs->fs_old_cpc != 0 ||
fs->fs_old_postblformat != 1 ||
fs->fs_old_nrpos != 1 ||
fs->fs_old_spc != fs->fs_fpg * fs->fs_old_nspf ||
fs->fs_old_nsect != fs->fs_old_spc ||
fs->fs_old_npsect != fs->fs_old_spc ||
fs->fs_old_dsize != fs->fs_dsize ||
fs->fs_old_ncyl != fs->fs_ncg)
return (ENOENT);
if (!isaltsblk) {
CHK(fs->fs_sblockloc, >, SBLOCK_UFS1, %#jx);
CHK2(fs->fs_sblockactualloc, !=, SBLOCK_UFS1,
fs->fs_sblockactualloc, !=, 0, %jd);
}
CHK(fs->fs_nindir, !=, fs->fs_bsize / sizeof(ufs1_daddr_t),
%jd);
CHK(fs->fs_inopb, !=, fs->fs_bsize / sizeof(struct ufs1_dinode),
%jd);
CHK(fs->fs_maxsymlinklen, !=, ((UFS_NDADDR + UFS_NIADDR) *
sizeof(ufs1_daddr_t)), %jd);
CHK(fs->fs_old_inodefmt, !=, FS_44INODEFMT, %jd);
CHK(fs->fs_old_cgoffset, !=, 0, %jd);
CHK(fs->fs_old_cgmask, !=, 0xffffffff, %#jx);
CHK(fs->fs_old_rotdelay, !=, 0, %jd);
CHK(fs->fs_old_rps, !=, 60, %jd);
CHK(fs->fs_old_nspf, !=, fs->fs_fsize / sectorsize, %jd);
CHK(fs->fs_old_cpg, !=, 1, %jd);
CHK(fs->fs_old_interleave, !=, 1, %jd);
CHK(fs->fs_old_trackskew, !=, 0, %jd);
CHK(fs->fs_old_cpc, !=, 0, %jd);
CHK(fs->fs_old_postblformat, !=, 1, %jd);
CHK(fs->fs_old_nrpos, !=, 1, %jd);
CHK(fs->fs_old_spc, !=, fs->fs_fpg * fs->fs_old_nspf, %jd);
CHK(fs->fs_old_nsect, !=, fs->fs_old_spc, %jd);
CHK(fs->fs_old_npsect, !=, fs->fs_old_spc, %jd);
CHK(fs->fs_old_ncyl, !=, fs->fs_ncg, %jd);
} else {
/* Bad magic number, so assume not a superblock */
return (ENOENT);
}
if (fs->fs_bsize < MINBSIZE || fs->fs_bsize > MAXBSIZE ||
fs->fs_bsize < roundup(sizeof(struct fs), DEV_BSIZE) ||
fs->fs_sbsize > SBLOCKSIZE || fs->fs_sbsize < fs->fs_fsize ||
!powerof2(fs->fs_bsize))
return (ENOENT);
if (fs->fs_fsize < sectorsize || fs->fs_fsize > fs->fs_bsize ||
fs->fs_fsize * MAXFRAG < fs->fs_bsize || !powerof2(fs->fs_fsize))
return (ENOENT);
if (fs->fs_maxbsize < fs->fs_bsize || !powerof2(fs->fs_maxbsize) ||
fs->fs_maxbsize > FS_MAXCONTIG * fs->fs_bsize)
return (ENOENT);
if (fs->fs_bmask != ~(fs->fs_bsize - 1) ||
fs->fs_fmask != ~(fs->fs_fsize - 1) ||
fs->fs_qbmask != ~fs->fs_bmask ||
fs->fs_qfmask != ~fs->fs_fmask ||
fs->fs_bshift != ILOG2(fs->fs_bsize) ||
fs->fs_fshift != ILOG2(fs->fs_fsize) ||
fs->fs_frag != numfrags(fs, fs->fs_bsize) ||
fs->fs_fragshift != ILOG2(fs->fs_frag) ||
fs->fs_frag > MAXFRAG ||
fs->fs_fsbtodb != ILOG2(fs->fs_fsize / sectorsize))
return (ENOENT);
if (fs->fs_sblkno !=
roundup(howmany(fs->fs_sblockloc + SBLOCKSIZE, fs->fs_fsize),
fs->fs_frag) ||
fs->fs_cblkno != fs->fs_sblkno +
roundup(howmany(SBLOCKSIZE, fs->fs_fsize), fs->fs_frag) ||
fs->fs_iblkno != fs->fs_cblkno + fs->fs_frag ||
fs->fs_dblkno != fs->fs_iblkno + fs->fs_ipg / INOPF(fs) ||
fs->fs_cgsize > fs->fs_bsize)
return (ENOENT);
if (fs->fs_csaddr != cgdmin(fs, 0) ||
fs->fs_cssize !=
fragroundup(fs, fs->fs_ncg * sizeof(struct csum)) ||
fs->fs_dsize != fs->fs_size - fs->fs_sblkno -
CHK(fs->fs_bsize, <, MINBSIZE, %jd);
CHK(fs->fs_bsize, >, MAXBSIZE, %jd);
CHK(fs->fs_bsize, <, roundup(sizeof(struct fs), DEV_BSIZE), %jd);
CHK(fs->fs_sbsize, >, SBLOCKSIZE, %jd);
CHK(fs->fs_sbsize, <, fs->fs_fsize, %jd);
CHK(powerof2(fs->fs_bsize), ==, 0, %jd);
CHK(fs->fs_fsize, <, sectorsize, %jd);
CHK(fs->fs_fsize, >, fs->fs_bsize, %jd);
CHK(fs->fs_fsize * MAXFRAG, <, fs->fs_bsize, %jd);
CHK(powerof2(fs->fs_fsize), ==, 0, %jd);
CHK(fs->fs_maxbsize, <, fs->fs_bsize, %jd);
CHK(powerof2(fs->fs_maxbsize), ==, 0, %jd);
CHK(fs->fs_maxbsize, >, FS_MAXCONTIG * fs->fs_bsize, %jd);
CHK(fs->fs_bmask, !=, ~(fs->fs_bsize - 1), %#jx);
CHK(fs->fs_fmask, !=, ~(fs->fs_fsize - 1), %#jx);
CHK(fs->fs_qbmask, !=, ~fs->fs_bmask, %#jx);
CHK(fs->fs_qfmask, !=, ~fs->fs_fmask, %#jx);
CHK(fs->fs_bshift, !=, ILOG2(fs->fs_bsize), %jd);
CHK(fs->fs_fshift, !=, ILOG2(fs->fs_fsize), %jd);
CHK(fs->fs_frag, !=, numfrags(fs, fs->fs_bsize), %jd);
CHK(fs->fs_fragshift, !=, ILOG2(fs->fs_frag), %jd);
CHK(fs->fs_frag, >, MAXFRAG, %jd);
CHK(fs->fs_fsbtodb, !=, ILOG2(fs->fs_fsize / sectorsize), %jd);
CHK(fs->fs_sblkno, !=, roundup(
howmany(fs->fs_sblockloc + SBLOCKSIZE, fs->fs_fsize),
fs->fs_frag), %jd);
CHK(fs->fs_cblkno, !=, fs->fs_sblkno +
roundup(howmany(SBLOCKSIZE, fs->fs_fsize), fs->fs_frag), %jd);
CHK(fs->fs_iblkno, !=, fs->fs_cblkno + fs->fs_frag, %jd);
CHK(fs->fs_dblkno, !=, fs->fs_iblkno + fs->fs_ipg / INOPF(fs), %jd);
CHK(fs->fs_cgsize, >, fs->fs_bsize, %jd);
CHK(fs->fs_csaddr, !=, cgdmin(fs, 0), %jd);
CHK(fs->fs_cssize, !=,
fragroundup(fs, fs->fs_ncg * sizeof(struct csum)), %jd);
CHK(fs->fs_dsize, !=, fs->fs_size - fs->fs_sblkno -
fs->fs_ncg * (fs->fs_dblkno - fs->fs_sblkno) -
howmany(fs->fs_cssize, fs->fs_fsize) ||
fs->fs_metaspace < 0 || fs->fs_metaspace > fs->fs_fpg / 2 ||
fs->fs_minfree > 99)
return (ENOENT);
howmany(fs->fs_cssize, fs->fs_fsize), %jd);
CHK(fs->fs_metaspace, <, 0, %jd);
CHK(fs->fs_metaspace, >, fs->fs_fpg / 2, %jd);
CHK(fs->fs_minfree, >, 99, %jd%%);
maxfilesize = fs->fs_bsize * UFS_NDADDR - 1;
for (sizepb = fs->fs_bsize, i = 0; i < UFS_NIADDR; i++) {
sizepb *= NINDIR(fs);
maxfilesize += sizepb;
}
if (fs->fs_maxfilesize != maxfilesize)
return (ENOENT);
CHK(fs->fs_maxfilesize, !=, maxfilesize, %jd);
/*
* These values have a tight interaction with each other that
* makes it hard to tightly bound them. So we can only check
@ -416,14 +436,16 @@ validate_sblock(struct fs *fs, int isaltsblk)
* since newfs(8) strives to have at least four cylinder groups.
*/
minfpg = MIN(12289, fs->fs_size / 4);
if (fs->fs_ncg < 1 || fs->fs_ncg > (fs->fs_size / minfpg) + 1 ||
fs->fs_fpg < minfpg || fs->fs_fpg > fs->fs_size ||
fs->fs_ipg * fs->fs_ncg > (((int64_t)(1)) << 32) - INOPB(fs) ||
fs->fs_ipg > fs->fs_fpg || fs->fs_size < 8 * fs->fs_frag)
return (ENOENT);
if (fs->fs_size <= (fs->fs_ncg - 1) * fs->fs_fpg ||
fs->fs_size > fs->fs_ncg * fs->fs_fpg)
return (ENOENT);
CHK(fs->fs_ncg, <, 1, %jd);
CHK(fs->fs_ncg, >, (fs->fs_size / minfpg) + 1, %jd);
CHK(fs->fs_fpg, <, minfpg, %jd);
CHK(fs->fs_fpg, >, fs->fs_size, %jd);
CHK(fs->fs_ipg * fs->fs_ncg, >, (((int64_t)(1)) << 32) - INOPB(fs),
%jd);
CHK(fs->fs_ipg, >, fs->fs_fpg, %jd);
CHK(fs->fs_size, <, 8 * fs->fs_frag, %jd);
CHK(fs->fs_size, <=, (fs->fs_ncg - 1) * fs->fs_fpg, %jd);
CHK(fs->fs_size, >, fs->fs_ncg * fs->fs_fpg, %jd);
/*
* With file system clustering it is possible to allocate
* many contiguous blocks. The kernel variable maxphys defines
@ -443,14 +465,12 @@ validate_sblock(struct fs *fs, int isaltsblk)
* those (mostly 32-bit machines) can (very slowly) handle I/O
* requests that exceed maxphys.
*/
if (fs->fs_maxcontig < 1 ||
fs->fs_maxcontig > MAX(256, maxphys / fs->fs_bsize))
return (ENOENT);
if (fs->fs_maxcontig < 0 ||
(fs->fs_maxcontig == 0 && fs->fs_contigsumsize != 0) ||
(fs->fs_maxcontig > 1 &&
fs->fs_contigsumsize != MIN(fs->fs_maxcontig, FS_MAXCONTIG)))
return (ENOENT);
CHK(fs->fs_maxcontig, <, 1, %jd);
CHK(fs->fs_maxcontig, >, MAX(256, maxphys / fs->fs_bsize), %jd);
CHK(fs->fs_maxcontig, <, 0, %jd);
CHK2(fs->fs_maxcontig, ==, 0, fs->fs_contigsumsize, !=, 0, %jd);
CHK2(fs->fs_maxcontig, >, 1, fs->fs_contigsumsize, !=,
MIN(fs->fs_maxcontig, FS_MAXCONTIG), %jd);
return (0);
}

Write Preview
Loading…
Cancel
Save