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 dest
->sb_versionnum
|= XFS_SB_VERSION_EXTFLGBIT
;
63 * these are all supposed to be zero or will get reset anyway
67 dest
->sb_fdblocks
= 0;
68 dest
->sb_frextents
= 0;
70 memset(source
->sb_fname
, 0, 12);
74 verify_sb_blocksize(xfs_sb_t
*sb
)
76 /* check to make sure blocksize is legal 2^N, 9 <= N <= 16 */
77 if (sb
->sb_blocksize
== 0)
78 return XR_BAD_BLOCKSIZE
;
79 if (sb
->sb_blocklog
< XFS_MIN_BLOCKSIZE_LOG
||
80 sb
->sb_blocklog
> XFS_MAX_BLOCKSIZE_LOG
)
81 return XR_BAD_BLOCKLOG
;
82 if (sb
->sb_blocksize
!= (1 << sb
->sb_blocklog
))
83 return XR_BAD_BLOCKLOG
;
89 * find a secondary superblock, copy it into the sb buffer.
90 * start is the point to begin reading BSIZE bytes.
91 * skip contains a byte-count of how far to advance for next read.
109 sb
= (xfs_sb_t
*)memalign(libxfs_device_alignment(), BSIZE
);
112 _("error finding secondary superblock -- failed to memalign buffer\n"));
116 memset(&bufsb
, 0, sizeof(xfs_sb_t
));
122 * skip first sector since we know that's bad
124 for (done
= 0, off
= start
; !done
; off
+= skip
) {
126 * read disk 1 MByte at a time.
128 if (lseek(x
.dfd
, off
, SEEK_SET
) != off
) {
132 if (!done
&& (bsize
= read(x
.dfd
, sb
, BSIZE
)) <= 0) {
139 * check the buffer 512 bytes at a time since
140 * we don't know how big the sectors really are.
142 for (i
= 0; !done
&& i
< bsize
; i
+= BBSIZE
) {
143 c_bufsb
= (char *)sb
+ i
;
144 libxfs_sb_from_disk(&bufsb
, (xfs_dsb_t
*)c_bufsb
);
146 if (verify_sb(c_bufsb
, &bufsb
, 0) != XR_OK
)
149 do_warn(_("found candidate secondary superblock...\n"));
152 * found one. now verify it by looking
153 * for other secondaries.
155 memmove(rsb
, &bufsb
, sizeof(xfs_sb_t
));
156 rsb
->sb_inprogress
= 0;
159 if (verify_set_primary_sb(rsb
, 0, &dirty
) == XR_OK
) {
161 _("verified secondary superblock...\n"));
166 _("unable to verify superblock, continuing...\n"));
176 guess_default_geometry(
181 struct fs_topology ft
;
186 memset(&ft
, 0, sizeof(ft
));
187 get_topology(x
, &ft
, 1);
190 * get geometry from get_topology result.
191 * Use default block size (2^12)
194 multidisk
= ft
.dswidth
| ft
.dsunit
;
195 dblocks
= x
->dsize
>> (blocklog
- BBSHIFT
);
196 calc_default_ag_geometry(blocklog
, dblocks
, multidisk
,
203 find_secondary_sb(xfs_sb_t
*rsb
)
212 * Attempt to find secondary sb with a coarse approach,
213 * first trying agblocks and blocksize read from sb, providing
216 do_warn(_("\nattempting to find secondary superblock...\n"));
218 if (verify_sb_blocksize(rsb
) == 0) {
219 skip
= (uint64_t)rsb
->sb_agblocks
* rsb
->sb_blocksize
;
220 if (skip
>= XFS_AG_MIN_BYTES
&& skip
<= XFS_AG_MAX_BYTES
)
221 retval
= __find_secondary_sb(rsb
, skip
, skip
);
224 /* If that failed, retry coarse approach, using default geometry */
226 blocklog
= guess_default_geometry(&agsize
, &agcount
, &x
);
227 skip
= agsize
<< blocklog
;
228 retval
= __find_secondary_sb(rsb
, skip
, skip
);
231 /* If that failed, fall back to the brute force method */
233 retval
= __find_secondary_sb(rsb
, XFS_AG_MIN_BYTES
, BSIZE
);
239 * Calculate what the inode alignment field ought to be based on internal
240 * superblock info and determine if it is valid.
242 * For standard v5 superblocks, the inode alignment must either match
243 * XFS_INODE_BIG_CLUSTER_SIZE or a multiple based on the inode size. For v5
244 * superblocks with sparse inode chunks enabled, inode alignment must match the
247 * Return true if the alignment is valid, false otherwise.
250 sb_validate_ino_align(struct xfs_sb
*sb
)
254 if (!xfs_sb_version_hasalign(sb
))
257 /* standard cluster size alignment is always valid */
258 align
= XFS_INODE_BIG_CLUSTER_SIZE
>> sb
->sb_blocklog
;
259 if (align
== sb
->sb_inoalignmt
)
262 /* alignment scaled by inode size is v5 only for now */
263 if (!xfs_sb_version_hascrc(sb
))
266 align
= (XFS_INODE_BIG_CLUSTER_SIZE
*
267 sb
->sb_inodesize
/ XFS_DINODE_MIN_SIZE
) >> sb
->sb_blocklog
;
268 if (align
== sb
->sb_inoalignmt
)
272 * Sparse inodes requires inoalignmt to match full inode chunk size and
273 * spino_align to match the scaled alignment (as calculated above).
275 if (xfs_sb_version_hassparseinodes(sb
)) {
276 if (align
!= sb
->sb_spino_align
)
279 align
= (sb
->sb_inodesize
* XFS_INODES_PER_CHUNK
)
281 if (align
== sb
->sb_inoalignmt
)
289 * Validate the given log space. Derived from xfs_log_mount, though we
290 * can't validate the minimum log size until later. We only do this
291 * validation on V5 filesystems because the kernel doesn't reject malformed
292 * log geometry on older revision filesystems.
294 * Returns false if the log is garbage.
300 if (xfs_sb_version_hascrc(sb
) &&
301 (sb
->sb_logblocks
== 0 ||
302 sb
->sb_logblocks
> XFS_MAX_LOG_BLOCKS
||
303 ((unsigned long long)sb
->sb_logblocks
<< sb
->sb_blocklog
) >
307 if (sb
->sb_logsunit
> 1 && sb
->sb_logsunit
% sb
->sb_blocksize
)
314 * verify a superblock -- does not verify root inode #
315 * can only check that geometry info is internally
316 * consistent. because of growfs, that's no guarantee
317 * of correctness (e.g. geometry may have changed)
319 * fields verified or consistency checked:
327 * sb_blocksize (as a group)
330 * geometry info - sb_dblocks (as a group)
335 * inode info - sb_inodesize (x-checked with geo info)
351 * ALL real-time fields
352 * final 4 summary counters
356 verify_sb(char *sb_buf
, xfs_sb_t
*sb
, int is_primary_sb
)
362 /* check magic number and version number */
364 if (sb
->sb_magicnum
!= XFS_SB_MAGIC
)
365 return(XR_BAD_MAGIC
);
367 if (!xfs_sb_good_version(sb
))
368 return(XR_BAD_VERSION
);
370 /* does sb think mkfs really finished ? */
372 if (is_primary_sb
&& sb
->sb_inprogress
== 1)
373 return(XR_BAD_INPROGRESS
);
376 * before going *any further*, validate the sector size and if the
377 * version says we should have CRCs enabled, validate that.
380 /* check to make sure sectorsize is legal 2^N, 9 <= N <= 15 */
381 if (sb
->sb_sectsize
== 0)
382 return(XR_BAD_SECT_SIZE_DATA
);
385 for (i
= 0; bsize
< sb
->sb_sectsize
&&
386 i
< sizeof(sb
->sb_sectsize
) * NBBY
; i
++) {
390 if (i
< XFS_MIN_SECTORSIZE_LOG
|| i
> XFS_MAX_SECTORSIZE_LOG
)
391 return(XR_BAD_SECT_SIZE_DATA
);
393 /* check sb sectorsize field against sb sectlog field */
394 if (i
!= sb
->sb_sectlog
)
395 return(XR_BAD_SECT_SIZE_DATA
);
397 /* sector size in range - CRC check time */
398 if (xfs_sb_version_hascrc(sb
) &&
399 !libxfs_verify_cksum(sb_buf
, sb
->sb_sectsize
, XFS_SB_CRC_OFF
))
402 /* check to ensure blocksize and blocklog are legal */
403 ret
= verify_sb_blocksize(sb
);
407 /* sanity check ag count, size fields against data size field */
409 if (sb
->sb_dblocks
== 0 ||
410 sb
->sb_dblocks
> XFS_MAX_DBLOCKS(sb
) ||
411 sb
->sb_dblocks
< XFS_MIN_DBLOCKS(sb
))
412 return(XR_BAD_FS_SIZE_DATA
);
414 if (sb
->sb_agblklog
!= (uint8_t)log2_roundup(sb
->sb_agblocks
))
415 return(XR_BAD_FS_SIZE_DATA
);
417 if (sb
->sb_inodesize
< XFS_DINODE_MIN_SIZE
||
418 sb
->sb_inodesize
> XFS_DINODE_MAX_SIZE
||
419 sb
->sb_inodelog
< XFS_DINODE_MIN_LOG
||
420 sb
->sb_inodelog
> XFS_DINODE_MAX_LOG
||
421 sb
->sb_inodesize
!= (1 << sb
->sb_inodelog
) ||
422 sb
->sb_logsunit
> XLOG_MAX_RECORD_BSIZE
||
423 sb
->sb_inopblock
!= howmany(sb
->sb_blocksize
, sb
->sb_inodesize
) ||
424 (sb
->sb_blocklog
- sb
->sb_inodelog
!= sb
->sb_inopblog
))
425 return XR_BAD_INO_SIZE_DATA
;
427 if (!verify_sb_loginfo(sb
))
428 return XR_BAD_LOG_GEOMETRY
;
430 if (xfs_sb_version_hassector(sb
)) {
432 /* check to make sure log sector is legal 2^N, 9 <= N <= 15 */
434 if (sb
->sb_logsectsize
== 0)
435 return(XR_BAD_SECT_SIZE_DATA
);
439 for (i
= 0; bsize
< sb
->sb_logsectsize
&&
440 i
< sizeof(sb
->sb_logsectsize
) * NBBY
; i
++) {
444 if (i
< XFS_MIN_SECTORSIZE_LOG
|| i
> XFS_MAX_SECTORSIZE_LOG
)
445 return(XR_BAD_SECT_SIZE_DATA
);
447 /* check sb log sectorsize field against sb log sectlog field */
449 if (i
!= sb
->sb_logsectlog
)
450 return(XR_BAD_SECT_SIZE_DATA
);
454 * real-time extent size is always set
456 if (sb
->sb_rextsize
* sb
->sb_blocksize
> XFS_MAX_RTEXTSIZE
)
457 return(XR_BAD_RT_GEO_DATA
);
459 if (sb
->sb_rextsize
* sb
->sb_blocksize
< XFS_MIN_RTEXTSIZE
)
460 return(XR_BAD_RT_GEO_DATA
);
462 if (sb
->sb_rblocks
== 0) {
463 if (sb
->sb_rextents
!= 0)
464 return(XR_BAD_RT_GEO_DATA
);
466 if (sb
->sb_rbmblocks
!= 0)
467 return(XR_BAD_RT_GEO_DATA
);
469 if (sb
->sb_rextslog
!= 0)
470 return(XR_BAD_RT_GEO_DATA
);
472 if (sb
->sb_frextents
!= 0)
473 return(XR_BAD_RT_GEO_DATA
);
476 * if we have a real-time partition, sanity-check geometry
478 if (sb
->sb_rblocks
/ sb
->sb_rextsize
!= sb
->sb_rextents
)
479 return(XR_BAD_RT_GEO_DATA
);
481 if (sb
->sb_rextslog
!=
482 libxfs_highbit32((unsigned int)sb
->sb_rextents
))
483 return(XR_BAD_RT_GEO_DATA
);
485 if (sb
->sb_rbmblocks
!= (xfs_extlen_t
) howmany(sb
->sb_rextents
,
486 NBBY
* sb
->sb_blocksize
))
487 return(XR_BAD_RT_GEO_DATA
);
491 * verify correctness of inode alignment if it's there
493 if (!sb_validate_ino_align(sb
))
494 return(XR_BAD_INO_ALIGN
);
497 * verify max. % of inodes (sb_imax_pct)
499 if (sb
->sb_imax_pct
> 100)
500 return(XR_BAD_INO_MAX_PCT
);
503 * verify stripe alignment fields if present
505 if (xfs_sb_version_hasdalign(sb
)) {
506 if ((!sb
->sb_unit
&& sb
->sb_width
) ||
507 (sb
->sb_unit
&& sb
->sb_agblocks
% sb
->sb_unit
))
508 return(XR_BAD_SB_UNIT
);
509 if ((sb
->sb_unit
&& !sb
->sb_width
) ||
510 (sb
->sb_width
&& sb
->sb_unit
&& sb
->sb_width
% sb
->sb_unit
))
511 return(XR_BAD_SB_WIDTH
);
512 } else if (sb
->sb_unit
|| sb
->sb_width
)
513 return XR_BAD_SB_WIDTH
;
515 /* Directory block log */
516 if (sb
->sb_blocklog
+ sb
->sb_dirblklog
> XFS_MAX_BLOCKSIZE_LOG
)
517 return XR_BAD_DIR_SIZE_DATA
;
523 write_primary_sb(xfs_sb_t
*sbp
, int size
)
530 buf
= memalign(libxfs_device_alignment(), size
);
532 do_error(_("failed to memalign superblock buffer\n"));
535 memset(buf
, 0, size
);
537 if (lseek(x
.dfd
, 0LL, SEEK_SET
) != 0LL) {
539 do_error(_("couldn't seek to offset 0 in filesystem\n"));
542 libxfs_sb_to_disk(buf
, sbp
);
544 if (xfs_sb_version_hascrc(sbp
))
545 xfs_update_cksum((char *)buf
, size
, XFS_SB_CRC_OFF
);
547 if (write(x
.dfd
, buf
, size
) != size
) {
549 do_error(_("primary superblock write failed!\n"));
556 * get a possible superblock -- checks for internal consistency
559 get_sb(xfs_sb_t
*sbp
, xfs_off_t off
, int size
, xfs_agnumber_t agno
)
564 buf
= memalign(libxfs_device_alignment(), size
);
567 _("error reading superblock %u -- failed to memalign buffer\n"),
571 memset(buf
, 0, size
);
572 memset(sbp
, 0, sizeof(*sbp
));
574 /* try and read it first */
576 if (lseek(x
.dfd
, off
, SEEK_SET
) != off
) {
578 _("error reading superblock %u -- seek to offset %" PRId64
" failed\n"),
584 if ((rval
= read(x
.dfd
, buf
, size
)) != size
) {
587 _("superblock read failed, offset %" PRId64
", size %d, ag %u, rval %d\n"),
588 off
, size
, agno
, rval
);
589 do_error("%s\n", strerror(error
));
591 libxfs_sb_from_disk(sbp
, buf
);
593 rval
= verify_sb((char *)buf
, sbp
, agno
== 0);
598 /* returns element on list with highest reference count */
599 static fs_geo_list_t
*
600 get_best_geo(fs_geo_list_t
*list
)
603 fs_geo_list_t
*current
, *rval
= NULL
;
607 while (current
!= NULL
) {
608 if (current
->refs
> cnt
) {
612 current
= current
->next
;
618 /* adds geometry info to linked list. returns (sometimes new) head of list */
619 static fs_geo_list_t
*
620 add_geo(fs_geo_list_t
*list
, fs_geometry_t
*geo_p
, int index
)
622 fs_geo_list_t
*current
= list
;
624 while (current
!= NULL
) {
625 if (memcmp(geo_p
, ¤t
->geo
, sizeof(fs_geometry_t
)) == 0) {
630 current
= current
->next
;
633 if ((current
= malloc(sizeof(fs_geo_list_t
))) == NULL
) {
634 do_error(_("couldn't malloc geometry structure\n"));
638 current
->geo
= *geo_p
;
640 current
->next
= list
;
641 current
->index
= index
;
647 free_geo(fs_geo_list_t
*list
)
650 fs_geo_list_t
*current
;
652 for (current
= list
; current
!= NULL
; current
= next
) {
653 next
= current
->next
;
659 get_sb_geometry(fs_geometry_t
*geo
, xfs_sb_t
*sbp
)
661 memset(geo
, 0, sizeof(fs_geometry_t
));
664 * blindly set fields that we know are always good
666 geo
->sb_blocksize
= sbp
->sb_blocksize
;
667 geo
->sb_dblocks
= sbp
->sb_dblocks
;
668 geo
->sb_rblocks
= sbp
->sb_rblocks
;
669 geo
->sb_rextents
= sbp
->sb_rextents
;
670 geo
->sb_logstart
= sbp
->sb_logstart
;
671 geo
->sb_rextsize
= sbp
->sb_rextsize
;
672 geo
->sb_agblocks
= sbp
->sb_agblocks
;
673 geo
->sb_agcount
= sbp
->sb_agcount
;
674 geo
->sb_rbmblocks
= sbp
->sb_rbmblocks
;
675 geo
->sb_logblocks
= sbp
->sb_logblocks
;
676 geo
->sb_sectsize
= sbp
->sb_sectsize
;
677 geo
->sb_inodesize
= sbp
->sb_inodesize
;
679 if (xfs_sb_version_hasalign(sbp
))
680 geo
->sb_ialignbit
= 1;
682 if (xfs_sb_version_hasdalign(sbp
))
683 geo
->sb_salignbit
= 1;
685 geo
->sb_extflgbit
= 1;
686 geo
->sb_fully_zeroed
= 1;
690 * the way to verify that a primary sb is consistent with the
691 * filesystem is find the secondaries given the info in the
692 * primary and compare the geometries in the secondaries against
693 * the geometry indicated by the primary.
695 * returns 0 if ok, else error code (XR_EOF, XR_INSUFF_SEC_SB, etc).
698 verify_set_primary_sb(xfs_sb_t
*rsb
,
706 fs_geo_list_t
*current
;
714 * We haven't been able to validate the sector size yet properly
715 * (e.g. in the case of repairing an image in a file), so we need to
716 * take into account sector mismatches and so use the maximum possible
717 * sector size rather than the sector size in @rsb.
719 size
= NUM_AGH_SECTS
* (1 << (XFS_MAX_SECTORSIZE_LOG
));
723 num_sbs
= rsb
->sb_agcount
;
725 sb
= (xfs_sb_t
*) alloc_ag_buf(size
);
728 * put the primary sb geometry info onto the geometry list
730 get_sb_geometry(&geo
, rsb
);
731 list
= add_geo(list
, &geo
, sb_index
);
734 * scan the secondaries and check them off as we get them so we only
735 * process each one once
737 for (agno
= 1; agno
< rsb
->sb_agcount
; agno
++) {
738 off
= (xfs_off_t
)agno
* rsb
->sb_agblocks
<< rsb
->sb_blocklog
;
740 retval
= get_sb(sb
, off
, size
, agno
);
741 if (retval
== XR_EOF
)
744 if (retval
== XR_OK
) {
746 * save away geometry info. don't bother checking the
747 * sb against the agi/agf as the odds of the sb being
748 * corrupted in a way that it is internally consistent
749 * but not consistent with the rest of the filesystem is
752 get_sb_geometry(&geo
, sb
);
753 list
= add_geo(list
, &geo
, agno
);
759 * see if we have enough superblocks to bother with
762 if (num_ok
< num_sbs
/ 2) {
763 retval
= XR_INSUFF_SEC_SB
;
767 current
= get_best_geo(list
);
770 * check that enough sbs agree that we're willing to
771 * go with this geometry. if not, print out the
772 * geometry and a message about the force option.
777 * If we only have two allocation groups, and the superblock
778 * in the second allocation group differs from the primary
779 * superblock we can't verify the geometry information.
780 * Warn the user about this situation and get out unless
781 * explicitly overridden.
783 if (current
->refs
!= 2) {
786 _("Only two AGs detected and they do not match - "
787 "cannot validate filesystem geometry.\n"
788 "Use the -o force_geometry option to proceed.\n"));
795 * If we only have a single allocation group there is no
796 * secondary superblock that we can use to verify the geometry
797 * information. Warn the user about this situation and get
798 * out unless explicitly overridden.
802 _("Only one AG detected - "
803 "cannot validate filesystem geometry.\n"
804 "Use the -o force_geometry option to proceed.\n"));
810 * at least half of the probed superblocks have
811 * to agree. if they don't, this fs is probably
812 * too far gone anyway considering the fact that
813 * XFS normally doesn't alter the secondary superblocks.
815 if (current
->refs
< num_sbs
/ 2) {
817 _("Not enough matching superblocks - cannot proceed.\n"));
823 * set the geometry into primary superblock if necessary.
826 if (current
->index
!= sb_index
) {
828 off
= (xfs_off_t
)current
->index
* current
->geo
.sb_agblocks
829 * current
->geo
.sb_blocksize
;
830 if (get_sb(sb
, off
, current
->geo
.sb_sectsize
,
831 current
->index
) != XR_OK
)
832 do_error(_("could not read superblock\n"));
837 * turn off inprogress bit since this is the primary.
838 * also save away values that we need to ensure are
839 * consistent in the other secondaries.
841 rsb
->sb_inprogress
= 0;
842 sb_inoalignmt
= sb
->sb_inoalignmt
;
843 sb_unit
= sb
->sb_unit
;
844 sb_width
= sb
->sb_width
;