2013-08-12 18:49:41 +08:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2000-2005 Silicon Graphics, Inc.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it would be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
|
|
|
#include "xfs_fs.h"
|
2013-10-29 19:11:58 +08:00
|
|
|
#include "xfs_shared.h"
|
2013-08-12 18:49:41 +08:00
|
|
|
#include "xfs_format.h"
|
2013-10-23 07:50:10 +08:00
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2013-08-12 18:49:41 +08:00
|
|
|
#include "xfs_bit.h"
|
|
|
|
#include "xfs_sb.h"
|
|
|
|
#include "xfs_mount.h"
|
2016-08-03 09:15:38 +08:00
|
|
|
#include "xfs_defer.h"
|
2013-08-12 18:49:41 +08:00
|
|
|
#include "xfs_inode.h"
|
|
|
|
#include "xfs_ialloc.h"
|
|
|
|
#include "xfs_alloc.h"
|
|
|
|
#include "xfs_error.h"
|
|
|
|
#include "xfs_trace.h"
|
|
|
|
#include "xfs_cksum.h"
|
2013-10-23 07:50:10 +08:00
|
|
|
#include "xfs_trans.h"
|
2013-08-12 18:49:41 +08:00
|
|
|
#include "xfs_buf_item.h"
|
2013-10-23 07:51:50 +08:00
|
|
|
#include "xfs_bmap_btree.h"
|
|
|
|
#include "xfs_alloc_btree.h"
|
|
|
|
#include "xfs_ialloc_btree.h"
|
2015-10-12 12:59:25 +08:00
|
|
|
#include "xfs_log.h"
|
2016-08-03 09:36:07 +08:00
|
|
|
#include "xfs_rmap_btree.h"
|
2016-10-04 00:11:18 +08:00
|
|
|
#include "xfs_bmap.h"
|
|
|
|
#include "xfs_refcount_btree.h"
|
2018-01-09 02:51:27 +08:00
|
|
|
#include "xfs_da_format.h"
|
|
|
|
#include "xfs_da_btree.h"
|
2013-08-12 18:49:41 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Physical superblock buffer manipulations. Shared with libxfs in userspace.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reference counting access wrappers to the perag structures.
|
|
|
|
* Because we never free per-ag structures, the only thing we
|
|
|
|
* have to protect against changes is the tree structure itself.
|
|
|
|
*/
|
|
|
|
struct xfs_perag *
|
|
|
|
xfs_perag_get(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_agnumber_t agno)
|
|
|
|
{
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
int ref = 0;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
pag = radix_tree_lookup(&mp->m_perag_tree, agno);
|
|
|
|
if (pag) {
|
|
|
|
ASSERT(atomic_read(&pag->pag_ref) >= 0);
|
|
|
|
ref = atomic_inc_return(&pag->pag_ref);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
trace_xfs_perag_get(mp, agno, ref, _RET_IP_);
|
|
|
|
return pag;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* search from @first to find the next perag with the given tag set.
|
|
|
|
*/
|
|
|
|
struct xfs_perag *
|
|
|
|
xfs_perag_get_tag(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_agnumber_t first,
|
|
|
|
int tag)
|
|
|
|
{
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
int found;
|
|
|
|
int ref;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
found = radix_tree_gang_lookup_tag(&mp->m_perag_tree,
|
|
|
|
(void **)&pag, first, 1, tag);
|
|
|
|
if (found <= 0) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
ref = atomic_inc_return(&pag->pag_ref);
|
|
|
|
rcu_read_unlock();
|
|
|
|
trace_xfs_perag_get_tag(mp, pag->pag_agno, ref, _RET_IP_);
|
|
|
|
return pag;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_perag_put(
|
|
|
|
struct xfs_perag *pag)
|
|
|
|
{
|
|
|
|
int ref;
|
|
|
|
|
|
|
|
ASSERT(atomic_read(&pag->pag_ref) > 0);
|
|
|
|
ref = atomic_dec_return(&pag->pag_ref);
|
|
|
|
trace_xfs_perag_put(pag->pag_mount, pag->pag_agno, ref, _RET_IP_);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check the validity of the SB found.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_mount_validate_sb(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
xfs_sb_t *sbp,
|
|
|
|
bool check_inprogress,
|
|
|
|
bool check_version)
|
|
|
|
{
|
|
|
|
if (sbp->sb_magicnum != XFS_SB_MAGIC) {
|
|
|
|
xfs_warn(mp, "bad magic number");
|
2014-06-25 12:58:08 +08:00
|
|
|
return -EWRONGFS;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (!xfs_sb_good_version(sbp)) {
|
|
|
|
xfs_warn(mp, "bad version");
|
2014-06-25 12:58:08 +08:00
|
|
|
return -EWRONGFS;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Version 5 superblock feature mask validation. Reject combinations the
|
|
|
|
* kernel cannot support up front before checking anything else. For
|
|
|
|
* write validation, we don't need to check feature masks.
|
|
|
|
*/
|
|
|
|
if (check_version && XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5) {
|
|
|
|
if (xfs_sb_has_compat_feature(sbp,
|
|
|
|
XFS_SB_FEAT_COMPAT_UNKNOWN)) {
|
|
|
|
xfs_warn(mp,
|
2015-07-29 09:52:04 +08:00
|
|
|
"Superblock has unknown compatible features (0x%x) enabled.",
|
2013-08-12 18:49:41 +08:00
|
|
|
(sbp->sb_features_compat &
|
|
|
|
XFS_SB_FEAT_COMPAT_UNKNOWN));
|
2015-07-29 09:52:04 +08:00
|
|
|
xfs_warn(mp,
|
|
|
|
"Using a more recent kernel is recommended.");
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (xfs_sb_has_ro_compat_feature(sbp,
|
|
|
|
XFS_SB_FEAT_RO_COMPAT_UNKNOWN)) {
|
|
|
|
xfs_alert(mp,
|
|
|
|
"Superblock has unknown read-only compatible features (0x%x) enabled.",
|
|
|
|
(sbp->sb_features_ro_compat &
|
|
|
|
XFS_SB_FEAT_RO_COMPAT_UNKNOWN));
|
|
|
|
if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
|
|
|
|
xfs_warn(mp,
|
2015-07-29 09:52:04 +08:00
|
|
|
"Attempted to mount read-only compatible filesystem read-write.");
|
|
|
|
xfs_warn(mp,
|
2013-08-12 18:49:41 +08:00
|
|
|
"Filesystem can only be safely mounted read only.");
|
2015-07-29 09:52:04 +08:00
|
|
|
|
2014-06-25 12:58:08 +08:00
|
|
|
return -EINVAL;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (xfs_sb_has_incompat_feature(sbp,
|
|
|
|
XFS_SB_FEAT_INCOMPAT_UNKNOWN)) {
|
|
|
|
xfs_warn(mp,
|
2015-07-29 09:52:04 +08:00
|
|
|
"Superblock has unknown incompatible features (0x%x) enabled.",
|
2013-08-12 18:49:41 +08:00
|
|
|
(sbp->sb_features_incompat &
|
|
|
|
XFS_SB_FEAT_INCOMPAT_UNKNOWN));
|
2015-07-29 09:52:04 +08:00
|
|
|
xfs_warn(mp,
|
|
|
|
"Filesystem can not be safely mounted by this kernel.");
|
2014-06-25 12:58:08 +08:00
|
|
|
return -EINVAL;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
2015-10-12 12:59:25 +08:00
|
|
|
} else if (xfs_sb_version_hascrc(sbp)) {
|
|
|
|
/*
|
|
|
|
* We can't read verify the sb LSN because the read verifier is
|
|
|
|
* called before the log is allocated and processed. We know the
|
|
|
|
* log is set up before write verifier (!check_version) calls,
|
|
|
|
* so just check it here.
|
|
|
|
*/
|
|
|
|
if (!xfs_log_check_lsn(mp, sbp->sb_lsn))
|
|
|
|
return -EFSCORRUPTED;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (xfs_sb_version_has_pquotino(sbp)) {
|
|
|
|
if (sbp->sb_qflags & (XFS_OQUOTA_ENFD | XFS_OQUOTA_CHKD)) {
|
|
|
|
xfs_notice(mp,
|
2013-10-12 09:59:05 +08:00
|
|
|
"Version 5 of Super block has XFS_OQUOTA bits.");
|
2014-06-25 12:58:08 +08:00
|
|
|
return -EFSCORRUPTED;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
} else if (sbp->sb_qflags & (XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD |
|
|
|
|
XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD)) {
|
|
|
|
xfs_notice(mp,
|
2013-10-12 09:59:05 +08:00
|
|
|
"Superblock earlier than Version 5 has XFS_[PQ]UOTA_{ENFD|CHKD} bits.");
|
2014-06-25 12:58:08 +08:00
|
|
|
return -EFSCORRUPTED;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
2015-05-29 06:57:27 +08:00
|
|
|
/*
|
|
|
|
* Full inode chunks must be aligned to inode chunk size when
|
|
|
|
* sparse inodes are enabled to support the sparse chunk
|
|
|
|
* allocation algorithm and prevent overlapping inode records.
|
|
|
|
*/
|
|
|
|
if (xfs_sb_version_hassparseinodes(sbp)) {
|
|
|
|
uint32_t align;
|
|
|
|
|
|
|
|
align = XFS_INODES_PER_CHUNK * sbp->sb_inodesize
|
|
|
|
>> sbp->sb_blocklog;
|
|
|
|
if (sbp->sb_inoalignmt != align) {
|
|
|
|
xfs_warn(mp,
|
|
|
|
"Inode block alignment (%u) must match chunk size (%u) for sparse inodes.",
|
|
|
|
sbp->sb_inoalignmt, align);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-12 18:49:41 +08:00
|
|
|
if (unlikely(
|
|
|
|
sbp->sb_logstart == 0 && mp->m_logdev_targp == mp->m_ddev_targp)) {
|
|
|
|
xfs_warn(mp,
|
|
|
|
"filesystem is marked as having an external log; "
|
|
|
|
"specify logdev on the mount command line.");
|
2014-06-25 12:58:08 +08:00
|
|
|
return -EINVAL;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(
|
|
|
|
sbp->sb_logstart != 0 && mp->m_logdev_targp != mp->m_ddev_targp)) {
|
|
|
|
xfs_warn(mp,
|
|
|
|
"filesystem is marked as having an internal log; "
|
|
|
|
"do not specify logdev on the mount command line.");
|
2014-06-25 12:58:08 +08:00
|
|
|
return -EINVAL;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* More sanity checking. Most of these were stolen directly from
|
|
|
|
* xfs_repair.
|
|
|
|
*/
|
|
|
|
if (unlikely(
|
|
|
|
sbp->sb_agcount <= 0 ||
|
|
|
|
sbp->sb_sectsize < XFS_MIN_SECTORSIZE ||
|
|
|
|
sbp->sb_sectsize > XFS_MAX_SECTORSIZE ||
|
|
|
|
sbp->sb_sectlog < XFS_MIN_SECTORSIZE_LOG ||
|
|
|
|
sbp->sb_sectlog > XFS_MAX_SECTORSIZE_LOG ||
|
|
|
|
sbp->sb_sectsize != (1 << sbp->sb_sectlog) ||
|
|
|
|
sbp->sb_blocksize < XFS_MIN_BLOCKSIZE ||
|
|
|
|
sbp->sb_blocksize > XFS_MAX_BLOCKSIZE ||
|
|
|
|
sbp->sb_blocklog < XFS_MIN_BLOCKSIZE_LOG ||
|
|
|
|
sbp->sb_blocklog > XFS_MAX_BLOCKSIZE_LOG ||
|
|
|
|
sbp->sb_blocksize != (1 << sbp->sb_blocklog) ||
|
2017-01-24 11:43:00 +08:00
|
|
|
sbp->sb_dirblklog + sbp->sb_blocklog > XFS_MAX_BLOCKSIZE_LOG ||
|
2013-08-12 18:49:41 +08:00
|
|
|
sbp->sb_inodesize < XFS_DINODE_MIN_SIZE ||
|
|
|
|
sbp->sb_inodesize > XFS_DINODE_MAX_SIZE ||
|
|
|
|
sbp->sb_inodelog < XFS_DINODE_MIN_LOG ||
|
|
|
|
sbp->sb_inodelog > XFS_DINODE_MAX_LOG ||
|
|
|
|
sbp->sb_inodesize != (1 << sbp->sb_inodelog) ||
|
2014-09-09 09:47:24 +08:00
|
|
|
sbp->sb_logsunit > XLOG_MAX_RECORD_BSIZE ||
|
2014-02-07 12:26:11 +08:00
|
|
|
sbp->sb_inopblock != howmany(sbp->sb_blocksize,sbp->sb_inodesize) ||
|
2013-08-12 18:49:41 +08:00
|
|
|
(sbp->sb_blocklog - sbp->sb_inodelog != sbp->sb_inopblog) ||
|
|
|
|
(sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE) ||
|
|
|
|
(sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE) ||
|
|
|
|
(sbp->sb_imax_pct > 100 /* zero sb_imax_pct is valid */) ||
|
|
|
|
sbp->sb_dblocks == 0 ||
|
|
|
|
sbp->sb_dblocks > XFS_MAX_DBLOCKS(sbp) ||
|
2014-05-20 05:47:05 +08:00
|
|
|
sbp->sb_dblocks < XFS_MIN_DBLOCKS(sbp) ||
|
|
|
|
sbp->sb_shared_vn != 0)) {
|
xfs: limit superblock corruption errors to actual corruption
Today, if
xfs_sb_read_verify
xfs_sb_verify
xfs_mount_validate_sb
detects superblock corruption, it'll be extremely noisy, dumping
2 stacks, 2 hexdumps, etc.
This is because we call XFS_CORRUPTION_ERROR in xfs_mount_validate_sb
as well as in xfs_sb_read_verify.
Also, *any* errors in xfs_mount_validate_sb which are not corruption
per se; things like too-big-blocksize, bad version, bad magic, v1 dirs,
rw-incompat etc - things which do not return EFSCORRUPTED - will
still do the whole XFS_CORRUPTION_ERROR spew when xfs_sb_read_verify
sees any error at all. And it suggests to the user that they
should run xfs_repair, even if the root cause of the mount failure
is a simple incompatibility.
I'll submit that the probably-not-corrupted errors don't warrant
this much noise, so this patch removes the warning for anything
other than EFSCORRUPTED returns, and replaces the lower-level
XFS_CORRUPTION_ERROR with an xfs_notice().
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-02-19 12:39:35 +08:00
|
|
|
xfs_notice(mp, "SB sanity check failed");
|
2014-06-25 12:58:08 +08:00
|
|
|
return -EFSCORRUPTED;
|
2016-11-09 09:11:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb) &&
|
|
|
|
sbp->sb_blocksize < XFS_MIN_CRC_BLOCKSIZE) {
|
|
|
|
xfs_notice(mp, "v5 SB sanity check failed");
|
|
|
|
return -EFSCORRUPTED;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Until this is fixed only page-sized or smaller data blocks work.
|
|
|
|
*/
|
|
|
|
if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) {
|
|
|
|
xfs_warn(mp,
|
|
|
|
"File system with blocksize %d bytes. "
|
|
|
|
"Only pagesize (%ld) or less will currently work.",
|
|
|
|
sbp->sb_blocksize, PAGE_SIZE);
|
2014-06-25 12:58:08 +08:00
|
|
|
return -ENOSYS;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Currently only very few inode sizes are supported.
|
|
|
|
*/
|
|
|
|
switch (sbp->sb_inodesize) {
|
|
|
|
case 256:
|
|
|
|
case 512:
|
|
|
|
case 1024:
|
|
|
|
case 2048:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
xfs_warn(mp, "inode size of %d bytes not supported",
|
|
|
|
sbp->sb_inodesize);
|
2014-06-25 12:58:08 +08:00
|
|
|
return -ENOSYS;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (xfs_sb_validate_fsb_count(sbp, sbp->sb_dblocks) ||
|
|
|
|
xfs_sb_validate_fsb_count(sbp, sbp->sb_rblocks)) {
|
|
|
|
xfs_warn(mp,
|
|
|
|
"file system too large to be mounted on this system.");
|
2014-06-25 12:58:08 +08:00
|
|
|
return -EFBIG;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (check_inprogress && sbp->sb_inprogress) {
|
|
|
|
xfs_warn(mp, "Offline file system operation in progress!");
|
2014-06-25 12:58:08 +08:00
|
|
|
return -EFSCORRUPTED;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_sb_quota_from_disk(struct xfs_sb *sbp)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* older mkfs doesn't initialize quota inodes to NULLFSINO. This
|
|
|
|
* leads to in-core values having two different values for a quota
|
|
|
|
* inode to be invalid: 0 and NULLFSINO. Change it to a single value
|
|
|
|
* NULLFSINO.
|
|
|
|
*
|
|
|
|
* Note that this change affect only the in-core values. These
|
|
|
|
* values are not written back to disk unless any quota information
|
|
|
|
* is written to the disk. Even in that case, sb_pquotino field is
|
|
|
|
* not written to disk unless the superblock supports pquotino.
|
|
|
|
*/
|
|
|
|
if (sbp->sb_uquotino == 0)
|
|
|
|
sbp->sb_uquotino = NULLFSINO;
|
|
|
|
if (sbp->sb_gquotino == 0)
|
|
|
|
sbp->sb_gquotino = NULLFSINO;
|
|
|
|
if (sbp->sb_pquotino == 0)
|
|
|
|
sbp->sb_pquotino = NULLFSINO;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to do these manipilations only if we are working
|
|
|
|
* with an older version of on-disk superblock.
|
|
|
|
*/
|
|
|
|
if (xfs_sb_version_has_pquotino(sbp))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (sbp->sb_qflags & XFS_OQUOTA_ENFD)
|
|
|
|
sbp->sb_qflags |= (sbp->sb_qflags & XFS_PQUOTA_ACCT) ?
|
|
|
|
XFS_PQUOTA_ENFD : XFS_GQUOTA_ENFD;
|
|
|
|
if (sbp->sb_qflags & XFS_OQUOTA_CHKD)
|
|
|
|
sbp->sb_qflags |= (sbp->sb_qflags & XFS_PQUOTA_ACCT) ?
|
|
|
|
XFS_PQUOTA_CHKD : XFS_GQUOTA_CHKD;
|
|
|
|
sbp->sb_qflags &= ~(XFS_OQUOTA_ENFD | XFS_OQUOTA_CHKD);
|
|
|
|
|
2016-11-08 08:58:55 +08:00
|
|
|
if (sbp->sb_qflags & XFS_PQUOTA_ACCT &&
|
|
|
|
sbp->sb_gquotino != NULLFSINO) {
|
2013-08-12 18:49:41 +08:00
|
|
|
/*
|
|
|
|
* In older version of superblock, on-disk superblock only
|
|
|
|
* has sb_gquotino, and in-core superblock has both sb_gquotino
|
|
|
|
* and sb_pquotino. But, only one of them is supported at any
|
|
|
|
* point of time. So, if PQUOTA is set in disk superblock,
|
2016-11-08 08:58:55 +08:00
|
|
|
* copy over sb_gquotino to sb_pquotino. The NULLFSINO test
|
|
|
|
* above is to make sure we don't do this twice and wipe them
|
|
|
|
* both out!
|
2013-08-12 18:49:41 +08:00
|
|
|
*/
|
|
|
|
sbp->sb_pquotino = sbp->sb_gquotino;
|
|
|
|
sbp->sb_gquotino = NULLFSINO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-04 09:35:44 +08:00
|
|
|
static void
|
|
|
|
__xfs_sb_from_disk(
|
2013-08-12 18:49:41 +08:00
|
|
|
struct xfs_sb *to,
|
2014-08-04 09:35:44 +08:00
|
|
|
xfs_dsb_t *from,
|
|
|
|
bool convert_xquota)
|
2013-08-12 18:49:41 +08:00
|
|
|
{
|
|
|
|
to->sb_magicnum = be32_to_cpu(from->sb_magicnum);
|
|
|
|
to->sb_blocksize = be32_to_cpu(from->sb_blocksize);
|
|
|
|
to->sb_dblocks = be64_to_cpu(from->sb_dblocks);
|
|
|
|
to->sb_rblocks = be64_to_cpu(from->sb_rblocks);
|
|
|
|
to->sb_rextents = be64_to_cpu(from->sb_rextents);
|
|
|
|
memcpy(&to->sb_uuid, &from->sb_uuid, sizeof(to->sb_uuid));
|
|
|
|
to->sb_logstart = be64_to_cpu(from->sb_logstart);
|
|
|
|
to->sb_rootino = be64_to_cpu(from->sb_rootino);
|
|
|
|
to->sb_rbmino = be64_to_cpu(from->sb_rbmino);
|
|
|
|
to->sb_rsumino = be64_to_cpu(from->sb_rsumino);
|
|
|
|
to->sb_rextsize = be32_to_cpu(from->sb_rextsize);
|
|
|
|
to->sb_agblocks = be32_to_cpu(from->sb_agblocks);
|
|
|
|
to->sb_agcount = be32_to_cpu(from->sb_agcount);
|
|
|
|
to->sb_rbmblocks = be32_to_cpu(from->sb_rbmblocks);
|
|
|
|
to->sb_logblocks = be32_to_cpu(from->sb_logblocks);
|
|
|
|
to->sb_versionnum = be16_to_cpu(from->sb_versionnum);
|
|
|
|
to->sb_sectsize = be16_to_cpu(from->sb_sectsize);
|
|
|
|
to->sb_inodesize = be16_to_cpu(from->sb_inodesize);
|
|
|
|
to->sb_inopblock = be16_to_cpu(from->sb_inopblock);
|
|
|
|
memcpy(&to->sb_fname, &from->sb_fname, sizeof(to->sb_fname));
|
|
|
|
to->sb_blocklog = from->sb_blocklog;
|
|
|
|
to->sb_sectlog = from->sb_sectlog;
|
|
|
|
to->sb_inodelog = from->sb_inodelog;
|
|
|
|
to->sb_inopblog = from->sb_inopblog;
|
|
|
|
to->sb_agblklog = from->sb_agblklog;
|
|
|
|
to->sb_rextslog = from->sb_rextslog;
|
|
|
|
to->sb_inprogress = from->sb_inprogress;
|
|
|
|
to->sb_imax_pct = from->sb_imax_pct;
|
|
|
|
to->sb_icount = be64_to_cpu(from->sb_icount);
|
|
|
|
to->sb_ifree = be64_to_cpu(from->sb_ifree);
|
|
|
|
to->sb_fdblocks = be64_to_cpu(from->sb_fdblocks);
|
|
|
|
to->sb_frextents = be64_to_cpu(from->sb_frextents);
|
|
|
|
to->sb_uquotino = be64_to_cpu(from->sb_uquotino);
|
|
|
|
to->sb_gquotino = be64_to_cpu(from->sb_gquotino);
|
|
|
|
to->sb_qflags = be16_to_cpu(from->sb_qflags);
|
|
|
|
to->sb_flags = from->sb_flags;
|
|
|
|
to->sb_shared_vn = from->sb_shared_vn;
|
|
|
|
to->sb_inoalignmt = be32_to_cpu(from->sb_inoalignmt);
|
|
|
|
to->sb_unit = be32_to_cpu(from->sb_unit);
|
|
|
|
to->sb_width = be32_to_cpu(from->sb_width);
|
|
|
|
to->sb_dirblklog = from->sb_dirblklog;
|
|
|
|
to->sb_logsectlog = from->sb_logsectlog;
|
|
|
|
to->sb_logsectsize = be16_to_cpu(from->sb_logsectsize);
|
|
|
|
to->sb_logsunit = be32_to_cpu(from->sb_logsunit);
|
|
|
|
to->sb_features2 = be32_to_cpu(from->sb_features2);
|
|
|
|
to->sb_bad_features2 = be32_to_cpu(from->sb_bad_features2);
|
|
|
|
to->sb_features_compat = be32_to_cpu(from->sb_features_compat);
|
|
|
|
to->sb_features_ro_compat = be32_to_cpu(from->sb_features_ro_compat);
|
|
|
|
to->sb_features_incompat = be32_to_cpu(from->sb_features_incompat);
|
|
|
|
to->sb_features_log_incompat =
|
|
|
|
be32_to_cpu(from->sb_features_log_incompat);
|
2014-10-02 07:24:11 +08:00
|
|
|
/* crc is only used on disk, not in memory; just init to 0 here. */
|
|
|
|
to->sb_crc = 0;
|
2015-05-29 06:54:03 +08:00
|
|
|
to->sb_spino_align = be32_to_cpu(from->sb_spino_align);
|
2013-08-12 18:49:41 +08:00
|
|
|
to->sb_pquotino = be64_to_cpu(from->sb_pquotino);
|
|
|
|
to->sb_lsn = be64_to_cpu(from->sb_lsn);
|
2015-07-29 09:53:31 +08:00
|
|
|
/*
|
|
|
|
* sb_meta_uuid is only on disk if it differs from sb_uuid and the
|
|
|
|
* feature flag is set; if not set we keep it only in memory.
|
|
|
|
*/
|
|
|
|
if (xfs_sb_version_hasmetauuid(to))
|
|
|
|
uuid_copy(&to->sb_meta_uuid, &from->sb_meta_uuid);
|
|
|
|
else
|
|
|
|
uuid_copy(&to->sb_meta_uuid, &from->sb_uuid);
|
2014-08-04 09:35:44 +08:00
|
|
|
/* Convert on-disk flags to in-memory flags? */
|
|
|
|
if (convert_xquota)
|
|
|
|
xfs_sb_quota_from_disk(to);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_sb_from_disk(
|
|
|
|
struct xfs_sb *to,
|
|
|
|
xfs_dsb_t *from)
|
|
|
|
{
|
|
|
|
__xfs_sb_from_disk(to, from, true);
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
static void
|
2013-08-12 18:49:41 +08:00
|
|
|
xfs_sb_quota_to_disk(
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
struct xfs_dsb *to,
|
|
|
|
struct xfs_sb *from)
|
2013-08-12 18:49:41 +08:00
|
|
|
{
|
2017-06-17 02:00:05 +08:00
|
|
|
uint16_t qflags = from->sb_qflags;
|
2013-08-12 18:49:41 +08:00
|
|
|
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
to->sb_uquotino = cpu_to_be64(from->sb_uquotino);
|
|
|
|
if (xfs_sb_version_has_pquotino(from)) {
|
|
|
|
to->sb_qflags = cpu_to_be16(from->sb_qflags);
|
|
|
|
to->sb_gquotino = cpu_to_be64(from->sb_gquotino);
|
|
|
|
to->sb_pquotino = cpu_to_be64(from->sb_pquotino);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-08-12 18:49:41 +08:00
|
|
|
/*
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
* The in-core version of sb_qflags do not have XFS_OQUOTA_*
|
|
|
|
* flags, whereas the on-disk version does. So, convert incore
|
|
|
|
* XFS_{PG}QUOTA_* flags to on-disk XFS_OQUOTA_* flags.
|
2013-08-12 18:49:41 +08:00
|
|
|
*/
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
qflags &= ~(XFS_PQUOTA_ENFD | XFS_PQUOTA_CHKD |
|
|
|
|
XFS_GQUOTA_ENFD | XFS_GQUOTA_CHKD);
|
2013-08-12 18:49:41 +08:00
|
|
|
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
if (from->sb_qflags &
|
|
|
|
(XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD))
|
|
|
|
qflags |= XFS_OQUOTA_ENFD;
|
|
|
|
if (from->sb_qflags &
|
|
|
|
(XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD))
|
|
|
|
qflags |= XFS_OQUOTA_CHKD;
|
|
|
|
to->sb_qflags = cpu_to_be16(qflags);
|
2013-08-12 18:49:41 +08:00
|
|
|
|
|
|
|
/*
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
* GQUOTINO and PQUOTINO cannot be used together in versions
|
|
|
|
* of superblock that do not have pquotino. from->sb_flags
|
|
|
|
* tells us which quota is active and should be copied to
|
|
|
|
* disk. If neither are active, we should NULL the inode.
|
2014-07-15 05:28:41 +08:00
|
|
|
*
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
* In all cases, the separate pquotino must remain 0 because it
|
|
|
|
* it beyond the "end" of the valid non-pquotino superblock.
|
2013-08-12 18:49:41 +08:00
|
|
|
*/
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
if (from->sb_qflags & XFS_GQUOTA_ACCT)
|
2013-08-12 18:49:41 +08:00
|
|
|
to->sb_gquotino = cpu_to_be64(from->sb_gquotino);
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
else if (from->sb_qflags & XFS_PQUOTA_ACCT)
|
2013-08-12 18:49:41 +08:00
|
|
|
to->sb_gquotino = cpu_to_be64(from->sb_pquotino);
|
2014-07-15 05:28:41 +08:00
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* We can't rely on just the fields being logged to tell us
|
|
|
|
* that it is safe to write NULLFSINO - we should only do that
|
|
|
|
* if quotas are not actually enabled. Hence only write
|
|
|
|
* NULLFSINO if both in-core quota inodes are NULL.
|
|
|
|
*/
|
|
|
|
if (from->sb_gquotino == NULLFSINO &&
|
|
|
|
from->sb_pquotino == NULLFSINO)
|
|
|
|
to->sb_gquotino = cpu_to_be64(NULLFSINO);
|
|
|
|
}
|
2013-08-12 18:49:41 +08:00
|
|
|
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
to->sb_pquotino = 0;
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_sb_to_disk(
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
struct xfs_dsb *to,
|
|
|
|
struct xfs_sb *from)
|
2013-08-12 18:49:41 +08:00
|
|
|
{
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
xfs_sb_quota_to_disk(to, from);
|
|
|
|
|
|
|
|
to->sb_magicnum = cpu_to_be32(from->sb_magicnum);
|
|
|
|
to->sb_blocksize = cpu_to_be32(from->sb_blocksize);
|
|
|
|
to->sb_dblocks = cpu_to_be64(from->sb_dblocks);
|
|
|
|
to->sb_rblocks = cpu_to_be64(from->sb_rblocks);
|
|
|
|
to->sb_rextents = cpu_to_be64(from->sb_rextents);
|
|
|
|
memcpy(&to->sb_uuid, &from->sb_uuid, sizeof(to->sb_uuid));
|
|
|
|
to->sb_logstart = cpu_to_be64(from->sb_logstart);
|
|
|
|
to->sb_rootino = cpu_to_be64(from->sb_rootino);
|
|
|
|
to->sb_rbmino = cpu_to_be64(from->sb_rbmino);
|
|
|
|
to->sb_rsumino = cpu_to_be64(from->sb_rsumino);
|
|
|
|
to->sb_rextsize = cpu_to_be32(from->sb_rextsize);
|
|
|
|
to->sb_agblocks = cpu_to_be32(from->sb_agblocks);
|
|
|
|
to->sb_agcount = cpu_to_be32(from->sb_agcount);
|
|
|
|
to->sb_rbmblocks = cpu_to_be32(from->sb_rbmblocks);
|
|
|
|
to->sb_logblocks = cpu_to_be32(from->sb_logblocks);
|
|
|
|
to->sb_versionnum = cpu_to_be16(from->sb_versionnum);
|
|
|
|
to->sb_sectsize = cpu_to_be16(from->sb_sectsize);
|
|
|
|
to->sb_inodesize = cpu_to_be16(from->sb_inodesize);
|
|
|
|
to->sb_inopblock = cpu_to_be16(from->sb_inopblock);
|
|
|
|
memcpy(&to->sb_fname, &from->sb_fname, sizeof(to->sb_fname));
|
|
|
|
to->sb_blocklog = from->sb_blocklog;
|
|
|
|
to->sb_sectlog = from->sb_sectlog;
|
|
|
|
to->sb_inodelog = from->sb_inodelog;
|
|
|
|
to->sb_inopblog = from->sb_inopblog;
|
|
|
|
to->sb_agblklog = from->sb_agblklog;
|
|
|
|
to->sb_rextslog = from->sb_rextslog;
|
|
|
|
to->sb_inprogress = from->sb_inprogress;
|
|
|
|
to->sb_imax_pct = from->sb_imax_pct;
|
|
|
|
to->sb_icount = cpu_to_be64(from->sb_icount);
|
|
|
|
to->sb_ifree = cpu_to_be64(from->sb_ifree);
|
|
|
|
to->sb_fdblocks = cpu_to_be64(from->sb_fdblocks);
|
|
|
|
to->sb_frextents = cpu_to_be64(from->sb_frextents);
|
2013-08-12 18:49:41 +08:00
|
|
|
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
to->sb_flags = from->sb_flags;
|
|
|
|
to->sb_shared_vn = from->sb_shared_vn;
|
|
|
|
to->sb_inoalignmt = cpu_to_be32(from->sb_inoalignmt);
|
|
|
|
to->sb_unit = cpu_to_be32(from->sb_unit);
|
|
|
|
to->sb_width = cpu_to_be32(from->sb_width);
|
|
|
|
to->sb_dirblklog = from->sb_dirblklog;
|
|
|
|
to->sb_logsectlog = from->sb_logsectlog;
|
|
|
|
to->sb_logsectsize = cpu_to_be16(from->sb_logsectsize);
|
|
|
|
to->sb_logsunit = cpu_to_be32(from->sb_logsunit);
|
2015-01-22 06:10:33 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to ensure that bad_features2 always matches features2.
|
|
|
|
* Hence we enforce that here rather than having to remember to do it
|
|
|
|
* everywhere else that updates features2.
|
|
|
|
*/
|
|
|
|
from->sb_bad_features2 = from->sb_features2;
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
to->sb_features2 = cpu_to_be32(from->sb_features2);
|
|
|
|
to->sb_bad_features2 = cpu_to_be32(from->sb_bad_features2);
|
|
|
|
|
|
|
|
if (xfs_sb_version_hascrc(from)) {
|
|
|
|
to->sb_features_compat = cpu_to_be32(from->sb_features_compat);
|
|
|
|
to->sb_features_ro_compat =
|
|
|
|
cpu_to_be32(from->sb_features_ro_compat);
|
|
|
|
to->sb_features_incompat =
|
|
|
|
cpu_to_be32(from->sb_features_incompat);
|
|
|
|
to->sb_features_log_incompat =
|
|
|
|
cpu_to_be32(from->sb_features_log_incompat);
|
2015-05-29 06:54:03 +08:00
|
|
|
to->sb_spino_align = cpu_to_be32(from->sb_spino_align);
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
to->sb_lsn = cpu_to_be64(from->sb_lsn);
|
2015-07-29 09:53:31 +08:00
|
|
|
if (xfs_sb_version_hasmetauuid(from))
|
|
|
|
uuid_copy(&to->sb_meta_uuid, &from->sb_meta_uuid);
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xfs_sb_verify(
|
|
|
|
struct xfs_buf *bp,
|
|
|
|
bool check_version)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = bp->b_target->bt_mount;
|
|
|
|
struct xfs_sb sb;
|
|
|
|
|
2014-08-04 09:35:44 +08:00
|
|
|
/*
|
|
|
|
* Use call variant which doesn't convert quota flags from disk
|
|
|
|
* format, because xfs_mount_validate_sb checks the on-disk flags.
|
|
|
|
*/
|
|
|
|
__xfs_sb_from_disk(&sb, XFS_BUF_TO_SBP(bp), false);
|
2013-08-12 18:49:41 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Only check the in progress field for the primary superblock as
|
|
|
|
* mkfs.xfs doesn't clear it from secondary superblocks.
|
|
|
|
*/
|
2016-08-26 14:01:30 +08:00
|
|
|
return xfs_mount_validate_sb(mp, &sb,
|
|
|
|
bp->b_maps[0].bm_bn == XFS_SB_DADDR,
|
2013-08-12 18:49:41 +08:00
|
|
|
check_version);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the superblock has the CRC feature bit set or the CRC field is non-null,
|
|
|
|
* check that the CRC is valid. We check the CRC field is non-null because a
|
|
|
|
* single bit error could clear the feature bit and unused parts of the
|
|
|
|
* superblock are supposed to be zero. Hence a non-null crc field indicates that
|
|
|
|
* we've potentially lost a feature bit and we should check it anyway.
|
2013-09-10 04:33:29 +08:00
|
|
|
*
|
|
|
|
* However, past bugs (i.e. in growfs) left non-zeroed regions beyond the
|
|
|
|
* last field in V4 secondary superblocks. So for secondary superblocks,
|
|
|
|
* we are more forgiving, and ignore CRC failures if the primary doesn't
|
|
|
|
* indicate that the fs version is V5.
|
2013-08-12 18:49:41 +08:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
xfs_sb_read_verify(
|
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = bp->b_target->bt_mount;
|
|
|
|
struct xfs_dsb *dsb = XFS_BUF_TO_SBP(bp);
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* open code the version check to avoid needing to convert the entire
|
|
|
|
* superblock from disk order just to check the version number
|
|
|
|
*/
|
|
|
|
if (dsb->sb_magicnum == cpu_to_be32(XFS_SB_MAGIC) &&
|
|
|
|
(((be16_to_cpu(dsb->sb_versionnum) & XFS_SB_VERSION_NUMBITS) ==
|
|
|
|
XFS_SB_VERSION_5) ||
|
|
|
|
dsb->sb_crc != 0)) {
|
|
|
|
|
2014-02-27 12:17:27 +08:00
|
|
|
if (!xfs_buf_verify_cksum(bp, XFS_SB_CRC_OFF)) {
|
2013-09-10 04:33:29 +08:00
|
|
|
/* Only fail bad secondaries on a known V5 filesystem */
|
2014-02-19 12:33:05 +08:00
|
|
|
if (bp->b_bn == XFS_SB_DADDR ||
|
2013-09-10 04:33:29 +08:00
|
|
|
xfs_sb_version_hascrc(&mp->m_sb)) {
|
2014-06-25 12:58:08 +08:00
|
|
|
error = -EFSBADCRC;
|
2013-09-10 04:33:29 +08:00
|
|
|
goto out_error;
|
|
|
|
}
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
error = xfs_sb_verify(bp, true);
|
|
|
|
|
|
|
|
out_error:
|
2018-01-09 02:51:02 +08:00
|
|
|
if (error == -EFSCORRUPTED || error == -EFSBADCRC)
|
2018-01-09 02:51:03 +08:00
|
|
|
xfs_verifier_error(bp, error, __this_address);
|
2018-01-09 02:51:02 +08:00
|
|
|
else if (error)
|
2013-08-12 18:49:41 +08:00
|
|
|
xfs_buf_ioerror(bp, error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We may be probed for a filesystem match, so we may not want to emit
|
|
|
|
* messages when the superblock buffer is not actually an XFS superblock.
|
2013-08-12 11:15:02 +08:00
|
|
|
* If we find an XFS superblock, then run a normal, noisy mount because we are
|
2013-08-12 18:49:41 +08:00
|
|
|
* really going to mount it and want to know about errors.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
xfs_sb_quiet_read_verify(
|
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
|
|
|
struct xfs_dsb *dsb = XFS_BUF_TO_SBP(bp);
|
|
|
|
|
|
|
|
if (dsb->sb_magicnum == cpu_to_be32(XFS_SB_MAGIC)) {
|
|
|
|
/* XFS filesystem, verify noisily! */
|
|
|
|
xfs_sb_read_verify(bp);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* quietly fail */
|
2014-06-25 12:58:08 +08:00
|
|
|
xfs_buf_ioerror(bp, -EWRONGFS);
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xfs_sb_write_verify(
|
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = bp->b_target->bt_mount;
|
|
|
|
struct xfs_buf_log_item *bip = bp->b_fspriv;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = xfs_sb_verify(bp, false);
|
|
|
|
if (error) {
|
2018-01-09 02:51:03 +08:00
|
|
|
xfs_verifier_error(bp, error, __this_address);
|
2013-08-12 18:49:41 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!xfs_sb_version_hascrc(&mp->m_sb))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (bip)
|
|
|
|
XFS_BUF_TO_SBP(bp)->sb_lsn = cpu_to_be64(bip->bli_item.li_lsn);
|
|
|
|
|
2014-02-27 12:18:23 +08:00
|
|
|
xfs_buf_update_cksum(bp, XFS_SB_CRC_OFF);
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const struct xfs_buf_ops xfs_sb_buf_ops = {
|
2016-01-04 13:10:19 +08:00
|
|
|
.name = "xfs_sb",
|
2013-08-12 18:49:41 +08:00
|
|
|
.verify_read = xfs_sb_read_verify,
|
|
|
|
.verify_write = xfs_sb_write_verify,
|
|
|
|
};
|
|
|
|
|
|
|
|
const struct xfs_buf_ops xfs_sb_quiet_buf_ops = {
|
2016-01-04 13:10:19 +08:00
|
|
|
.name = "xfs_sb_quiet",
|
2013-08-12 18:49:41 +08:00
|
|
|
.verify_read = xfs_sb_quiet_read_verify,
|
|
|
|
.verify_write = xfs_sb_write_verify,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xfs_mount_common
|
|
|
|
*
|
|
|
|
* Mount initialization code establishing various mount
|
|
|
|
* fields from the superblock associated with the given
|
|
|
|
* mount structure
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_sb_mount_common(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_sb *sbp)
|
|
|
|
{
|
|
|
|
mp->m_agfrotor = mp->m_agirotor = 0;
|
|
|
|
spin_lock_init(&mp->m_agirotor_lock);
|
|
|
|
mp->m_maxagi = mp->m_sb.sb_agcount;
|
|
|
|
mp->m_blkbit_log = sbp->sb_blocklog + XFS_NBBYLOG;
|
|
|
|
mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT;
|
|
|
|
mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT;
|
|
|
|
mp->m_agno_log = xfs_highbit32(sbp->sb_agcount - 1) + 1;
|
|
|
|
mp->m_agino_log = sbp->sb_inopblog + sbp->sb_agblklog;
|
|
|
|
mp->m_blockmask = sbp->sb_blocksize - 1;
|
|
|
|
mp->m_blockwsize = sbp->sb_blocksize >> XFS_WORDLOG;
|
|
|
|
mp->m_blockwmask = mp->m_blockwsize - 1;
|
|
|
|
|
|
|
|
mp->m_alloc_mxr[0] = xfs_allocbt_maxrecs(mp, sbp->sb_blocksize, 1);
|
|
|
|
mp->m_alloc_mxr[1] = xfs_allocbt_maxrecs(mp, sbp->sb_blocksize, 0);
|
|
|
|
mp->m_alloc_mnr[0] = mp->m_alloc_mxr[0] / 2;
|
|
|
|
mp->m_alloc_mnr[1] = mp->m_alloc_mxr[1] / 2;
|
|
|
|
|
|
|
|
mp->m_inobt_mxr[0] = xfs_inobt_maxrecs(mp, sbp->sb_blocksize, 1);
|
|
|
|
mp->m_inobt_mxr[1] = xfs_inobt_maxrecs(mp, sbp->sb_blocksize, 0);
|
|
|
|
mp->m_inobt_mnr[0] = mp->m_inobt_mxr[0] / 2;
|
|
|
|
mp->m_inobt_mnr[1] = mp->m_inobt_mxr[1] / 2;
|
|
|
|
|
|
|
|
mp->m_bmap_dmxr[0] = xfs_bmbt_maxrecs(mp, sbp->sb_blocksize, 1);
|
|
|
|
mp->m_bmap_dmxr[1] = xfs_bmbt_maxrecs(mp, sbp->sb_blocksize, 0);
|
|
|
|
mp->m_bmap_dmnr[0] = mp->m_bmap_dmxr[0] / 2;
|
|
|
|
mp->m_bmap_dmnr[1] = mp->m_bmap_dmxr[1] / 2;
|
|
|
|
|
2016-08-03 09:36:07 +08:00
|
|
|
mp->m_rmap_mxr[0] = xfs_rmapbt_maxrecs(mp, sbp->sb_blocksize, 1);
|
|
|
|
mp->m_rmap_mxr[1] = xfs_rmapbt_maxrecs(mp, sbp->sb_blocksize, 0);
|
|
|
|
mp->m_rmap_mnr[0] = mp->m_rmap_mxr[0] / 2;
|
|
|
|
mp->m_rmap_mnr[1] = mp->m_rmap_mxr[1] / 2;
|
|
|
|
|
2016-10-04 00:11:18 +08:00
|
|
|
mp->m_refc_mxr[0] = xfs_refcountbt_maxrecs(mp, sbp->sb_blocksize,
|
|
|
|
true);
|
|
|
|
mp->m_refc_mxr[1] = xfs_refcountbt_maxrecs(mp, sbp->sb_blocksize,
|
|
|
|
false);
|
|
|
|
mp->m_refc_mnr[0] = mp->m_refc_mxr[0] / 2;
|
|
|
|
mp->m_refc_mnr[1] = mp->m_refc_mxr[1] / 2;
|
|
|
|
|
2013-08-12 18:49:41 +08:00
|
|
|
mp->m_bsize = XFS_FSB_TO_BB(mp, 1);
|
2017-06-17 02:00:05 +08:00
|
|
|
mp->m_ialloc_inos = (int)MAX((uint16_t)XFS_INODES_PER_CHUNK,
|
2013-08-12 18:49:41 +08:00
|
|
|
sbp->sb_inopblock);
|
|
|
|
mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog;
|
2015-05-29 06:55:20 +08:00
|
|
|
|
|
|
|
if (sbp->sb_spino_align)
|
|
|
|
mp->m_ialloc_min_blks = sbp->sb_spino_align;
|
|
|
|
else
|
|
|
|
mp->m_ialloc_min_blks = mp->m_ialloc_blks;
|
2016-08-03 09:38:24 +08:00
|
|
|
mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
|
|
|
|
mp->m_ag_max_usable = xfs_alloc_ag_max_usable(mp);
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xfs_initialize_perag_data
|
|
|
|
*
|
|
|
|
* Read in each per-ag structure so we can count up the number of
|
|
|
|
* allocated inodes, free inodes and used filesystem blocks as this
|
|
|
|
* information is no longer persistent in the superblock. Once we have
|
|
|
|
* this information, write it into the in-core superblock structure.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_initialize_perag_data(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_agnumber_t agcount)
|
|
|
|
{
|
|
|
|
xfs_agnumber_t index;
|
|
|
|
xfs_perag_t *pag;
|
|
|
|
xfs_sb_t *sbp = &mp->m_sb;
|
|
|
|
uint64_t ifree = 0;
|
|
|
|
uint64_t ialloc = 0;
|
|
|
|
uint64_t bfree = 0;
|
|
|
|
uint64_t bfreelst = 0;
|
|
|
|
uint64_t btree = 0;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
for (index = 0; index < agcount; index++) {
|
|
|
|
/*
|
|
|
|
* read the agf, then the agi. This gets us
|
|
|
|
* all the information we need and populates the
|
|
|
|
* per-ag structures for us.
|
|
|
|
*/
|
|
|
|
error = xfs_alloc_pagf_init(mp, NULL, index, 0);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
error = xfs_ialloc_pagi_init(mp, NULL, index);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
pag = xfs_perag_get(mp, index);
|
|
|
|
ifree += pag->pagi_freecount;
|
|
|
|
ialloc += pag->pagi_count;
|
|
|
|
bfree += pag->pagf_freeblks;
|
|
|
|
bfreelst += pag->pagf_flcount;
|
|
|
|
btree += pag->pagf_btreeblks;
|
|
|
|
xfs_perag_put(pag);
|
|
|
|
}
|
2015-02-23 18:22:31 +08:00
|
|
|
|
|
|
|
/* Overwrite incore superblock counters with just-read data */
|
2013-08-12 18:49:41 +08:00
|
|
|
spin_lock(&mp->m_sb_lock);
|
|
|
|
sbp->sb_ifree = ifree;
|
|
|
|
sbp->sb_icount = ialloc;
|
|
|
|
sbp->sb_fdblocks = bfree + bfreelst + btree;
|
|
|
|
spin_unlock(&mp->m_sb_lock);
|
|
|
|
|
2015-02-23 18:22:31 +08:00
|
|
|
xfs_reinit_percpu_counters(mp);
|
2013-08-12 18:49:41 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-01-22 06:10:31 +08:00
|
|
|
* xfs_log_sb() can be used to copy arbitrary changes to the in-core superblock
|
|
|
|
* into the superblock buffer to be logged. It does not provide the higher
|
|
|
|
* level of locking that is needed to protect the in-core superblock from
|
|
|
|
* concurrent access.
|
2013-08-12 18:49:41 +08:00
|
|
|
*/
|
|
|
|
void
|
2015-01-22 06:10:31 +08:00
|
|
|
xfs_log_sb(
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
struct xfs_trans *tp)
|
2013-08-12 18:49:41 +08:00
|
|
|
{
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
struct xfs_buf *bp = xfs_trans_getsb(tp, mp, 0);
|
2013-08-12 18:49:41 +08:00
|
|
|
|
2015-02-23 18:19:28 +08:00
|
|
|
mp->m_sb.sb_icount = percpu_counter_sum(&mp->m_icount);
|
2015-02-23 18:19:53 +08:00
|
|
|
mp->m_sb.sb_ifree = percpu_counter_sum(&mp->m_ifree);
|
2015-02-23 18:22:03 +08:00
|
|
|
mp->m_sb.sb_fdblocks = percpu_counter_sum(&mp->m_fdblocks);
|
2015-02-23 18:19:28 +08:00
|
|
|
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb);
|
2013-08-12 18:49:41 +08:00
|
|
|
xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-22 06:10:26 +08:00
|
|
|
xfs_trans_log_buf(tp, bp, 0, sizeof(struct xfs_dsb));
|
2013-08-12 18:49:41 +08:00
|
|
|
}
|
2015-01-22 06:10:31 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* xfs_sync_sb
|
|
|
|
*
|
|
|
|
* Sync the superblock to disk.
|
|
|
|
*
|
|
|
|
* Note that the caller is responsible for checking the frozen state of the
|
|
|
|
* filesystem. This procedure uses the non-blocking transaction allocator and
|
|
|
|
* thus will allow modifications to a frozen fs. This is required because this
|
|
|
|
* code can be called during the process of freezing where use of the high-level
|
|
|
|
* allocator would deadlock.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_sync_sb(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
bool wait)
|
|
|
|
{
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
int error;
|
|
|
|
|
2016-04-06 07:19:55 +08:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_sb, 0, 0,
|
|
|
|
XFS_TRANS_NO_WRITECOUNT, &tp);
|
|
|
|
if (error)
|
2015-01-22 06:10:31 +08:00
|
|
|
return error;
|
|
|
|
|
|
|
|
xfs_log_sb(tp);
|
|
|
|
if (wait)
|
|
|
|
xfs_trans_set_sync(tp);
|
2015-06-04 11:48:08 +08:00
|
|
|
return xfs_trans_commit(tp);
|
2015-01-22 06:10:31 +08:00
|
|
|
}
|
2018-01-09 02:51:27 +08:00
|
|
|
|
|
|
|
int
|
|
|
|
xfs_fs_geometry(
|
2018-01-09 02:51:27 +08:00
|
|
|
struct xfs_sb *sbp,
|
|
|
|
struct xfs_fsop_geom *geo,
|
|
|
|
int struct_version)
|
2018-01-09 02:51:27 +08:00
|
|
|
{
|
2018-01-09 02:51:27 +08:00
|
|
|
memset(geo, 0, sizeof(struct xfs_fsop_geom));
|
|
|
|
|
|
|
|
geo->blocksize = sbp->sb_blocksize;
|
|
|
|
geo->rtextsize = sbp->sb_rextsize;
|
|
|
|
geo->agblocks = sbp->sb_agblocks;
|
|
|
|
geo->agcount = sbp->sb_agcount;
|
|
|
|
geo->logblocks = sbp->sb_logblocks;
|
|
|
|
geo->sectsize = sbp->sb_sectsize;
|
|
|
|
geo->inodesize = sbp->sb_inodesize;
|
|
|
|
geo->imaxpct = sbp->sb_imax_pct;
|
|
|
|
geo->datablocks = sbp->sb_dblocks;
|
|
|
|
geo->rtblocks = sbp->sb_rblocks;
|
|
|
|
geo->rtextents = sbp->sb_rextents;
|
|
|
|
geo->logstart = sbp->sb_logstart;
|
|
|
|
BUILD_BUG_ON(sizeof(geo->uuid) != sizeof(sbp->sb_uuid));
|
|
|
|
memcpy(geo->uuid, &sbp->sb_uuid, sizeof(sbp->sb_uuid));
|
|
|
|
|
|
|
|
if (struct_version < 2)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
geo->sunit = sbp->sb_unit;
|
|
|
|
geo->swidth = sbp->sb_width;
|
|
|
|
|
|
|
|
if (struct_version < 3)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
geo->version = XFS_FSOP_GEOM_VERSION;
|
|
|
|
geo->flags = XFS_FSOP_GEOM_FLAGS_NLINK |
|
|
|
|
XFS_FSOP_GEOM_FLAGS_DIRV2;
|
|
|
|
if (xfs_sb_version_hasattr(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_ATTR;
|
|
|
|
if (xfs_sb_version_hasquota(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_QUOTA;
|
|
|
|
if (xfs_sb_version_hasalign(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_IALIGN;
|
|
|
|
if (xfs_sb_version_hasdalign(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_DALIGN;
|
|
|
|
if (xfs_sb_version_hasextflgbit(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_EXTFLG;
|
|
|
|
if (xfs_sb_version_hassector(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_SECTOR;
|
|
|
|
if (xfs_sb_version_hasasciici(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_DIRV2CI;
|
|
|
|
if (xfs_sb_version_haslazysbcount(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_LAZYSB;
|
|
|
|
if (xfs_sb_version_hasattr2(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_ATTR2;
|
|
|
|
if (xfs_sb_version_hasprojid32bit(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_PROJID32;
|
|
|
|
if (xfs_sb_version_hascrc(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_V5SB;
|
|
|
|
if (xfs_sb_version_hasftype(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_FTYPE;
|
|
|
|
if (xfs_sb_version_hasfinobt(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_FINOBT;
|
|
|
|
if (xfs_sb_version_hassparseinodes(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_SPINODES;
|
|
|
|
if (xfs_sb_version_hasrmapbt(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_RMAPBT;
|
|
|
|
if (xfs_sb_version_hasreflink(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_REFLINK;
|
|
|
|
if (xfs_sb_version_hassector(sbp))
|
|
|
|
geo->logsectsize = sbp->sb_logsectsize;
|
|
|
|
else
|
|
|
|
geo->logsectsize = BBSIZE;
|
|
|
|
geo->rtsectsize = sbp->sb_blocksize;
|
|
|
|
geo->dirblocksize = xfs_dir2_dirblock_bytes(sbp);
|
|
|
|
|
|
|
|
if (struct_version < 3)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (xfs_sb_version_haslogv2(sbp))
|
|
|
|
geo->flags |= XFS_FSOP_GEOM_FLAGS_LOGV2;
|
|
|
|
|
|
|
|
geo->logsunit = sbp->sb_logsunit;
|
2018-01-09 02:51:27 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|