2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 #include "libxfs_priv.h"
20 #include "xfs_shared.h"
21 #include "xfs_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
26 #include "xfs_mount.h"
27 #include "xfs_defer.h"
28 #include "xfs_inode.h"
29 #include "xfs_ialloc.h"
30 #include "xfs_alloc.h"
31 #include "xfs_trace.h"
32 #include "xfs_cksum.h"
33 #include "xfs_trans.h"
34 #include "xfs_bmap_btree.h"
35 #include "xfs_alloc_btree.h"
36 #include "xfs_ialloc_btree.h"
37 #include "xfs_rmap_btree.h"
39 #include "xfs_refcount_btree.h"
40 #include "xfs_da_format.h"
41 #include "xfs_da_btree.h"
44 * Physical superblock buffer manipulations. Shared with libxfs in userspace.
48 * Reference counting access wrappers to the perag structures.
49 * Because we never free per-ag structures, the only thing we
50 * have to protect against changes is the tree structure itself.
57 struct xfs_perag
*pag
;
61 pag
= radix_tree_lookup(&mp
->m_perag_tree
, agno
);
63 ASSERT(atomic_read(&pag
->pag_ref
) >= 0);
64 ref
= atomic_inc_return(&pag
->pag_ref
);
67 trace_xfs_perag_get(mp
, agno
, ref
, _RET_IP_
);
72 * search from @first to find the next perag with the given tag set.
80 struct xfs_perag
*pag
;
85 found
= radix_tree_gang_lookup_tag(&mp
->m_perag_tree
,
86 (void **)&pag
, first
, 1, tag
);
91 ref
= atomic_inc_return(&pag
->pag_ref
);
93 trace_xfs_perag_get_tag(mp
, pag
->pag_agno
, ref
, _RET_IP_
);
99 struct xfs_perag
*pag
)
103 ASSERT(atomic_read(&pag
->pag_ref
) > 0);
104 ref
= atomic_dec_return(&pag
->pag_ref
);
105 trace_xfs_perag_put(pag
->pag_mount
, pag
->pag_agno
, ref
, _RET_IP_
);
109 * Check the validity of the SB found.
112 xfs_mount_validate_sb(
115 bool check_inprogress
,
118 uint32_t agcount
= 0;
121 if (sbp
->sb_magicnum
!= XFS_SB_MAGIC
) {
122 xfs_warn(mp
, "bad magic number");
127 if (!xfs_sb_good_version(sbp
)) {
128 xfs_warn(mp
, "bad version");
133 * Version 5 superblock feature mask validation. Reject combinations the
134 * kernel cannot support up front before checking anything else. For
135 * write validation, we don't need to check feature masks.
137 if (check_version
&& XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_5
) {
138 if (xfs_sb_has_compat_feature(sbp
,
139 XFS_SB_FEAT_COMPAT_UNKNOWN
)) {
141 "Superblock has unknown compatible features (0x%x) enabled.",
142 (sbp
->sb_features_compat
&
143 XFS_SB_FEAT_COMPAT_UNKNOWN
));
145 "Using a more recent kernel is recommended.");
148 if (xfs_sb_has_ro_compat_feature(sbp
,
149 XFS_SB_FEAT_RO_COMPAT_UNKNOWN
)) {
151 "Superblock has unknown read-only compatible features (0x%x) enabled.",
152 (sbp
->sb_features_ro_compat
&
153 XFS_SB_FEAT_RO_COMPAT_UNKNOWN
));
154 if (!(mp
->m_flags
& XFS_MOUNT_RDONLY
)) {
156 "Attempted to mount read-only compatible filesystem read-write.");
158 "Filesystem can only be safely mounted read only.");
163 if (xfs_sb_has_incompat_feature(sbp
,
164 XFS_SB_FEAT_INCOMPAT_UNKNOWN
)) {
166 "Superblock has unknown incompatible features (0x%x) enabled.",
167 (sbp
->sb_features_incompat
&
168 XFS_SB_FEAT_INCOMPAT_UNKNOWN
));
170 "Filesystem can not be safely mounted by this kernel.");
173 } else if (xfs_sb_version_hascrc(sbp
)) {
175 * We can't read verify the sb LSN because the read verifier is
176 * called before the log is allocated and processed. We know the
177 * log is set up before write verifier (!check_version) calls,
178 * so just check it here.
180 if (!xfs_log_check_lsn(mp
, sbp
->sb_lsn
))
181 return -EFSCORRUPTED
;
184 if (xfs_sb_version_has_pquotino(sbp
)) {
185 if (sbp
->sb_qflags
& (XFS_OQUOTA_ENFD
| XFS_OQUOTA_CHKD
)) {
187 "Version 5 of Super block has XFS_OQUOTA bits.");
188 return -EFSCORRUPTED
;
190 } else if (sbp
->sb_qflags
& (XFS_PQUOTA_ENFD
| XFS_GQUOTA_ENFD
|
191 XFS_PQUOTA_CHKD
| XFS_GQUOTA_CHKD
)) {
193 "Superblock earlier than Version 5 has XFS_[PQ]UOTA_{ENFD|CHKD} bits.");
194 return -EFSCORRUPTED
;
198 * Full inode chunks must be aligned to inode chunk size when
199 * sparse inodes are enabled to support the sparse chunk
200 * allocation algorithm and prevent overlapping inode records.
202 if (xfs_sb_version_hassparseinodes(sbp
)) {
205 align
= XFS_INODES_PER_CHUNK
* sbp
->sb_inodesize
207 if (sbp
->sb_inoalignmt
!= align
) {
209 "Inode block alignment (%u) must match chunk size (%u) for sparse inodes.",
210 sbp
->sb_inoalignmt
, align
);
216 sbp
->sb_logstart
== 0 && mp
->m_logdev_targp
== mp
->m_ddev_targp
)) {
218 "filesystem is marked as having an external log; "
219 "specify logdev on the mount command line.");
224 sbp
->sb_logstart
!= 0 && mp
->m_logdev_targp
!= mp
->m_ddev_targp
)) {
226 "filesystem is marked as having an internal log; "
227 "do not specify logdev on the mount command line.");
231 /* Compute agcount for this number of dblocks and agblocks */
232 if (sbp
->sb_agblocks
) {
233 agcount
= div_u64_rem(sbp
->sb_dblocks
, sbp
->sb_agblocks
, &rem
);
239 * More sanity checking. Most of these were stolen directly from
243 sbp
->sb_agcount
<= 0 ||
244 sbp
->sb_sectsize
< XFS_MIN_SECTORSIZE
||
245 sbp
->sb_sectsize
> XFS_MAX_SECTORSIZE
||
246 sbp
->sb_sectlog
< XFS_MIN_SECTORSIZE_LOG
||
247 sbp
->sb_sectlog
> XFS_MAX_SECTORSIZE_LOG
||
248 sbp
->sb_sectsize
!= (1 << sbp
->sb_sectlog
) ||
249 sbp
->sb_blocksize
< XFS_MIN_BLOCKSIZE
||
250 sbp
->sb_blocksize
> XFS_MAX_BLOCKSIZE
||
251 sbp
->sb_blocklog
< XFS_MIN_BLOCKSIZE_LOG
||
252 sbp
->sb_blocklog
> XFS_MAX_BLOCKSIZE_LOG
||
253 sbp
->sb_blocksize
!= (1 << sbp
->sb_blocklog
) ||
254 sbp
->sb_dirblklog
+ sbp
->sb_blocklog
> XFS_MAX_BLOCKSIZE_LOG
||
255 sbp
->sb_inodesize
< XFS_DINODE_MIN_SIZE
||
256 sbp
->sb_inodesize
> XFS_DINODE_MAX_SIZE
||
257 sbp
->sb_inodelog
< XFS_DINODE_MIN_LOG
||
258 sbp
->sb_inodelog
> XFS_DINODE_MAX_LOG
||
259 sbp
->sb_inodesize
!= (1 << sbp
->sb_inodelog
) ||
260 sbp
->sb_logsunit
> XLOG_MAX_RECORD_BSIZE
||
261 sbp
->sb_inopblock
!= howmany(sbp
->sb_blocksize
,sbp
->sb_inodesize
) ||
262 XFS_FSB_TO_B(mp
, sbp
->sb_agblocks
) < XFS_MIN_AG_BYTES
||
263 XFS_FSB_TO_B(mp
, sbp
->sb_agblocks
) > XFS_MAX_AG_BYTES
||
264 sbp
->sb_agblklog
!= xfs_highbit32(sbp
->sb_agblocks
- 1) + 1 ||
265 agcount
== 0 || agcount
!= sbp
->sb_agcount
||
266 (sbp
->sb_blocklog
- sbp
->sb_inodelog
!= sbp
->sb_inopblog
) ||
267 (sbp
->sb_rextsize
* sbp
->sb_blocksize
> XFS_MAX_RTEXTSIZE
) ||
268 (sbp
->sb_rextsize
* sbp
->sb_blocksize
< XFS_MIN_RTEXTSIZE
) ||
269 (sbp
->sb_imax_pct
> 100 /* zero sb_imax_pct is valid */) ||
270 sbp
->sb_dblocks
== 0 ||
271 sbp
->sb_dblocks
> XFS_MAX_DBLOCKS(sbp
) ||
272 sbp
->sb_dblocks
< XFS_MIN_DBLOCKS(sbp
) ||
273 sbp
->sb_shared_vn
!= 0)) {
274 xfs_notice(mp
, "SB sanity check failed");
275 return -EFSCORRUPTED
;
278 if (xfs_sb_version_hascrc(&mp
->m_sb
) &&
279 sbp
->sb_blocksize
< XFS_MIN_CRC_BLOCKSIZE
) {
280 xfs_notice(mp
, "v5 SB sanity check failed");
281 return -EFSCORRUPTED
;
285 * Currently only very few inode sizes are supported.
287 switch (sbp
->sb_inodesize
) {
294 xfs_warn(mp
, "inode size of %d bytes not supported",
299 if (xfs_sb_validate_fsb_count(sbp
, sbp
->sb_dblocks
) ||
300 xfs_sb_validate_fsb_count(sbp
, sbp
->sb_rblocks
)) {
302 "file system too large to be mounted on this system.");
310 xfs_sb_quota_from_disk(struct xfs_sb
*sbp
)
313 * older mkfs doesn't initialize quota inodes to NULLFSINO. This
314 * leads to in-core values having two different values for a quota
315 * inode to be invalid: 0 and NULLFSINO. Change it to a single value
318 * Note that this change affect only the in-core values. These
319 * values are not written back to disk unless any quota information
320 * is written to the disk. Even in that case, sb_pquotino field is
321 * not written to disk unless the superblock supports pquotino.
323 if (sbp
->sb_uquotino
== 0)
324 sbp
->sb_uquotino
= NULLFSINO
;
325 if (sbp
->sb_gquotino
== 0)
326 sbp
->sb_gquotino
= NULLFSINO
;
327 if (sbp
->sb_pquotino
== 0)
328 sbp
->sb_pquotino
= NULLFSINO
;
331 * We need to do these manipilations only if we are working
332 * with an older version of on-disk superblock.
334 if (xfs_sb_version_has_pquotino(sbp
))
337 if (sbp
->sb_qflags
& XFS_OQUOTA_ENFD
)
338 sbp
->sb_qflags
|= (sbp
->sb_qflags
& XFS_PQUOTA_ACCT
) ?
339 XFS_PQUOTA_ENFD
: XFS_GQUOTA_ENFD
;
340 if (sbp
->sb_qflags
& XFS_OQUOTA_CHKD
)
341 sbp
->sb_qflags
|= (sbp
->sb_qflags
& XFS_PQUOTA_ACCT
) ?
342 XFS_PQUOTA_CHKD
: XFS_GQUOTA_CHKD
;
343 sbp
->sb_qflags
&= ~(XFS_OQUOTA_ENFD
| XFS_OQUOTA_CHKD
);
345 if (sbp
->sb_qflags
& XFS_PQUOTA_ACCT
&&
346 sbp
->sb_gquotino
!= NULLFSINO
) {
348 * In older version of superblock, on-disk superblock only
349 * has sb_gquotino, and in-core superblock has both sb_gquotino
350 * and sb_pquotino. But, only one of them is supported at any
351 * point of time. So, if PQUOTA is set in disk superblock,
352 * copy over sb_gquotino to sb_pquotino. The NULLFSINO test
353 * above is to make sure we don't do this twice and wipe them
356 sbp
->sb_pquotino
= sbp
->sb_gquotino
;
357 sbp
->sb_gquotino
= NULLFSINO
;
367 to
->sb_magicnum
= be32_to_cpu(from
->sb_magicnum
);
368 to
->sb_blocksize
= be32_to_cpu(from
->sb_blocksize
);
369 to
->sb_dblocks
= be64_to_cpu(from
->sb_dblocks
);
370 to
->sb_rblocks
= be64_to_cpu(from
->sb_rblocks
);
371 to
->sb_rextents
= be64_to_cpu(from
->sb_rextents
);
372 memcpy(&to
->sb_uuid
, &from
->sb_uuid
, sizeof(to
->sb_uuid
));
373 to
->sb_logstart
= be64_to_cpu(from
->sb_logstart
);
374 to
->sb_rootino
= be64_to_cpu(from
->sb_rootino
);
375 to
->sb_rbmino
= be64_to_cpu(from
->sb_rbmino
);
376 to
->sb_rsumino
= be64_to_cpu(from
->sb_rsumino
);
377 to
->sb_rextsize
= be32_to_cpu(from
->sb_rextsize
);
378 to
->sb_agblocks
= be32_to_cpu(from
->sb_agblocks
);
379 to
->sb_agcount
= be32_to_cpu(from
->sb_agcount
);
380 to
->sb_rbmblocks
= be32_to_cpu(from
->sb_rbmblocks
);
381 to
->sb_logblocks
= be32_to_cpu(from
->sb_logblocks
);
382 to
->sb_versionnum
= be16_to_cpu(from
->sb_versionnum
);
383 to
->sb_sectsize
= be16_to_cpu(from
->sb_sectsize
);
384 to
->sb_inodesize
= be16_to_cpu(from
->sb_inodesize
);
385 to
->sb_inopblock
= be16_to_cpu(from
->sb_inopblock
);
386 memcpy(&to
->sb_fname
, &from
->sb_fname
, sizeof(to
->sb_fname
));
387 to
->sb_blocklog
= from
->sb_blocklog
;
388 to
->sb_sectlog
= from
->sb_sectlog
;
389 to
->sb_inodelog
= from
->sb_inodelog
;
390 to
->sb_inopblog
= from
->sb_inopblog
;
391 to
->sb_agblklog
= from
->sb_agblklog
;
392 to
->sb_rextslog
= from
->sb_rextslog
;
393 to
->sb_inprogress
= from
->sb_inprogress
;
394 to
->sb_imax_pct
= from
->sb_imax_pct
;
395 to
->sb_icount
= be64_to_cpu(from
->sb_icount
);
396 to
->sb_ifree
= be64_to_cpu(from
->sb_ifree
);
397 to
->sb_fdblocks
= be64_to_cpu(from
->sb_fdblocks
);
398 to
->sb_frextents
= be64_to_cpu(from
->sb_frextents
);
399 to
->sb_uquotino
= be64_to_cpu(from
->sb_uquotino
);
400 to
->sb_gquotino
= be64_to_cpu(from
->sb_gquotino
);
401 to
->sb_qflags
= be16_to_cpu(from
->sb_qflags
);
402 to
->sb_flags
= from
->sb_flags
;
403 to
->sb_shared_vn
= from
->sb_shared_vn
;
404 to
->sb_inoalignmt
= be32_to_cpu(from
->sb_inoalignmt
);
405 to
->sb_unit
= be32_to_cpu(from
->sb_unit
);
406 to
->sb_width
= be32_to_cpu(from
->sb_width
);
407 to
->sb_dirblklog
= from
->sb_dirblklog
;
408 to
->sb_logsectlog
= from
->sb_logsectlog
;
409 to
->sb_logsectsize
= be16_to_cpu(from
->sb_logsectsize
);
410 to
->sb_logsunit
= be32_to_cpu(from
->sb_logsunit
);
411 to
->sb_features2
= be32_to_cpu(from
->sb_features2
);
412 to
->sb_bad_features2
= be32_to_cpu(from
->sb_bad_features2
);
413 to
->sb_features_compat
= be32_to_cpu(from
->sb_features_compat
);
414 to
->sb_features_ro_compat
= be32_to_cpu(from
->sb_features_ro_compat
);
415 to
->sb_features_incompat
= be32_to_cpu(from
->sb_features_incompat
);
416 to
->sb_features_log_incompat
=
417 be32_to_cpu(from
->sb_features_log_incompat
);
418 /* crc is only used on disk, not in memory; just init to 0 here. */
420 to
->sb_spino_align
= be32_to_cpu(from
->sb_spino_align
);
421 to
->sb_pquotino
= be64_to_cpu(from
->sb_pquotino
);
422 to
->sb_lsn
= be64_to_cpu(from
->sb_lsn
);
424 * sb_meta_uuid is only on disk if it differs from sb_uuid and the
425 * feature flag is set; if not set we keep it only in memory.
427 if (xfs_sb_version_hasmetauuid(to
))
428 uuid_copy(&to
->sb_meta_uuid
, &from
->sb_meta_uuid
);
430 uuid_copy(&to
->sb_meta_uuid
, &from
->sb_uuid
);
431 /* Convert on-disk flags to in-memory flags? */
433 xfs_sb_quota_from_disk(to
);
441 __xfs_sb_from_disk(to
, from
, true);
445 xfs_sb_quota_to_disk(
449 uint16_t qflags
= from
->sb_qflags
;
451 to
->sb_uquotino
= cpu_to_be64(from
->sb_uquotino
);
452 if (xfs_sb_version_has_pquotino(from
)) {
453 to
->sb_qflags
= cpu_to_be16(from
->sb_qflags
);
454 to
->sb_gquotino
= cpu_to_be64(from
->sb_gquotino
);
455 to
->sb_pquotino
= cpu_to_be64(from
->sb_pquotino
);
460 * The in-core version of sb_qflags do not have XFS_OQUOTA_*
461 * flags, whereas the on-disk version does. So, convert incore
462 * XFS_{PG}QUOTA_* flags to on-disk XFS_OQUOTA_* flags.
464 qflags
&= ~(XFS_PQUOTA_ENFD
| XFS_PQUOTA_CHKD
|
465 XFS_GQUOTA_ENFD
| XFS_GQUOTA_CHKD
);
467 if (from
->sb_qflags
&
468 (XFS_PQUOTA_ENFD
| XFS_GQUOTA_ENFD
))
469 qflags
|= XFS_OQUOTA_ENFD
;
470 if (from
->sb_qflags
&
471 (XFS_PQUOTA_CHKD
| XFS_GQUOTA_CHKD
))
472 qflags
|= XFS_OQUOTA_CHKD
;
473 to
->sb_qflags
= cpu_to_be16(qflags
);
476 * GQUOTINO and PQUOTINO cannot be used together in versions
477 * of superblock that do not have pquotino. from->sb_flags
478 * tells us which quota is active and should be copied to
479 * disk. If neither are active, we should NULL the inode.
481 * In all cases, the separate pquotino must remain 0 because it
482 * it beyond the "end" of the valid non-pquotino superblock.
484 if (from
->sb_qflags
& XFS_GQUOTA_ACCT
)
485 to
->sb_gquotino
= cpu_to_be64(from
->sb_gquotino
);
486 else if (from
->sb_qflags
& XFS_PQUOTA_ACCT
)
487 to
->sb_gquotino
= cpu_to_be64(from
->sb_pquotino
);
490 * We can't rely on just the fields being logged to tell us
491 * that it is safe to write NULLFSINO - we should only do that
492 * if quotas are not actually enabled. Hence only write
493 * NULLFSINO if both in-core quota inodes are NULL.
495 if (from
->sb_gquotino
== NULLFSINO
&&
496 from
->sb_pquotino
== NULLFSINO
)
497 to
->sb_gquotino
= cpu_to_be64(NULLFSINO
);
508 xfs_sb_quota_to_disk(to
, from
);
510 to
->sb_magicnum
= cpu_to_be32(from
->sb_magicnum
);
511 to
->sb_blocksize
= cpu_to_be32(from
->sb_blocksize
);
512 to
->sb_dblocks
= cpu_to_be64(from
->sb_dblocks
);
513 to
->sb_rblocks
= cpu_to_be64(from
->sb_rblocks
);
514 to
->sb_rextents
= cpu_to_be64(from
->sb_rextents
);
515 memcpy(&to
->sb_uuid
, &from
->sb_uuid
, sizeof(to
->sb_uuid
));
516 to
->sb_logstart
= cpu_to_be64(from
->sb_logstart
);
517 to
->sb_rootino
= cpu_to_be64(from
->sb_rootino
);
518 to
->sb_rbmino
= cpu_to_be64(from
->sb_rbmino
);
519 to
->sb_rsumino
= cpu_to_be64(from
->sb_rsumino
);
520 to
->sb_rextsize
= cpu_to_be32(from
->sb_rextsize
);
521 to
->sb_agblocks
= cpu_to_be32(from
->sb_agblocks
);
522 to
->sb_agcount
= cpu_to_be32(from
->sb_agcount
);
523 to
->sb_rbmblocks
= cpu_to_be32(from
->sb_rbmblocks
);
524 to
->sb_logblocks
= cpu_to_be32(from
->sb_logblocks
);
525 to
->sb_versionnum
= cpu_to_be16(from
->sb_versionnum
);
526 to
->sb_sectsize
= cpu_to_be16(from
->sb_sectsize
);
527 to
->sb_inodesize
= cpu_to_be16(from
->sb_inodesize
);
528 to
->sb_inopblock
= cpu_to_be16(from
->sb_inopblock
);
529 memcpy(&to
->sb_fname
, &from
->sb_fname
, sizeof(to
->sb_fname
));
530 to
->sb_blocklog
= from
->sb_blocklog
;
531 to
->sb_sectlog
= from
->sb_sectlog
;
532 to
->sb_inodelog
= from
->sb_inodelog
;
533 to
->sb_inopblog
= from
->sb_inopblog
;
534 to
->sb_agblklog
= from
->sb_agblklog
;
535 to
->sb_rextslog
= from
->sb_rextslog
;
536 to
->sb_inprogress
= from
->sb_inprogress
;
537 to
->sb_imax_pct
= from
->sb_imax_pct
;
538 to
->sb_icount
= cpu_to_be64(from
->sb_icount
);
539 to
->sb_ifree
= cpu_to_be64(from
->sb_ifree
);
540 to
->sb_fdblocks
= cpu_to_be64(from
->sb_fdblocks
);
541 to
->sb_frextents
= cpu_to_be64(from
->sb_frextents
);
543 to
->sb_flags
= from
->sb_flags
;
544 to
->sb_shared_vn
= from
->sb_shared_vn
;
545 to
->sb_inoalignmt
= cpu_to_be32(from
->sb_inoalignmt
);
546 to
->sb_unit
= cpu_to_be32(from
->sb_unit
);
547 to
->sb_width
= cpu_to_be32(from
->sb_width
);
548 to
->sb_dirblklog
= from
->sb_dirblklog
;
549 to
->sb_logsectlog
= from
->sb_logsectlog
;
550 to
->sb_logsectsize
= cpu_to_be16(from
->sb_logsectsize
);
551 to
->sb_logsunit
= cpu_to_be32(from
->sb_logsunit
);
554 * We need to ensure that bad_features2 always matches features2.
555 * Hence we enforce that here rather than having to remember to do it
556 * everywhere else that updates features2.
558 from
->sb_bad_features2
= from
->sb_features2
;
559 to
->sb_features2
= cpu_to_be32(from
->sb_features2
);
560 to
->sb_bad_features2
= cpu_to_be32(from
->sb_bad_features2
);
562 if (xfs_sb_version_hascrc(from
)) {
563 to
->sb_features_compat
= cpu_to_be32(from
->sb_features_compat
);
564 to
->sb_features_ro_compat
=
565 cpu_to_be32(from
->sb_features_ro_compat
);
566 to
->sb_features_incompat
=
567 cpu_to_be32(from
->sb_features_incompat
);
568 to
->sb_features_log_incompat
=
569 cpu_to_be32(from
->sb_features_log_incompat
);
570 to
->sb_spino_align
= cpu_to_be32(from
->sb_spino_align
);
571 to
->sb_lsn
= cpu_to_be64(from
->sb_lsn
);
572 if (xfs_sb_version_hasmetauuid(from
))
573 uuid_copy(&to
->sb_meta_uuid
, &from
->sb_meta_uuid
);
582 struct xfs_mount
*mp
= bp
->b_target
->bt_mount
;
586 * Use call variant which doesn't convert quota flags from disk
587 * format, because xfs_mount_validate_sb checks the on-disk flags.
589 __xfs_sb_from_disk(&sb
, XFS_BUF_TO_SBP(bp
), false);
592 * Only check the in progress field for the primary superblock as
593 * mkfs.xfs doesn't clear it from secondary superblocks.
595 return xfs_mount_validate_sb(mp
, &sb
,
596 bp
->b_maps
[0].bm_bn
== XFS_SB_DADDR
,
601 * If the superblock has the CRC feature bit set or the CRC field is non-null,
602 * check that the CRC is valid. We check the CRC field is non-null because a
603 * single bit error could clear the feature bit and unused parts of the
604 * superblock are supposed to be zero. Hence a non-null crc field indicates that
605 * we've potentially lost a feature bit and we should check it anyway.
607 * However, past bugs (i.e. in growfs) left non-zeroed regions beyond the
608 * last field in V4 secondary superblocks. So for secondary superblocks,
609 * we are more forgiving, and ignore CRC failures if the primary doesn't
610 * indicate that the fs version is V5.
616 struct xfs_mount
*mp
= bp
->b_target
->bt_mount
;
617 struct xfs_dsb
*dsb
= XFS_BUF_TO_SBP(bp
);
621 * open code the version check to avoid needing to convert the entire
622 * superblock from disk order just to check the version number
624 if (dsb
->sb_magicnum
== cpu_to_be32(XFS_SB_MAGIC
) &&
625 (((be16_to_cpu(dsb
->sb_versionnum
) & XFS_SB_VERSION_NUMBITS
) ==
629 if (!xfs_buf_verify_cksum(bp
, XFS_SB_CRC_OFF
)) {
630 /* Only fail bad secondaries on a known V5 filesystem */
631 if (bp
->b_bn
== XFS_SB_DADDR
||
632 xfs_sb_version_hascrc(&mp
->m_sb
)) {
638 error
= xfs_sb_verify(bp
, true);
641 if (error
== -EFSCORRUPTED
|| error
== -EFSBADCRC
)
642 xfs_verifier_error(bp
, error
, __this_address
);
644 xfs_buf_ioerror(bp
, error
);
648 * We may be probed for a filesystem match, so we may not want to emit
649 * messages when the superblock buffer is not actually an XFS superblock.
650 * If we find an XFS superblock, then run a normal, noisy mount because we are
651 * really going to mount it and want to know about errors.
654 xfs_sb_quiet_read_verify(
657 struct xfs_dsb
*dsb
= XFS_BUF_TO_SBP(bp
);
659 if (dsb
->sb_magicnum
== cpu_to_be32(XFS_SB_MAGIC
)) {
660 /* XFS filesystem, verify noisily! */
661 xfs_sb_read_verify(bp
);
665 xfs_buf_ioerror(bp
, -EWRONGFS
);
672 struct xfs_mount
*mp
= bp
->b_target
->bt_mount
;
673 struct xfs_buf_log_item
*bip
= bp
->b_log_item
;
676 error
= xfs_sb_verify(bp
, false);
678 xfs_verifier_error(bp
, error
, __this_address
);
682 if (!xfs_sb_version_hascrc(&mp
->m_sb
))
686 XFS_BUF_TO_SBP(bp
)->sb_lsn
= cpu_to_be64(bip
->bli_item
.li_lsn
);
688 xfs_buf_update_cksum(bp
, XFS_SB_CRC_OFF
);
691 const struct xfs_buf_ops xfs_sb_buf_ops
= {
693 .verify_read
= xfs_sb_read_verify
,
694 .verify_write
= xfs_sb_write_verify
,
697 const struct xfs_buf_ops xfs_sb_quiet_buf_ops
= {
698 .name
= "xfs_sb_quiet",
699 .verify_read
= xfs_sb_quiet_read_verify
,
700 .verify_write
= xfs_sb_write_verify
,
706 * Mount initialization code establishing various mount
707 * fields from the superblock associated with the given
712 struct xfs_mount
*mp
,
715 mp
->m_agfrotor
= mp
->m_agirotor
= 0;
716 mp
->m_maxagi
= mp
->m_sb
.sb_agcount
;
717 mp
->m_blkbit_log
= sbp
->sb_blocklog
+ XFS_NBBYLOG
;
718 mp
->m_blkbb_log
= sbp
->sb_blocklog
- BBSHIFT
;
719 mp
->m_sectbb_log
= sbp
->sb_sectlog
- BBSHIFT
;
720 mp
->m_agno_log
= xfs_highbit32(sbp
->sb_agcount
- 1) + 1;
721 mp
->m_agino_log
= sbp
->sb_inopblog
+ sbp
->sb_agblklog
;
722 mp
->m_blockmask
= sbp
->sb_blocksize
- 1;
723 mp
->m_blockwsize
= sbp
->sb_blocksize
>> XFS_WORDLOG
;
724 mp
->m_blockwmask
= mp
->m_blockwsize
- 1;
726 mp
->m_alloc_mxr
[0] = xfs_allocbt_maxrecs(mp
, sbp
->sb_blocksize
, 1);
727 mp
->m_alloc_mxr
[1] = xfs_allocbt_maxrecs(mp
, sbp
->sb_blocksize
, 0);
728 mp
->m_alloc_mnr
[0] = mp
->m_alloc_mxr
[0] / 2;
729 mp
->m_alloc_mnr
[1] = mp
->m_alloc_mxr
[1] / 2;
731 mp
->m_inobt_mxr
[0] = xfs_inobt_maxrecs(mp
, sbp
->sb_blocksize
, 1);
732 mp
->m_inobt_mxr
[1] = xfs_inobt_maxrecs(mp
, sbp
->sb_blocksize
, 0);
733 mp
->m_inobt_mnr
[0] = mp
->m_inobt_mxr
[0] / 2;
734 mp
->m_inobt_mnr
[1] = mp
->m_inobt_mxr
[1] / 2;
736 mp
->m_bmap_dmxr
[0] = xfs_bmbt_maxrecs(mp
, sbp
->sb_blocksize
, 1);
737 mp
->m_bmap_dmxr
[1] = xfs_bmbt_maxrecs(mp
, sbp
->sb_blocksize
, 0);
738 mp
->m_bmap_dmnr
[0] = mp
->m_bmap_dmxr
[0] / 2;
739 mp
->m_bmap_dmnr
[1] = mp
->m_bmap_dmxr
[1] / 2;
741 mp
->m_rmap_mxr
[0] = xfs_rmapbt_maxrecs(sbp
->sb_blocksize
, 1);
742 mp
->m_rmap_mxr
[1] = xfs_rmapbt_maxrecs(sbp
->sb_blocksize
, 0);
743 mp
->m_rmap_mnr
[0] = mp
->m_rmap_mxr
[0] / 2;
744 mp
->m_rmap_mnr
[1] = mp
->m_rmap_mxr
[1] / 2;
746 mp
->m_refc_mxr
[0] = xfs_refcountbt_maxrecs(sbp
->sb_blocksize
, true);
747 mp
->m_refc_mxr
[1] = xfs_refcountbt_maxrecs(sbp
->sb_blocksize
, false);
748 mp
->m_refc_mnr
[0] = mp
->m_refc_mxr
[0] / 2;
749 mp
->m_refc_mnr
[1] = mp
->m_refc_mxr
[1] / 2;
751 mp
->m_bsize
= XFS_FSB_TO_BB(mp
, 1);
752 mp
->m_ialloc_inos
= (int)MAX((uint16_t)XFS_INODES_PER_CHUNK
,
754 mp
->m_ialloc_blks
= mp
->m_ialloc_inos
>> sbp
->sb_inopblog
;
756 if (sbp
->sb_spino_align
)
757 mp
->m_ialloc_min_blks
= sbp
->sb_spino_align
;
759 mp
->m_ialloc_min_blks
= mp
->m_ialloc_blks
;
760 mp
->m_alloc_set_aside
= xfs_alloc_set_aside(mp
);
761 mp
->m_ag_max_usable
= xfs_alloc_ag_max_usable(mp
);
765 * xfs_initialize_perag_data
767 * Read in each per-ag structure so we can count up the number of
768 * allocated inodes, free inodes and used filesystem blocks as this
769 * information is no longer persistent in the superblock. Once we have
770 * this information, write it into the in-core superblock structure.
773 xfs_initialize_perag_data(
774 struct xfs_mount
*mp
,
775 xfs_agnumber_t agcount
)
777 xfs_agnumber_t index
;
779 xfs_sb_t
*sbp
= &mp
->m_sb
;
783 uint64_t bfreelst
= 0;
787 for (index
= 0; index
< agcount
; index
++) {
789 * read the agf, then the agi. This gets us
790 * all the information we need and populates the
791 * per-ag structures for us.
793 error
= xfs_alloc_pagf_init(mp
, NULL
, index
, 0);
797 error
= xfs_ialloc_pagi_init(mp
, NULL
, index
);
800 pag
= xfs_perag_get(mp
, index
);
801 ifree
+= pag
->pagi_freecount
;
802 ialloc
+= pag
->pagi_count
;
803 bfree
+= pag
->pagf_freeblks
;
804 bfreelst
+= pag
->pagf_flcount
;
805 btree
+= pag
->pagf_btreeblks
;
809 /* Overwrite incore superblock counters with just-read data */
810 spin_lock(&mp
->m_sb_lock
);
811 sbp
->sb_ifree
= ifree
;
812 sbp
->sb_icount
= ialloc
;
813 sbp
->sb_fdblocks
= bfree
+ bfreelst
+ btree
;
814 spin_unlock(&mp
->m_sb_lock
);
816 xfs_reinit_percpu_counters(mp
);
822 * xfs_log_sb() can be used to copy arbitrary changes to the in-core superblock
823 * into the superblock buffer to be logged. It does not provide the higher
824 * level of locking that is needed to protect the in-core superblock from
829 struct xfs_trans
*tp
)
831 struct xfs_mount
*mp
= tp
->t_mountp
;
832 struct xfs_buf
*bp
= xfs_trans_getsb(tp
, mp
, 0);
834 mp
->m_sb
.sb_icount
= percpu_counter_sum(&mp
->m_icount
);
835 mp
->m_sb
.sb_ifree
= percpu_counter_sum(&mp
->m_ifree
);
836 mp
->m_sb
.sb_fdblocks
= percpu_counter_sum(&mp
->m_fdblocks
);
838 xfs_sb_to_disk(XFS_BUF_TO_SBP(bp
), &mp
->m_sb
);
839 xfs_trans_buf_set_type(tp
, bp
, XFS_BLFT_SB_BUF
);
840 xfs_trans_log_buf(tp
, bp
, 0, sizeof(struct xfs_dsb
));
846 * Sync the superblock to disk.
848 * Note that the caller is responsible for checking the frozen state of the
849 * filesystem. This procedure uses the non-blocking transaction allocator and
850 * thus will allow modifications to a frozen fs. This is required because this
851 * code can be called during the process of freezing where use of the high-level
852 * allocator would deadlock.
856 struct xfs_mount
*mp
,
859 struct xfs_trans
*tp
;
862 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_sb
, 0, 0,
863 XFS_TRANS_NO_WRITECOUNT
, &tp
);
869 xfs_trans_set_sync(tp
);
870 return xfs_trans_commit(tp
);
876 struct xfs_fsop_geom
*geo
,
879 memset(geo
, 0, sizeof(struct xfs_fsop_geom
));
881 geo
->blocksize
= sbp
->sb_blocksize
;
882 geo
->rtextsize
= sbp
->sb_rextsize
;
883 geo
->agblocks
= sbp
->sb_agblocks
;
884 geo
->agcount
= sbp
->sb_agcount
;
885 geo
->logblocks
= sbp
->sb_logblocks
;
886 geo
->sectsize
= sbp
->sb_sectsize
;
887 geo
->inodesize
= sbp
->sb_inodesize
;
888 geo
->imaxpct
= sbp
->sb_imax_pct
;
889 geo
->datablocks
= sbp
->sb_dblocks
;
890 geo
->rtblocks
= sbp
->sb_rblocks
;
891 geo
->rtextents
= sbp
->sb_rextents
;
892 geo
->logstart
= sbp
->sb_logstart
;
893 BUILD_BUG_ON(sizeof(geo
->uuid
) != sizeof(sbp
->sb_uuid
));
894 memcpy(geo
->uuid
, &sbp
->sb_uuid
, sizeof(sbp
->sb_uuid
));
896 if (struct_version
< 2)
899 geo
->sunit
= sbp
->sb_unit
;
900 geo
->swidth
= sbp
->sb_width
;
902 if (struct_version
< 3)
905 geo
->version
= XFS_FSOP_GEOM_VERSION
;
906 geo
->flags
= XFS_FSOP_GEOM_FLAGS_NLINK
|
907 XFS_FSOP_GEOM_FLAGS_DIRV2
;
908 if (xfs_sb_version_hasattr(sbp
))
909 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_ATTR
;
910 if (xfs_sb_version_hasquota(sbp
))
911 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_QUOTA
;
912 if (xfs_sb_version_hasalign(sbp
))
913 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_IALIGN
;
914 if (xfs_sb_version_hasdalign(sbp
))
915 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_DALIGN
;
916 if (xfs_sb_version_hasextflgbit(sbp
))
917 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_EXTFLG
;
918 if (xfs_sb_version_hassector(sbp
))
919 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_SECTOR
;
920 if (xfs_sb_version_hasasciici(sbp
))
921 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_DIRV2CI
;
922 if (xfs_sb_version_haslazysbcount(sbp
))
923 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_LAZYSB
;
924 if (xfs_sb_version_hasattr2(sbp
))
925 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_ATTR2
;
926 if (xfs_sb_version_hasprojid32bit(sbp
))
927 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_PROJID32
;
928 if (xfs_sb_version_hascrc(sbp
))
929 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_V5SB
;
930 if (xfs_sb_version_hasftype(sbp
))
931 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_FTYPE
;
932 if (xfs_sb_version_hasfinobt(sbp
))
933 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_FINOBT
;
934 if (xfs_sb_version_hassparseinodes(sbp
))
935 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_SPINODES
;
936 if (xfs_sb_version_hasrmapbt(sbp
))
937 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_RMAPBT
;
938 if (xfs_sb_version_hasreflink(sbp
))
939 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_REFLINK
;
940 if (xfs_sb_version_hassector(sbp
))
941 geo
->logsectsize
= sbp
->sb_logsectsize
;
943 geo
->logsectsize
= BBSIZE
;
944 geo
->rtsectsize
= sbp
->sb_blocksize
;
945 geo
->dirblocksize
= xfs_dir2_dirblock_bytes(sbp
);
947 if (struct_version
< 4)
950 if (xfs_sb_version_haslogv2(sbp
))
951 geo
->flags
|= XFS_FSOP_GEOM_FLAGS_LOGV2
;
953 geo
->logsunit
= sbp
->sb_logsunit
;