@@ -2388,12 +2388,12 @@ xfs_imap(
* driver.
*/
if ((imap->im_blkno + imap->im_len) >
- XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)) {
+ XFS_FSB_TO_BB(mp, mp->m_LBA_size)) {
xfs_alert(mp,
- "%s: (im_blkno (0x%llx) + im_len (0x%llx)) > sb_dblocks (0x%llx)",
+ "%s: (im_blkno (0x%llx) + im_len (0x%llx)) > device size (0x%llx)",
__func__, (unsigned long long) imap->im_blkno,
(unsigned long long) imap->im_len,
- XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks));
+ XFS_FSB_TO_BB(mp, mp->m_LBA_size));
return -EINVAL;
}
return 0;
@@ -728,6 +728,12 @@ xfs_sb_mount_common(
mp->m_blockwsize = sbp->sb_blocksize >> XFS_WORDLOG;
mp->m_blockwmask = mp->m_blockwsize - 1;
+ /*
+ * Set up the filesystem size and addressing limits
+ */
+ mp->m_LBA_size = sbp->sb_dblocks;
+ mp->m_usable_blocks = sbp->sb_dblocks;
+
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;
@@ -39,7 +39,7 @@ xfs_ag_block_count(
if (agno < mp->m_sb.sb_agcount - 1)
return mp->m_sb.sb_agblocks;
- return mp->m_sb.sb_dblocks - (agno * mp->m_sb.sb_agblocks);
+ return mp->m_LBA_size - (agno * mp->m_sb.sb_agblocks);
}
/*
@@ -435,12 +435,11 @@ xfs_bui_recover(
op_ok = false;
break;
}
- if (!op_ok || startblock_fsb == 0 ||
+ if (!op_ok ||
+ !xfs_verify_fsbno(mp, startblock_fsb) ||
+ !xfs_verify_fsbno(mp, inode_fsb) ||
bmap->me_len == 0 ||
- inode_fsb == 0 ||
- startblock_fsb >= mp->m_sb.sb_dblocks ||
bmap->me_len >= mp->m_sb.sb_agblocks ||
- inode_fsb >= mp->m_sb.sb_dblocks ||
(bmap->me_flags & ~XFS_BMAP_EXTENT_FLAGS)) {
/*
* This will pull the BUI from the AIL and
@@ -575,7 +575,7 @@ _xfs_buf_find(
* Corrupted block numbers can get through to here, unfortunately, so we
* have to check that the buffer falls within the filesystem bounds.
*/
- eofs = XFS_FSB_TO_BB(btp->bt_mount, btp->bt_mount->m_sb.sb_dblocks);
+ eofs = XFS_FSB_TO_BB(btp->bt_mount, btp->bt_mount->m_LBA_size);
if (cmap.bm_bn < 0 || cmap.bm_bn >= eofs) {
/*
* XXX (dgc): we should really be returning -EFSCORRUPTED here,
@@ -183,7 +183,7 @@ xfs_ioc_trim(
* used by the fstrim application. In the end it really doesn't
* matter as trimming blocks is an advisory interface.
*/
- if (range.start >= XFS_FSB_TO_B(mp, mp->m_sb.sb_dblocks) ||
+ if (range.start >= XFS_FSB_TO_B(mp, mp->m_LBA_size) ||
range.minlen > XFS_FSB_TO_B(mp, mp->m_ag_max_usable) ||
range.len < mp->m_sb.sb_blocksize)
return -EINVAL;
@@ -192,8 +192,8 @@ xfs_ioc_trim(
end = start + BTOBBT(range.len) - 1;
minlen = BTOBB(max_t(u64, granularity, range.minlen));
- if (end > XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks) - 1)
- end = XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)- 1;
+ if (end > XFS_FSB_TO_BB(mp, mp->m_LBA_size) - 1)
+ end = XFS_FSB_TO_BB(mp, mp->m_LBA_size)- 1;
start_agno = xfs_daddr_to_agno(mp, start);
end_agno = xfs_daddr_to_agno(mp, end);
@@ -519,9 +519,8 @@ xfs_efi_recover(
extp = &efip->efi_format.efi_extents[i];
startblock_fsb = XFS_BB_TO_FSB(mp,
XFS_FSB_TO_DADDR(mp, extp->ext_start));
- if (startblock_fsb == 0 ||
+ if (!xfs_verify_fsbno(mp, startblock_fsb) ||
extp->ext_len == 0 ||
- startblock_fsb >= mp->m_sb.sb_dblocks ||
extp->ext_len >= mp->m_sb.sb_agblocks) {
/*
* This will pull the EFI from the AIL and
@@ -585,7 +585,7 @@ __xfs_getfsmap_datadev(
xfs_daddr_t eofs;
int error = 0;
- eofs = XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
+ eofs = XFS_FSB_TO_BB(mp, mp->m_LBA_size);
if (keys[0].fmr_physical >= eofs)
return 0;
if (keys[1].fmr_physical >= eofs)
@@ -66,7 +66,7 @@ xfs_fs_geometry(
geo->sectsize = mp->m_sb.sb_sectsize;
geo->inodesize = mp->m_sb.sb_inodesize;
geo->imaxpct = mp->m_sb.sb_imax_pct;
- geo->datablocks = mp->m_sb.sb_dblocks;
+ geo->datablocks = mp->m_LBA_size;
geo->rtblocks = mp->m_sb.sb_rblocks;
geo->rtextents = mp->m_sb.sb_rextents;
geo->logstart = mp->m_sb.sb_logstart;
@@ -513,7 +513,7 @@ xfs_growfs_data_private(
struct aghdr_init_data id = {};
nb = in->newblocks;
- if (nb < mp->m_sb.sb_dblocks)
+ if (nb < mp->m_LBA_size)
return -EINVAL;
if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
return error;
@@ -530,10 +530,10 @@ xfs_growfs_data_private(
if (nb_mod && nb_mod < XFS_MIN_AG_BLOCKS) {
nagcount--;
nb = (xfs_rfsblock_t)nagcount * mp->m_sb.sb_agblocks;
- if (nb < mp->m_sb.sb_dblocks)
+ if (nb < mp->m_LBA_size)
return -EINVAL;
}
- new = nb - mp->m_sb.sb_dblocks;
+ new = nb - mp->m_LBA_size;
oagcount = mp->m_sb.sb_agcount;
/* allocate the new per-ag structures */
@@ -640,9 +640,9 @@ xfs_growfs_data_private(
*/
if (nagcount > oagcount)
xfs_trans_mod_sb(tp, XFS_TRANS_SB_AGCOUNT, nagcount - oagcount);
- if (nb > mp->m_sb.sb_dblocks)
+ if (nb > mp->m_LBA_size)
xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS,
- nb - mp->m_sb.sb_dblocks);
+ nb - mp->m_LBA_size);
if (id.nfree)
xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, id.nfree);
xfs_trans_set_sync(tp);
@@ -651,6 +651,9 @@ xfs_growfs_data_private(
return error;
/* New allocation groups fully initialized, so update mount struct */
+ mp->m_usable_blocks = mp->m_sb.sb_dblocks;
+ mp->m_LBA_size = mp->m_sb.sb_dblocks;
+
if (nagimax)
mp->m_maxagi = nagimax;
xfs_set_low_space_thresholds(mp);
@@ -821,7 +824,7 @@ xfs_growfs_data(
* Post growfs calculations needed to reflect new state in operations
*/
if (mp->m_sb.sb_imax_pct) {
- uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
+ uint64_t icount = mp->m_usable_blocks * mp->m_sb.sb_imax_pct;
do_div(icount, 100);
mp->m_maxicount = icount << mp->m_sb.sb_inopblog;
} else
@@ -432,17 +432,18 @@ xfs_update_alignment(xfs_mount_t *mp)
* Set the maximum inode count for this filesystem
*/
STATIC void
-xfs_set_maxicount(xfs_mount_t *mp)
+xfs_set_maxicount(
+ struct xfs_mount *mp)
{
- xfs_sb_t *sbp = &(mp->m_sb);
- uint64_t icount;
+ struct xfs_sb *sbp = &mp->m_sb;
+ uint64_t icount;
if (sbp->sb_imax_pct) {
/*
* Make sure the maximum inode count is a multiple
* of the units we allocate inodes in.
*/
- icount = sbp->sb_dblocks * sbp->sb_imax_pct;
+ icount = mp->m_usable_blocks * sbp->sb_imax_pct;
do_div(icount, 100);
do_div(icount, mp->m_ialloc_blks);
mp->m_maxicount = (icount * mp->m_ialloc_blks) <<
@@ -501,7 +502,7 @@ xfs_set_low_space_thresholds(
int i;
for (i = 0; i < XFS_LOWSP_MAX; i++) {
- uint64_t space = mp->m_sb.sb_dblocks;
+ uint64_t space = mp->m_usable_blocks;
do_div(space, 100);
mp->m_low_space[i] = space * (i + 1);
@@ -542,8 +543,8 @@ xfs_check_sizes(
xfs_daddr_t d;
int error;
- d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
- if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
+ d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_LBA_size);
+ if (XFS_BB_TO_FSB(mp, d) != mp->m_LBA_size) {
xfs_warn(mp, "filesystem size mismatch detected");
return -EFBIG;
}
@@ -609,7 +610,7 @@ xfs_default_resblks(xfs_mount_t *mp)
* block reservation. Hence by default we cover roughly 2000 concurrent
* allocation reservations.
*/
- resblks = mp->m_sb.sb_dblocks;
+ resblks = mp->m_usable_blocks;
do_div(resblks, 20);
resblks = min_t(uint64_t, resblks, 8192);
return resblks;
@@ -79,6 +79,8 @@ typedef struct xfs_mount {
struct percpu_counter m_icount; /* allocated inodes counter */
struct percpu_counter m_ifree; /* free inodes counter */
struct percpu_counter m_fdblocks; /* free block counter */
+ xfs_rfsblock_t m_LBA_size; /* device address space size */
+ xfs_rfsblock_t m_usable_blocks; /* max allocatable fs space */
struct xfs_buf *m_sb_bp; /* buffer for superblock */
char *m_fsname; /* filesystem name */
@@ -434,9 +434,9 @@ xfs_cui_recover(
op_ok = false;
break;
}
- if (!op_ok || startblock_fsb == 0 ||
+ if (!op_ok ||
+ !xfs_verify_fsbno(mp, startblock_fsb) ||
refc->pe_len == 0 ||
- startblock_fsb >= mp->m_sb.sb_dblocks ||
refc->pe_len >= mp->m_sb.sb_agblocks ||
(refc->pe_flags & ~XFS_REFCOUNT_EXTENT_FLAGS)) {
/*
@@ -455,9 +455,9 @@ xfs_rui_recover(
op_ok = false;
break;
}
- if (!op_ok || startblock_fsb == 0 ||
+ if (!op_ok ||
+ !xfs_verify_fsbno(mp, startblock_fsb) ||
rmap->me_len == 0 ||
- startblock_fsb >= mp->m_sb.sb_dblocks ||
rmap->me_len >= mp->m_sb.sb_agblocks ||
(rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS)) {
/*
@@ -624,7 +624,7 @@ xfs_set_inode_alloc(
if (mp->m_maxicount) {
uint64_t icount;
- icount = sbp->sb_dblocks * sbp->sb_imax_pct;
+ icount = mp->m_usable_blocks * sbp->sb_imax_pct;
do_div(icount, 100);
icount += sbp->sb_agblocks - 1;
do_div(icount, sbp->sb_agblocks);
@@ -1126,7 +1126,7 @@ xfs_fs_statfs(
spin_lock(&mp->m_sb_lock);
statp->f_bsize = sbp->sb_blocksize;
lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0;
- statp->f_blocks = sbp->sb_dblocks - lsize;
+ statp->f_blocks = mp->m_usable_blocks - lsize;
spin_unlock(&mp->m_sb_lock);
statp->f_bfree = fdblocks - mp->m_alloc_set_aside;