1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
13 #include "err_protos.h"
14 #include "xfs_multidisk.h"
16 #define BSIZE (1024 * 1024)
19 * copy the fields of a superblock that are present in primary and
20 * secondaries -- preserve fields that are different in the primary.
23 copy_sb(xfs_sb_t
*source
, xfs_sb_t
*dest
)
33 rootino
= dest
->sb_rootino
;
34 rbmino
= dest
->sb_rbmino
;
35 rsumino
= dest
->sb_rsumino
;
36 uquotino
= dest
->sb_uquotino
;
37 gquotino
= dest
->sb_gquotino
;
38 pquotino
= dest
->sb_pquotino
;
40 versionnum
= dest
->sb_versionnum
;
44 dest
->sb_rootino
= rootino
;
45 dest
->sb_rbmino
= rbmino
;
46 dest
->sb_rsumino
= rsumino
;
47 dest
->sb_uquotino
= uquotino
;
48 dest
->sb_gquotino
= gquotino
;
49 dest
->sb_pquotino
= pquotino
;
51 dest
->sb_versionnum
= versionnum
;
54 * copy over version bits that are stamped into all
55 * secondaries and cannot be changed at run time in
56 * the primary superblock
58 if (xfs_sb_version_hasdalign(source
))
59 dest
->sb_versionnum
|= XFS_SB_VERSION_DALIGNBIT
;
60 if (xfs_sb_version_hasextflgbit(source
))
61 dest
->sb_versionnum
|= XFS_SB_VERSION_EXTFLGBIT
;
64 * these are all supposed to be zero or will get reset anyway
68 dest
->sb_fdblocks
= 0;
69 dest
->sb_frextents
= 0;
71 memset(source
->sb_fname
, 0, 12);
75 verify_sb_blocksize(xfs_sb_t
*sb
)
77 /* check to make sure blocksize is legal 2^N, 9 <= N <= 16 */
78 if (sb
->sb_blocksize
== 0)
79 return XR_BAD_BLOCKSIZE
;
80 if (sb
->sb_blocklog
< XFS_MIN_BLOCKSIZE_LOG
||
81 sb
->sb_blocklog
> XFS_MAX_BLOCKSIZE_LOG
)
82 return XR_BAD_BLOCKLOG
;
83 if (sb
->sb_blocksize
!= (1 << sb
->sb_blocklog
))
84 return XR_BAD_BLOCKLOG
;
90 * find a secondary superblock, copy it into the sb buffer.
91 * start is the point to begin reading BSIZE bytes.
92 * skip contains a byte-count of how far to advance for next read.
110 sb
= (xfs_sb_t
*)memalign(libxfs_device_alignment(), BSIZE
);
113 _("error finding secondary superblock -- failed to memalign buffer\n"));
117 memset(&bufsb
, 0, sizeof(xfs_sb_t
));
123 * skip first sector since we know that's bad
125 for (done
= 0, off
= start
; !done
; off
+= skip
) {
127 * read disk 1 MByte at a time.
129 if (lseek(x
.dfd
, off
, SEEK_SET
) != off
) {
133 if (!done
&& (bsize
= read(x
.dfd
, sb
, BSIZE
)) <= 0) {
140 * check the buffer 512 bytes at a time since
141 * we don't know how big the sectors really are.
143 for (i
= 0; !done
&& i
< bsize
; i
+= BBSIZE
) {
144 c_bufsb
= (char *)sb
+ i
;
145 libxfs_sb_from_disk(&bufsb
, (xfs_dsb_t
*)c_bufsb
);
147 if (verify_sb(c_bufsb
, &bufsb
, 0) != XR_OK
)
150 do_warn(_("found candidate secondary superblock...\n"));
153 * found one. now verify it by looking
154 * for other secondaries.
156 memmove(rsb
, &bufsb
, sizeof(xfs_sb_t
));
157 rsb
->sb_inprogress
= 0;
160 if (verify_set_primary_sb(rsb
, 0, &dirty
) == XR_OK
) {
162 _("verified secondary superblock...\n"));
167 _("unable to verify superblock, continuing...\n"));
177 guess_default_geometry(
182 struct fs_topology ft
;
187 memset(&ft
, 0, sizeof(ft
));
188 get_topology(x
, &ft
, 1);
191 * get geometry from get_topology result.
192 * Use default block size (2^12)
195 multidisk
= ft
.dswidth
| ft
.dsunit
;
196 dblocks
= x
->dsize
>> (blocklog
- BBSHIFT
);
197 calc_default_ag_geometry(blocklog
, dblocks
, multidisk
,
204 find_secondary_sb(xfs_sb_t
*rsb
)
213 * Attempt to find secondary sb with a coarse approach,
214 * first trying agblocks and blocksize read from sb, providing
217 do_warn(_("\nattempting to find secondary superblock...\n"));
219 if (verify_sb_blocksize(rsb
) == 0) {
220 skip
= (uint64_t)rsb
->sb_agblocks
* rsb
->sb_blocksize
;
221 if (skip
>= XFS_AG_MIN_BYTES
&& skip
<= XFS_AG_MAX_BYTES
)
222 retval
= __find_secondary_sb(rsb
, skip
, skip
);
225 /* If that failed, retry coarse approach, using default geometry */
227 blocklog
= guess_default_geometry(&agsize
, &agcount
, &x
);
228 skip
= agsize
<< blocklog
;
229 retval
= __find_secondary_sb(rsb
, skip
, skip
);
232 /* If that failed, fall back to the brute force method */
234 retval
= __find_secondary_sb(rsb
, XFS_AG_MIN_BYTES
, BSIZE
);
240 * Calculate what the inode alignment field ought to be based on internal
241 * superblock info and determine if it is valid.
243 * For standard v5 superblocks, the inode alignment must either match
244 * XFS_INODE_BIG_CLUSTER_SIZE or a multiple based on the inode size. For v5
245 * superblocks with sparse inode chunks enabled, inode alignment must match the
248 * Return true if the alignment is valid, false otherwise.
251 sb_validate_ino_align(struct xfs_sb
*sb
)
255 if (!xfs_sb_version_hasalign(sb
))
258 /* standard cluster size alignment is always valid */
259 align
= XFS_INODE_BIG_CLUSTER_SIZE
>> sb
->sb_blocklog
;
260 if (align
== sb
->sb_inoalignmt
)
263 /* alignment scaled by inode size is v5 only for now */
264 if (!xfs_sb_version_hascrc(sb
))
267 align
= (XFS_INODE_BIG_CLUSTER_SIZE
*
268 sb
->sb_inodesize
/ XFS_DINODE_MIN_SIZE
) >> sb
->sb_blocklog
;
269 if (align
== sb
->sb_inoalignmt
)
273 * Sparse inodes requires inoalignmt to match full inode chunk size and
274 * spino_align to match the scaled alignment (as calculated above).
276 if (xfs_sb_version_hassparseinodes(sb
)) {
277 if (align
!= sb
->sb_spino_align
)
280 align
= (sb
->sb_inodesize
* XFS_INODES_PER_CHUNK
)
282 if (align
== sb
->sb_inoalignmt
)
290 * Validate the given log space. Derived from xfs_log_mount, though we
291 * can't validate the minimum log size until later. We only do this
292 * validation on V5 filesystems because the kernel doesn't reject malformed
293 * log geometry on older revision filesystems.
295 * Returns false if the log is garbage.
301 if (xfs_sb_version_hascrc(sb
) &&
302 (sb
->sb_logblocks
== 0 ||
303 sb
->sb_logblocks
> XFS_MAX_LOG_BLOCKS
||
304 ((unsigned long long)sb
->sb_logblocks
<< sb
->sb_blocklog
) >
308 if (sb
->sb_logsunit
> 1 && sb
->sb_logsunit
% sb
->sb_blocksize
)
315 * verify a superblock -- does not verify root inode #
316 * can only check that geometry info is internally
317 * consistent. because of growfs, that's no guarantee
318 * of correctness (e.g. geometry may have changed)
320 * fields verified or consistency checked:
328 * sb_blocksize (as a group)
331 * geometry info - sb_dblocks (as a group)
336 * inode info - sb_inodesize (x-checked with geo info)
352 * ALL real-time fields
353 * final 4 summary counters
357 verify_sb(char *sb_buf
, xfs_sb_t
*sb
, int is_primary_sb
)
363 /* check magic number and version number */
365 if (sb
->sb_magicnum
!= XFS_SB_MAGIC
)
366 return(XR_BAD_MAGIC
);
368 if (!xfs_sb_good_version(sb
))
369 return(XR_BAD_VERSION
);
371 /* does sb think mkfs really finished ? */
373 if (is_primary_sb
&& sb
->sb_inprogress
== 1)
374 return(XR_BAD_INPROGRESS
);
377 * before going *any further*, validate the sector size and if the
378 * version says we should have CRCs enabled, validate that.
381 /* check to make sure sectorsize is legal 2^N, 9 <= N <= 15 */
382 if (sb
->sb_sectsize
== 0)
383 return(XR_BAD_SECT_SIZE_DATA
);
386 for (i
= 0; bsize
< sb
->sb_sectsize
&&
387 i
< sizeof(sb
->sb_sectsize
) * NBBY
; i
++) {
391 if (i
< XFS_MIN_SECTORSIZE_LOG
|| i
> XFS_MAX_SECTORSIZE_LOG
)
392 return(XR_BAD_SECT_SIZE_DATA
);
394 /* check sb sectorsize field against sb sectlog field */
395 if (i
!= sb
->sb_sectlog
)
396 return(XR_BAD_SECT_SIZE_DATA
);
398 /* sector size in range - CRC check time */
399 if (xfs_sb_version_hascrc(sb
) &&
400 !libxfs_verify_cksum(sb_buf
, sb
->sb_sectsize
, XFS_SB_CRC_OFF
))
403 /* check to ensure blocksize and blocklog are legal */
404 ret
= verify_sb_blocksize(sb
);
408 /* sanity check ag count, size fields against data size field */
410 if (sb
->sb_dblocks
== 0 ||
411 sb
->sb_dblocks
> XFS_MAX_DBLOCKS(sb
) ||
412 sb
->sb_dblocks
< XFS_MIN_DBLOCKS(sb
))
413 return(XR_BAD_FS_SIZE_DATA
);
415 if (sb
->sb_agblklog
!= (uint8_t)log2_roundup(sb
->sb_agblocks
))
416 return(XR_BAD_FS_SIZE_DATA
);
418 if (sb
->sb_inodesize
< XFS_DINODE_MIN_SIZE
||
419 sb
->sb_inodesize
> XFS_DINODE_MAX_SIZE
||
420 sb
->sb_inodelog
< XFS_DINODE_MIN_LOG
||
421 sb
->sb_inodelog
> XFS_DINODE_MAX_LOG
||
422 sb
->sb_inodesize
!= (1 << sb
->sb_inodelog
) ||
423 sb
->sb_logsunit
> XLOG_MAX_RECORD_BSIZE
||
424 sb
->sb_inopblock
!= howmany(sb
->sb_blocksize
, sb
->sb_inodesize
) ||
425 (sb
->sb_blocklog
- sb
->sb_inodelog
!= sb
->sb_inopblog
))
426 return XR_BAD_INO_SIZE_DATA
;
428 if (!verify_sb_loginfo(sb
))
429 return XR_BAD_LOG_GEOMETRY
;
431 if (xfs_sb_version_hassector(sb
)) {
433 /* check to make sure log sector is legal 2^N, 9 <= N <= 15 */
435 if (sb
->sb_logsectsize
== 0)
436 return(XR_BAD_SECT_SIZE_DATA
);
440 for (i
= 0; bsize
< sb
->sb_logsectsize
&&
441 i
< sizeof(sb
->sb_logsectsize
) * NBBY
; i
++) {
445 if (i
< XFS_MIN_SECTORSIZE_LOG
|| i
> XFS_MAX_SECTORSIZE_LOG
)
446 return(XR_BAD_SECT_SIZE_DATA
);
448 /* check sb log sectorsize field against sb log sectlog field */
450 if (i
!= sb
->sb_logsectlog
)
451 return(XR_BAD_SECT_SIZE_DATA
);
455 * real-time extent size is always set
457 if (sb
->sb_rextsize
* sb
->sb_blocksize
> XFS_MAX_RTEXTSIZE
)
458 return(XR_BAD_RT_GEO_DATA
);
460 if (sb
->sb_rextsize
* sb
->sb_blocksize
< XFS_MIN_RTEXTSIZE
)
461 return(XR_BAD_RT_GEO_DATA
);
463 if (sb
->sb_rblocks
== 0) {
464 if (sb
->sb_rextents
!= 0)
465 return(XR_BAD_RT_GEO_DATA
);
467 if (sb
->sb_rbmblocks
!= 0)
468 return(XR_BAD_RT_GEO_DATA
);
470 if (sb
->sb_rextslog
!= 0)
471 return(XR_BAD_RT_GEO_DATA
);
473 if (sb
->sb_frextents
!= 0)
474 return(XR_BAD_RT_GEO_DATA
);
477 * if we have a real-time partition, sanity-check geometry
479 if (sb
->sb_rblocks
/ sb
->sb_rextsize
!= sb
->sb_rextents
)
480 return(XR_BAD_RT_GEO_DATA
);
482 if (sb
->sb_rextslog
!=
483 libxfs_highbit32((unsigned int)sb
->sb_rextents
))
484 return(XR_BAD_RT_GEO_DATA
);
486 if (sb
->sb_rbmblocks
!= (xfs_extlen_t
) howmany(sb
->sb_rextents
,
487 NBBY
* sb
->sb_blocksize
))
488 return(XR_BAD_RT_GEO_DATA
);
492 * verify correctness of inode alignment if it's there
494 if (!sb_validate_ino_align(sb
))
495 return(XR_BAD_INO_ALIGN
);
498 * verify max. % of inodes (sb_imax_pct)
500 if (sb
->sb_imax_pct
> 100)
501 return(XR_BAD_INO_MAX_PCT
);
504 * verify stripe alignment fields if present
506 if (xfs_sb_version_hasdalign(sb
)) {
507 if ((!sb
->sb_unit
&& sb
->sb_width
) ||
508 (sb
->sb_unit
&& sb
->sb_agblocks
% sb
->sb_unit
))
509 return(XR_BAD_SB_UNIT
);
510 if ((sb
->sb_unit
&& !sb
->sb_width
) ||
511 (sb
->sb_width
&& sb
->sb_unit
&& sb
->sb_width
% sb
->sb_unit
))
512 return(XR_BAD_SB_WIDTH
);
513 } else if (sb
->sb_unit
|| sb
->sb_width
)
514 return XR_BAD_SB_WIDTH
;
516 /* Directory block log */
517 if (sb
->sb_blocklog
+ sb
->sb_dirblklog
> XFS_MAX_BLOCKSIZE_LOG
)
518 return XR_BAD_DIR_SIZE_DATA
;
524 write_primary_sb(xfs_sb_t
*sbp
, int size
)
531 buf
= memalign(libxfs_device_alignment(), size
);
533 do_error(_("failed to memalign superblock buffer\n"));
536 memset(buf
, 0, size
);
538 if (lseek(x
.dfd
, 0LL, SEEK_SET
) != 0LL) {
540 do_error(_("couldn't seek to offset 0 in filesystem\n"));
543 libxfs_sb_to_disk(buf
, sbp
);
545 if (xfs_sb_version_hascrc(sbp
))
546 xfs_update_cksum((char *)buf
, size
, XFS_SB_CRC_OFF
);
548 if (write(x
.dfd
, buf
, size
) != size
) {
550 do_error(_("primary superblock write failed!\n"));
557 * get a possible superblock -- checks for internal consistency
560 get_sb(xfs_sb_t
*sbp
, xfs_off_t off
, int size
, xfs_agnumber_t agno
)
565 buf
= memalign(libxfs_device_alignment(), size
);
568 _("error reading superblock %u -- failed to memalign buffer\n"),
572 memset(buf
, 0, size
);
573 memset(sbp
, 0, sizeof(*sbp
));
575 /* try and read it first */
577 if (lseek(x
.dfd
, off
, SEEK_SET
) != off
) {
579 _("error reading superblock %u -- seek to offset %" PRId64
" failed\n"),
585 if ((rval
= read(x
.dfd
, buf
, size
)) != size
) {
588 _("superblock read failed, offset %" PRId64
", size %d, ag %u, rval %d\n"),
589 off
, size
, agno
, rval
);
590 do_error("%s\n", strerror(error
));
592 libxfs_sb_from_disk(sbp
, buf
);
594 rval
= verify_sb((char *)buf
, sbp
, agno
== 0);
599 /* returns element on list with highest reference count */
600 static fs_geo_list_t
*
601 get_best_geo(fs_geo_list_t
*list
)
604 fs_geo_list_t
*current
, *rval
= NULL
;
608 while (current
!= NULL
) {
609 if (current
->refs
> cnt
) {
613 current
= current
->next
;
619 /* adds geometry info to linked list. returns (sometimes new) head of list */
620 static fs_geo_list_t
*
621 add_geo(fs_geo_list_t
*list
, fs_geometry_t
*geo_p
, int index
)
623 fs_geo_list_t
*current
= list
;
625 while (current
!= NULL
) {
626 if (memcmp(geo_p
, ¤t
->geo
, sizeof(fs_geometry_t
)) == 0) {
631 current
= current
->next
;
634 if ((current
= malloc(sizeof(fs_geo_list_t
))) == NULL
) {
635 do_error(_("couldn't malloc geometry structure\n"));
639 current
->geo
= *geo_p
;
641 current
->next
= list
;
642 current
->index
= index
;
648 free_geo(fs_geo_list_t
*list
)
651 fs_geo_list_t
*current
;
653 for (current
= list
; current
!= NULL
; current
= next
) {
654 next
= current
->next
;
660 get_sb_geometry(fs_geometry_t
*geo
, xfs_sb_t
*sbp
)
662 memset(geo
, 0, sizeof(fs_geometry_t
));
665 * blindly set fields that we know are always good
667 geo
->sb_blocksize
= sbp
->sb_blocksize
;
668 geo
->sb_dblocks
= sbp
->sb_dblocks
;
669 geo
->sb_rblocks
= sbp
->sb_rblocks
;
670 geo
->sb_rextents
= sbp
->sb_rextents
;
671 geo
->sb_logstart
= sbp
->sb_logstart
;
672 geo
->sb_rextsize
= sbp
->sb_rextsize
;
673 geo
->sb_agblocks
= sbp
->sb_agblocks
;
674 geo
->sb_agcount
= sbp
->sb_agcount
;
675 geo
->sb_rbmblocks
= sbp
->sb_rbmblocks
;
676 geo
->sb_logblocks
= sbp
->sb_logblocks
;
677 geo
->sb_sectsize
= sbp
->sb_sectsize
;
678 geo
->sb_inodesize
= sbp
->sb_inodesize
;
680 if (xfs_sb_version_hasalign(sbp
))
681 geo
->sb_ialignbit
= 1;
683 if (xfs_sb_version_hasdalign(sbp
))
684 geo
->sb_salignbit
= 1;
686 if (xfs_sb_version_hasextflgbit(sbp
))
687 geo
->sb_extflgbit
= 1;
689 geo
->sb_fully_zeroed
= 1;
693 * the way to verify that a primary sb is consistent with the
694 * filesystem is find the secondaries given the info in the
695 * primary and compare the geometries in the secondaries against
696 * the geometry indicated by the primary.
698 * returns 0 if ok, else error code (XR_EOF, XR_INSUFF_SEC_SB, etc).
701 verify_set_primary_sb(xfs_sb_t
*rsb
,
709 fs_geo_list_t
*current
;
717 * We haven't been able to validate the sector size yet properly
718 * (e.g. in the case of repairing an image in a file), so we need to
719 * take into account sector mismatches and so use the maximum possible
720 * sector size rather than the sector size in @rsb.
722 size
= NUM_AGH_SECTS
* (1 << (XFS_MAX_SECTORSIZE_LOG
));
726 num_sbs
= rsb
->sb_agcount
;
728 sb
= (xfs_sb_t
*) alloc_ag_buf(size
);
731 * put the primary sb geometry info onto the geometry list
733 get_sb_geometry(&geo
, rsb
);
734 list
= add_geo(list
, &geo
, sb_index
);
737 * scan the secondaries and check them off as we get them so we only
738 * process each one once
740 for (agno
= 1; agno
< rsb
->sb_agcount
; agno
++) {
741 off
= (xfs_off_t
)agno
* rsb
->sb_agblocks
<< rsb
->sb_blocklog
;
743 retval
= get_sb(sb
, off
, size
, agno
);
744 if (retval
== XR_EOF
)
747 if (retval
== XR_OK
) {
749 * save away geometry info. don't bother checking the
750 * sb against the agi/agf as the odds of the sb being
751 * corrupted in a way that it is internally consistent
752 * but not consistent with the rest of the filesystem is
755 get_sb_geometry(&geo
, sb
);
756 list
= add_geo(list
, &geo
, agno
);
762 * see if we have enough superblocks to bother with
765 if (num_ok
< num_sbs
/ 2) {
766 retval
= XR_INSUFF_SEC_SB
;
770 current
= get_best_geo(list
);
773 * check that enough sbs agree that we're willing to
774 * go with this geometry. if not, print out the
775 * geometry and a message about the force option.
780 * If we only have two allocation groups, and the superblock
781 * in the second allocation group differs from the primary
782 * superblock we can't verify the geometry information.
783 * Warn the user about this situation and get out unless
784 * explicitly overridden.
786 if (current
->refs
!= 2) {
789 _("Only two AGs detected and they do not match - "
790 "cannot validate filesystem geometry.\n"
791 "Use the -o force_geometry option to proceed.\n"));
798 * If we only have a single allocation group there is no
799 * secondary superblock that we can use to verify the geometry
800 * information. Warn the user about this situation and get
801 * out unless explicitly overridden.
805 _("Only one AG detected - "
806 "cannot validate filesystem geometry.\n"
807 "Use the -o force_geometry option to proceed.\n"));
813 * at least half of the probed superblocks have
814 * to agree. if they don't, this fs is probably
815 * too far gone anyway considering the fact that
816 * XFS normally doesn't alter the secondary superblocks.
818 if (current
->refs
< num_sbs
/ 2) {
820 _("Not enough matching superblocks - cannot proceed.\n"));
826 * set the geometry into primary superblock if necessary.
829 if (current
->index
!= sb_index
) {
831 off
= (xfs_off_t
)current
->index
* current
->geo
.sb_agblocks
832 * current
->geo
.sb_blocksize
;
833 if (get_sb(sb
, off
, current
->geo
.sb_sectsize
,
834 current
->index
) != XR_OK
)
835 do_error(_("could not read superblock\n"));
840 * turn off inprogress bit since this is the primary.
841 * also save away values that we need to ensure are
842 * consistent in the other secondaries.
844 rsb
->sb_inprogress
= 0;
845 sb_inoalignmt
= sb
->sb_inoalignmt
;
846 sb_unit
= sb
->sb_unit
;
847 sb_width
= sb
->sb_width
;