1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
6 #include "libfrog/util.h"
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
.data
.fd
, off
, SEEK_SET
) != off
)
131 if (!done
&& (bsize
= read(x
.data
.fd
, sb
, BSIZE
)) <= 0)
137 * check the buffer 512 bytes at a time since
138 * we don't know how big the sectors really are.
140 for (i
= 0; !done
&& i
< bsize
; i
+= BBSIZE
) {
141 c_bufsb
= (char *)sb
+ i
;
142 libxfs_sb_from_disk(&bufsb
, (struct xfs_dsb
*)c_bufsb
);
144 if (verify_sb(c_bufsb
, &bufsb
, 0) != XR_OK
)
147 do_warn(_("found candidate secondary superblock...\n"));
150 * found one. now verify it by looking
151 * for other secondaries.
153 memmove(rsb
, &bufsb
, sizeof(xfs_sb_t
));
154 rsb
->sb_inprogress
= 0;
157 if (verify_set_primary_sb(rsb
, 0, &dirty
) == XR_OK
) {
159 _("verified secondary superblock...\n"));
164 _("unable to verify superblock, continuing...\n"));
174 guess_default_geometry(
177 struct libxfs_init
*x
)
179 struct fs_topology ft
;
184 memset(&ft
, 0, sizeof(ft
));
185 get_topology(x
, &ft
, 1);
188 * get geometry from get_topology result.
189 * Use default block size (2^12)
192 multidisk
= ft
.dswidth
| ft
.dsunit
;
193 dblocks
= x
->data
.size
>> (blocklog
- BBSHIFT
);
194 calc_default_ag_geometry(blocklog
, dblocks
, multidisk
,
201 find_secondary_sb(xfs_sb_t
*rsb
)
210 * Attempt to find secondary sb with a coarse approach,
211 * first trying agblocks and blocksize read from sb, providing
214 do_warn(_("\nattempting to find secondary superblock...\n"));
216 if (verify_sb_blocksize(rsb
) == 0) {
217 skip
= (uint64_t)rsb
->sb_agblocks
* rsb
->sb_blocksize
;
218 if (skip
>= XFS_AG_MIN_BYTES
&& skip
<= XFS_AG_MAX_BYTES
)
219 retval
= __find_secondary_sb(rsb
, skip
, skip
);
222 /* If that failed, retry coarse approach, using default geometry */
224 blocklog
= guess_default_geometry(&agsize
, &agcount
, &x
);
225 skip
= agsize
<< blocklog
;
226 retval
= __find_secondary_sb(rsb
, skip
, skip
);
229 /* If that failed, fall back to the brute force method */
231 retval
= __find_secondary_sb(rsb
, XFS_AG_MIN_BYTES
, BSIZE
);
237 * Calculate what the inode alignment field ought to be based on internal
238 * superblock info and determine if it is valid.
240 * For standard v5 superblocks, the inode alignment must either match
241 * XFS_INODE_BIG_CLUSTER_SIZE or a multiple based on the inode size. For v5
242 * superblocks with sparse inode chunks enabled, inode alignment must match the
245 * Return true if the alignment is valid, false otherwise.
248 sb_validate_ino_align(struct xfs_sb
*sb
)
252 if (!xfs_sb_version_hasalign(sb
))
255 /* standard cluster size alignment is always valid */
256 align
= XFS_INODE_BIG_CLUSTER_SIZE
>> sb
->sb_blocklog
;
257 if (align
== sb
->sb_inoalignmt
)
260 /* alignment scaled by inode size is v5 only for now */
261 if (!xfs_sb_version_hascrc(sb
))
264 align
= (XFS_INODE_BIG_CLUSTER_SIZE
*
265 sb
->sb_inodesize
/ XFS_DINODE_MIN_SIZE
) >> sb
->sb_blocklog
;
266 if (align
== sb
->sb_inoalignmt
)
270 * Sparse inodes requires inoalignmt to match full inode chunk size and
271 * spino_align to match the scaled alignment (as calculated above).
273 if (xfs_sb_version_hassparseinodes(sb
)) {
274 if (align
!= sb
->sb_spino_align
)
277 align
= (sb
->sb_inodesize
* XFS_INODES_PER_CHUNK
)
279 if (align
== sb
->sb_inoalignmt
)
287 * Validate the given log space. Derived from xfs_log_mount, though we
288 * can't validate the minimum log size until later. We only do this
289 * validation on V5 filesystems because the kernel doesn't reject malformed
290 * log geometry on older revision filesystems.
292 * Returns false if the log is garbage.
298 if (xfs_sb_version_hascrc(sb
) &&
299 (sb
->sb_logblocks
== 0 ||
300 sb
->sb_logblocks
> XFS_MAX_LOG_BLOCKS
||
301 ((unsigned long long)sb
->sb_logblocks
<< sb
->sb_blocklog
) >
305 if (sb
->sb_logsunit
> 1 && sb
->sb_logsunit
% sb
->sb_blocksize
)
312 * verify a superblock -- does not verify root inode #
313 * can only check that geometry info is internally
314 * consistent. because of growfs, that's no guarantee
315 * of correctness (e.g. geometry may have changed)
317 * fields verified or consistency checked:
325 * sb_blocksize (as a group)
328 * geometry info - sb_dblocks (as a group)
333 * inode info - sb_inodesize (x-checked with geo info)
349 * ALL real-time fields
350 * final 4 summary counters
354 verify_sb(char *sb_buf
, xfs_sb_t
*sb
, int is_primary_sb
)
360 /* check magic number and version number */
362 if (sb
->sb_magicnum
!= XFS_SB_MAGIC
)
363 return(XR_BAD_MAGIC
);
365 if (!xfs_sb_good_version(sb
))
366 return(XR_BAD_VERSION
);
368 /* does sb think mkfs really finished ? */
369 if (is_primary_sb
&& sb
->sb_inprogress
)
370 return(XR_BAD_INPROGRESS
);
373 * before going *any further*, validate the sector size and if the
374 * version says we should have CRCs enabled, validate that.
377 /* check to make sure sectorsize is legal 2^N, 9 <= N <= 15 */
378 if (sb
->sb_sectsize
== 0)
379 return(XR_BAD_SECT_SIZE_DATA
);
382 for (i
= 0; bsize
< sb
->sb_sectsize
&&
383 i
< sizeof(sb
->sb_sectsize
) * NBBY
; i
++) {
387 if (i
< XFS_MIN_SECTORSIZE_LOG
|| i
> XFS_MAX_SECTORSIZE_LOG
)
388 return(XR_BAD_SECT_SIZE_DATA
);
390 /* check sb sectorsize field against sb sectlog field */
391 if (i
!= sb
->sb_sectlog
)
392 return(XR_BAD_SECT_SIZE_DATA
);
394 /* sector size in range - CRC check time */
395 if (xfs_sb_version_hascrc(sb
) &&
396 !libxfs_verify_cksum(sb_buf
, sb
->sb_sectsize
, XFS_SB_CRC_OFF
))
399 /* check to ensure blocksize and blocklog are legal */
400 ret
= verify_sb_blocksize(sb
);
404 /* sanity check ag count, size fields against data size field */
406 if (sb
->sb_dblocks
== 0 ||
407 sb
->sb_dblocks
> XFS_MAX_DBLOCKS(sb
) ||
408 sb
->sb_dblocks
< XFS_MIN_DBLOCKS(sb
))
409 return(XR_BAD_FS_SIZE_DATA
);
411 if (sb
->sb_agblklog
!= (uint8_t)log2_roundup(sb
->sb_agblocks
))
412 return(XR_BAD_FS_SIZE_DATA
);
414 if (sb
->sb_inodesize
< XFS_DINODE_MIN_SIZE
||
415 sb
->sb_inodesize
> XFS_DINODE_MAX_SIZE
||
416 sb
->sb_inodelog
< XFS_DINODE_MIN_LOG
||
417 sb
->sb_inodelog
> XFS_DINODE_MAX_LOG
||
418 sb
->sb_inodesize
!= (1 << sb
->sb_inodelog
) ||
419 sb
->sb_logsunit
> XLOG_MAX_RECORD_BSIZE
||
420 sb
->sb_inopblock
!= howmany(sb
->sb_blocksize
, sb
->sb_inodesize
) ||
421 (sb
->sb_blocklog
- sb
->sb_inodelog
!= sb
->sb_inopblog
))
422 return XR_BAD_INO_SIZE_DATA
;
424 if (!verify_sb_loginfo(sb
))
425 return XR_BAD_LOG_GEOMETRY
;
427 if (xfs_sb_version_hassector(sb
)) {
429 /* check to make sure log sector is legal 2^N, 9 <= N <= 15 */
431 if (sb
->sb_logsectsize
== 0)
432 return(XR_BAD_SECT_SIZE_DATA
);
436 for (i
= 0; bsize
< sb
->sb_logsectsize
&&
437 i
< sizeof(sb
->sb_logsectsize
) * NBBY
; i
++) {
441 if (i
< XFS_MIN_SECTORSIZE_LOG
|| i
> XFS_MAX_SECTORSIZE_LOG
)
442 return(XR_BAD_SECT_SIZE_DATA
);
444 /* check sb log sectorsize field against sb log sectlog field */
446 if (i
!= sb
->sb_logsectlog
)
447 return(XR_BAD_SECT_SIZE_DATA
);
451 * real-time extent size is always set
453 if (sb
->sb_rextsize
* sb
->sb_blocksize
> XFS_MAX_RTEXTSIZE
)
454 return(XR_BAD_RT_GEO_DATA
);
456 if (sb
->sb_rextsize
* sb
->sb_blocksize
< XFS_MIN_RTEXTSIZE
)
457 return(XR_BAD_RT_GEO_DATA
);
459 if (sb
->sb_rblocks
== 0) {
460 if (sb
->sb_rextents
!= 0)
461 return(XR_BAD_RT_GEO_DATA
);
463 if (sb
->sb_rbmblocks
!= 0)
464 return(XR_BAD_RT_GEO_DATA
);
466 if (sb
->sb_rextslog
!= 0)
467 return(XR_BAD_RT_GEO_DATA
);
469 if (sb
->sb_frextents
!= 0)
470 return(XR_BAD_RT_GEO_DATA
);
473 * if we have a real-time partition, sanity-check geometry
475 if (sb
->sb_rblocks
/ sb
->sb_rextsize
!= sb
->sb_rextents
)
476 return(XR_BAD_RT_GEO_DATA
);
478 if (sb
->sb_rextslog
!=
479 libxfs_highbit32((unsigned int)sb
->sb_rextents
))
480 return(XR_BAD_RT_GEO_DATA
);
482 if (sb
->sb_rbmblocks
!= (xfs_extlen_t
) howmany(sb
->sb_rextents
,
483 NBBY
* sb
->sb_blocksize
))
484 return(XR_BAD_RT_GEO_DATA
);
488 * verify correctness of inode alignment if it's there
490 if (!sb_validate_ino_align(sb
))
491 return(XR_BAD_INO_ALIGN
);
494 * verify max. % of inodes (sb_imax_pct)
496 if (sb
->sb_imax_pct
> 100)
497 return(XR_BAD_INO_MAX_PCT
);
500 * verify stripe alignment fields if present
502 if (xfs_sb_version_hasdalign(sb
)) {
503 if ((!sb
->sb_unit
&& sb
->sb_width
) ||
504 (sb
->sb_unit
&& sb
->sb_agblocks
% sb
->sb_unit
))
505 return(XR_BAD_SB_UNIT
);
506 if ((sb
->sb_unit
&& !sb
->sb_width
) ||
507 (sb
->sb_width
&& sb
->sb_unit
&& sb
->sb_width
% sb
->sb_unit
))
508 return(XR_BAD_SB_WIDTH
);
509 } else if (sb
->sb_unit
|| sb
->sb_width
)
510 return XR_BAD_SB_WIDTH
;
512 /* Directory block log */
513 if (sb
->sb_blocklog
+ sb
->sb_dirblklog
> XFS_MAX_BLOCKSIZE_LOG
)
514 return XR_BAD_DIR_SIZE_DATA
;
520 write_primary_sb(xfs_sb_t
*sbp
, int size
)
527 buf
= memalign(libxfs_device_alignment(), size
);
529 do_error(_("failed to memalign superblock buffer\n"));
532 memset(buf
, 0, size
);
534 if (lseek(x
.data
.fd
, 0LL, SEEK_SET
) != 0LL) {
536 do_error(_("couldn't seek to offset 0 in filesystem\n"));
539 libxfs_sb_to_disk(buf
, sbp
);
541 if (xfs_sb_version_hascrc(sbp
))
542 xfs_update_cksum((char *)buf
, size
, XFS_SB_CRC_OFF
);
544 if (write(x
.data
.fd
, buf
, size
) != size
) {
546 do_error(_("primary superblock write failed!\n"));
553 * get a possible superblock -- checks for internal consistency
556 get_sb(xfs_sb_t
*sbp
, xfs_off_t off
, int size
, xfs_agnumber_t agno
)
561 buf
= memalign(libxfs_device_alignment(), size
);
564 _("error reading superblock %u -- failed to memalign buffer\n"),
568 memset(buf
, 0, size
);
569 memset(sbp
, 0, sizeof(*sbp
));
571 /* try and read it first */
573 if (lseek(x
.data
.fd
, off
, SEEK_SET
) != off
) {
575 _("error reading superblock %u -- seek to offset %" PRId64
" failed\n"),
581 if ((rval
= read(x
.data
.fd
, buf
, size
)) != size
) {
584 _("superblock read failed, offset %" PRId64
", size %d, ag %u, rval %d\n"),
585 off
, size
, agno
, rval
);
586 do_error("%s\n", strerror(error
));
588 libxfs_sb_from_disk(sbp
, buf
);
590 rval
= verify_sb((char *)buf
, sbp
, agno
== 0);
595 /* returns element on list with highest reference count */
596 static fs_geo_list_t
*
597 get_best_geo(fs_geo_list_t
*list
)
600 fs_geo_list_t
*current
, *rval
= NULL
;
604 while (current
!= NULL
) {
605 if (current
->refs
> cnt
) {
609 current
= current
->next
;
615 /* adds geometry info to linked list. returns (sometimes new) head of list */
616 static fs_geo_list_t
*
617 add_geo(fs_geo_list_t
*list
, fs_geometry_t
*geo_p
, int index
)
619 fs_geo_list_t
*current
= list
;
621 while (current
!= NULL
) {
622 if (memcmp(geo_p
, ¤t
->geo
, sizeof(fs_geometry_t
)) == 0) {
627 current
= current
->next
;
630 if ((current
= malloc(sizeof(fs_geo_list_t
))) == NULL
) {
631 do_error(_("couldn't malloc geometry structure\n"));
635 current
->geo
= *geo_p
;
637 current
->next
= list
;
638 current
->index
= index
;
644 free_geo(fs_geo_list_t
*list
)
647 fs_geo_list_t
*current
;
649 for (current
= list
; current
!= NULL
; current
= next
) {
650 next
= current
->next
;
656 get_sb_geometry(fs_geometry_t
*geo
, xfs_sb_t
*sbp
)
658 memset(geo
, 0, sizeof(fs_geometry_t
));
661 * blindly set fields that we know are always good
663 geo
->sb_blocksize
= sbp
->sb_blocksize
;
664 geo
->sb_dblocks
= sbp
->sb_dblocks
;
665 geo
->sb_rblocks
= sbp
->sb_rblocks
;
666 geo
->sb_rextents
= sbp
->sb_rextents
;
667 geo
->sb_logstart
= sbp
->sb_logstart
;
668 geo
->sb_rextsize
= sbp
->sb_rextsize
;
669 geo
->sb_agblocks
= sbp
->sb_agblocks
;
670 geo
->sb_agcount
= sbp
->sb_agcount
;
671 geo
->sb_rbmblocks
= sbp
->sb_rbmblocks
;
672 geo
->sb_logblocks
= sbp
->sb_logblocks
;
673 geo
->sb_sectsize
= sbp
->sb_sectsize
;
674 geo
->sb_inodesize
= sbp
->sb_inodesize
;
676 if (xfs_sb_version_hasalign(sbp
))
677 geo
->sb_ialignbit
= 1;
679 if (xfs_sb_version_hasdalign(sbp
))
680 geo
->sb_salignbit
= 1;
682 geo
->sb_extflgbit
= 1;
683 geo
->sb_fully_zeroed
= 1;
687 * the way to verify that a primary sb is consistent with the
688 * filesystem is find the secondaries given the info in the
689 * primary and compare the geometries in the secondaries against
690 * the geometry indicated by the primary.
692 * returns 0 if ok, else error code (XR_EOF, XR_INSUFF_SEC_SB, etc).
695 verify_set_primary_sb(xfs_sb_t
*rsb
,
703 fs_geo_list_t
*current
;
711 * We haven't been able to validate the sector size yet properly
712 * (e.g. in the case of repairing an image in a file), so we need to
713 * take into account sector mismatches and so use the maximum possible
714 * sector size rather than the sector size in @rsb.
716 size
= NUM_AGH_SECTS
* (1 << (XFS_MAX_SECTORSIZE_LOG
));
720 num_sbs
= rsb
->sb_agcount
;
722 sb
= (xfs_sb_t
*) alloc_ag_buf(size
);
725 * put the primary sb geometry info onto the geometry list
727 get_sb_geometry(&geo
, rsb
);
728 list
= add_geo(list
, &geo
, sb_index
);
731 * scan the secondaries and check them off as we get them so we only
732 * process each one once
734 for (agno
= 1; agno
< rsb
->sb_agcount
; agno
++) {
735 off
= (xfs_off_t
)agno
* rsb
->sb_agblocks
<< rsb
->sb_blocklog
;
737 retval
= get_sb(sb
, off
, size
, agno
);
738 if (retval
== XR_EOF
)
741 if (retval
== XR_OK
) {
743 * save away geometry info. don't bother checking the
744 * sb against the agi/agf as the odds of the sb being
745 * corrupted in a way that it is internally consistent
746 * but not consistent with the rest of the filesystem is
749 get_sb_geometry(&geo
, sb
);
750 list
= add_geo(list
, &geo
, agno
);
756 * see if we have enough superblocks to bother with
759 if (num_ok
< num_sbs
/ 2) {
760 retval
= XR_INSUFF_SEC_SB
;
764 current
= get_best_geo(list
);
767 * check that enough sbs agree that we're willing to
768 * go with this geometry. if not, print out the
769 * geometry and a message about the force option.
774 * If we only have two allocation groups, and the superblock
775 * in the second allocation group differs from the primary
776 * superblock we can't verify the geometry information.
777 * Warn the user about this situation and get out unless
778 * explicitly overridden.
780 if (current
->refs
!= 2) {
783 _("Only two AGs detected and they do not match - "
784 "cannot validate filesystem geometry.\n"
785 "Use the -o force_geometry option to proceed.\n"));
792 * If we only have a single allocation group there is no
793 * secondary superblock that we can use to verify the geometry
794 * information. Warn the user about this situation and get
795 * out unless explicitly overridden.
799 _("Only one AG detected - "
800 "cannot validate filesystem geometry.\n"
801 "Use the -o force_geometry option to proceed.\n"));
807 * at least half of the probed superblocks have
808 * to agree. if they don't, this fs is probably
809 * too far gone anyway considering the fact that
810 * XFS normally doesn't alter the secondary superblocks.
812 if (current
->refs
< num_sbs
/ 2) {
814 _("Not enough matching superblocks - cannot proceed.\n"));
820 * set the geometry into primary superblock if necessary.
823 if (current
->index
!= sb_index
) {
825 off
= (xfs_off_t
)current
->index
* current
->geo
.sb_agblocks
826 * current
->geo
.sb_blocksize
;
827 if (get_sb(sb
, off
, current
->geo
.sb_sectsize
,
828 current
->index
) != XR_OK
)
829 do_error(_("could not read superblock\n"));
834 * turn off inprogress bit since this is the primary.
835 * also save away values that we need to ensure are
836 * consistent in the other secondaries.
838 rsb
->sb_inprogress
= 0;
839 sb_inoalignmt
= sb
->sb_inoalignmt
;
840 sb_unit
= sb
->sb_unit
;
841 sb_width
= sb
->sb_width
;