UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

xfs: require 64-bit sector_t 

Trying to support tiny disks only and saving a bit memory might have
made sense on an SGI O2 15 years ago, but is pretty pointless today.

Remove the rarely tested codepath that uses various smaller in-memory
types to reduce our test matrix and make the codebase a little bit
smaller and less complicated.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
This commit is contained in:
Christoph Hellwig 2014-07-30 09:12:05 +10:00 committed by Dave Chinner
parent 74dc93a908
commit d5cf09bace
20 changed files with 50 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
fs/xfs/Kconfig
View File

@ -1,6 +1,7 @@
config XFS_FS config XFS_FS
tristate "XFS filesystem support" tristate "XFS filesystem support"
depends on BLOCK depends on BLOCK
depends on (64BIT || LBDAF)
select EXPORTFS select EXPORTFS
select LIBCRC32C select LIBCRC32C
help help

8
fs/xfs/libxfs/xfs_bmap.c
View File

@ -392,7 +392,7 @@ xfs_bmap_check_leaf_extents(
pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
bno = be64_to_cpu(*pp); bno = be64_to_cpu(*pp);
ASSERT(bno != NULLDFSBNO); ASSERT(bno != NULLFSBLOCK);
ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount); ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks); ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);
@ -1299,7 +1299,7 @@ xfs_bmap_read_extents(
ASSERT(level > 0); ASSERT(level > 0);
pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
bno = be64_to_cpu(*pp); bno = be64_to_cpu(*pp);
ASSERT(bno != NULLDFSBNO); ASSERT(bno != NULLFSBLOCK);
ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount); ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks); ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);
/* /*
@ -1429,11 +1429,7 @@ xfs_bmap_search_multi_extents(
gotp->br_startoff = 0xffa5a5a5a5a5a5a5LL; gotp->br_startoff = 0xffa5a5a5a5a5a5a5LL;
gotp->br_blockcount = 0xa55a5a5a5a5a5a5aLL; gotp->br_blockcount = 0xa55a5a5a5a5a5a5aLL;
gotp->br_state = XFS_EXT_INVALID; gotp->br_state = XFS_EXT_INVALID;
#if XFS_BIG_BLKNOS
gotp->br_startblock = 0xffffa5a5a5a5a5a5LL; gotp->br_startblock = 0xffffa5a5a5a5a5a5LL;
#else
gotp->br_startblock = 0xffffa5a5;
#endif
prevp->br_startoff = NULLFILEOFF; prevp->br_startoff = NULLFILEOFF;
ep = xfs_iext_bno_to_ext(ifp, bno, &lastx); ep = xfs_iext_bno_to_ext(ifp, bno, &lastx);

89
fs/xfs/libxfs/xfs_bmap_btree.c
View File

@ -111,23 +111,8 @@ __xfs_bmbt_get_all(
ext_flag = (int)(l0 >> (64 - BMBT_EXNTFLAG_BITLEN)); ext_flag = (int)(l0 >> (64 - BMBT_EXNTFLAG_BITLEN));
s->br_startoff = ((xfs_fileoff_t)l0 & s->br_startoff = ((xfs_fileoff_t)l0 &
xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9; xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9;
#if XFS_BIG_BLKNOS
s->br_startblock = (((xfs_fsblock_t)l0 & xfs_mask64lo(9)) << 43) | s->br_startblock = (((xfs_fsblock_t)l0 & xfs_mask64lo(9)) << 43) |
(((xfs_fsblock_t)l1) >> 21); (((xfs_fsblock_t)l1) >> 21);
#else
#ifdef DEBUG
{
xfs_dfsbno_t b;
b = (((xfs_dfsbno_t)l0 & xfs_mask64lo(9)) << 43) |
(((xfs_dfsbno_t)l1) >> 21);
ASSERT((b >> 32) == 0 || isnulldstartblock(b));
s->br_startblock = (xfs_fsblock_t)b;
}
#else /* !DEBUG */
s->br_startblock = (xfs_fsblock_t)(((xfs_dfsbno_t)l1) >> 21);
#endif /* DEBUG */
#endif /* XFS_BIG_BLKNOS */
s->br_blockcount = (xfs_filblks_t)(l1 & xfs_mask64lo(21)); s->br_blockcount = (xfs_filblks_t)(l1 & xfs_mask64lo(21));
/* This is xfs_extent_state() in-line */ /* This is xfs_extent_state() in-line */
if (ext_flag) { if (ext_flag) {
@ -163,21 +148,8 @@ xfs_fsblock_t
xfs_bmbt_get_startblock( xfs_bmbt_get_startblock(
xfs_bmbt_rec_host_t *r) xfs_bmbt_rec_host_t *r)
{ {
#if XFS_BIG_BLKNOS
return (((xfs_fsblock_t)r->l0 & xfs_mask64lo(9)) << 43) | return (((xfs_fsblock_t)r->l0 & xfs_mask64lo(9)) << 43) |
(((xfs_fsblock_t)r->l1) >> 21); (((xfs_fsblock_t)r->l1) >> 21);
#else
#ifdef DEBUG
xfs_dfsbno_t b;
b = (((xfs_dfsbno_t)r->l0 & xfs_mask64lo(9)) << 43) |
(((xfs_dfsbno_t)r->l1) >> 21);
ASSERT((b >> 32) == 0 || isnulldstartblock(b));
return (xfs_fsblock_t)b;
#else /* !DEBUG */
return (xfs_fsblock_t)(((xfs_dfsbno_t)r->l1) >> 21);
#endif /* DEBUG */
#endif /* XFS_BIG_BLKNOS */
} }
/* /*
@ -241,7 +213,6 @@ xfs_bmbt_set_allf(
ASSERT((startoff & xfs_mask64hi(64-BMBT_STARTOFF_BITLEN)) == 0); ASSERT((startoff & xfs_mask64hi(64-BMBT_STARTOFF_BITLEN)) == 0);
ASSERT((blockcount & xfs_mask64hi(64-BMBT_BLOCKCOUNT_BITLEN)) == 0); ASSERT((blockcount & xfs_mask64hi(64-BMBT_BLOCKCOUNT_BITLEN)) == 0);
#if XFS_BIG_BLKNOS
ASSERT((startblock & xfs_mask64hi(64-BMBT_STARTBLOCK_BITLEN)) == 0); ASSERT((startblock & xfs_mask64hi(64-BMBT_STARTBLOCK_BITLEN)) == 0);
r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) | r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
@ -250,23 +221,6 @@ xfs_bmbt_set_allf(
r->l1 = ((xfs_bmbt_rec_base_t)startblock << 21) | r->l1 = ((xfs_bmbt_rec_base_t)startblock << 21) |
((xfs_bmbt_rec_base_t)blockcount & ((xfs_bmbt_rec_base_t)blockcount &
(xfs_bmbt_rec_base_t)xfs_mask64lo(21)); (xfs_bmbt_rec_base_t)xfs_mask64lo(21));
#else /* !XFS_BIG_BLKNOS */
if (isnullstartblock(startblock)) {
r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)startoff << 9) |
(xfs_bmbt_rec_base_t)xfs_mask64lo(9);
r->l1 = xfs_mask64hi(11) |
((xfs_bmbt_rec_base_t)startblock << 21) |
((xfs_bmbt_rec_base_t)blockcount &
(xfs_bmbt_rec_base_t)xfs_mask64lo(21));
} else {
r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)startoff << 9);
r->l1 = ((xfs_bmbt_rec_base_t)startblock << 21) |
((xfs_bmbt_rec_base_t)blockcount &
(xfs_bmbt_rec_base_t)xfs_mask64lo(21));
}
#endif /* XFS_BIG_BLKNOS */
} }
/* /*
@ -298,8 +252,6 @@ xfs_bmbt_disk_set_allf(
ASSERT(state == XFS_EXT_NORM || state == XFS_EXT_UNWRITTEN); ASSERT(state == XFS_EXT_NORM || state == XFS_EXT_UNWRITTEN);
ASSERT((startoff & xfs_mask64hi(64-BMBT_STARTOFF_BITLEN)) == 0); ASSERT((startoff & xfs_mask64hi(64-BMBT_STARTOFF_BITLEN)) == 0);
ASSERT((blockcount & xfs_mask64hi(64-BMBT_BLOCKCOUNT_BITLEN)) == 0); ASSERT((blockcount & xfs_mask64hi(64-BMBT_BLOCKCOUNT_BITLEN)) == 0);
#if XFS_BIG_BLKNOS
ASSERT((startblock & xfs_mask64hi(64-BMBT_STARTBLOCK_BITLEN)) == 0); ASSERT((startblock & xfs_mask64hi(64-BMBT_STARTBLOCK_BITLEN)) == 0);
r->l0 = cpu_to_be64( r->l0 = cpu_to_be64(
@ -310,26 +262,6 @@ xfs_bmbt_disk_set_allf(
((xfs_bmbt_rec_base_t)startblock << 21) | ((xfs_bmbt_rec_base_t)startblock << 21) |
((xfs_bmbt_rec_base_t)blockcount & ((xfs_bmbt_rec_base_t)blockcount &
(xfs_bmbt_rec_base_t)xfs_mask64lo(21))); (xfs_bmbt_rec_base_t)xfs_mask64lo(21)));
#else /* !XFS_BIG_BLKNOS */
if (isnullstartblock(startblock)) {
r->l0 = cpu_to_be64(
((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)startoff << 9) |
(xfs_bmbt_rec_base_t)xfs_mask64lo(9));
r->l1 = cpu_to_be64(xfs_mask64hi(11) |
((xfs_bmbt_rec_base_t)startblock << 21) |
((xfs_bmbt_rec_base_t)blockcount &
(xfs_bmbt_rec_base_t)xfs_mask64lo(21)));
} else {
r->l0 = cpu_to_be64(
((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)startoff << 9));
r->l1 = cpu_to_be64(
((xfs_bmbt_rec_base_t)startblock << 21) |
((xfs_bmbt_rec_base_t)blockcount &
(xfs_bmbt_rec_base_t)xfs_mask64lo(21)));
}
#endif /* XFS_BIG_BLKNOS */
} }
/* /*
@ -365,24 +297,11 @@ xfs_bmbt_set_startblock(
xfs_bmbt_rec_host_t *r, xfs_bmbt_rec_host_t *r,
xfs_fsblock_t v) xfs_fsblock_t v)
{ {
#if XFS_BIG_BLKNOS
ASSERT((v & xfs_mask64hi(12)) == 0); ASSERT((v & xfs_mask64hi(12)) == 0);
r->l0 = (r->l0 & (xfs_bmbt_rec_base_t)xfs_mask64hi(55)) | r->l0 = (r->l0 & (xfs_bmbt_rec_base_t)xfs_mask64hi(55)) |
(xfs_bmbt_rec_base_t)(v >> 43); (xfs_bmbt_rec_base_t)(v >> 43);
r->l1 = (r->l1 & (xfs_bmbt_rec_base_t)xfs_mask64lo(21)) | r->l1 = (r->l1 & (xfs_bmbt_rec_base_t)xfs_mask64lo(21)) |
(xfs_bmbt_rec_base_t)(v << 21); (xfs_bmbt_rec_base_t)(v << 21);
#else /* !XFS_BIG_BLKNOS */
if (isnullstartblock(v)) {
r->l0 |= (xfs_bmbt_rec_base_t)xfs_mask64lo(9);
r->l1 = (xfs_bmbt_rec_base_t)xfs_mask64hi(11) |
((xfs_bmbt_rec_base_t)v << 21) |
(r->l1 & (xfs_bmbt_rec_base_t)xfs_mask64lo(21));
} else {
r->l0 &= ~(xfs_bmbt_rec_base_t)xfs_mask64lo(9);
r->l1 = ((xfs_bmbt_rec_base_t)v << 21) |
(r->l1 & (xfs_bmbt_rec_base_t)xfs_mask64lo(21));
}
#endif /* XFS_BIG_BLKNOS */
} }
/* /*
@ -438,8 +357,8 @@ xfs_bmbt_to_bmdr(
cpu_to_be64(XFS_BUF_DADDR_NULL)); cpu_to_be64(XFS_BUF_DADDR_NULL));
} else } else
ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_MAGIC)); ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_MAGIC));
ASSERT(rblock->bb_u.l.bb_leftsib == cpu_to_be64(NULLDFSBNO)); ASSERT(rblock->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK));
ASSERT(rblock->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO)); ASSERT(rblock->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK));
ASSERT(rblock->bb_level != 0); ASSERT(rblock->bb_level != 0);
dblock->bb_level = rblock->bb_level; dblock->bb_level = rblock->bb_level;
dblock->bb_numrecs = rblock->bb_numrecs; dblock->bb_numrecs = rblock->bb_numrecs;
@ -763,11 +682,11 @@ xfs_bmbt_verify(
/* sibling pointer verification */ /* sibling pointer verification */
if (!block->bb_u.l.bb_leftsib || if (!block->bb_u.l.bb_leftsib ||
(block->bb_u.l.bb_leftsib != cpu_to_be64(NULLDFSBNO) && (block->bb_u.l.bb_leftsib != cpu_to_be64(NULLFSBLOCK) &&
!XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_u.l.bb_leftsib)))) !XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_u.l.bb_leftsib))))
return false; return false;
if (!block->bb_u.l.bb_rightsib || if (!block->bb_u.l.bb_rightsib ||
(block->bb_u.l.bb_rightsib != cpu_to_be64(NULLDFSBNO) && (block->bb_u.l.bb_rightsib != cpu_to_be64(NULLFSBLOCK) &&
!XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_u.l.bb_rightsib)))) !XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_u.l.bb_rightsib))))
return false; return false;

32
fs/xfs/libxfs/xfs_btree.c
View File

@ -77,11 +77,11 @@ xfs_btree_check_lblock(
be16_to_cpu(block->bb_numrecs) <= be16_to_cpu(block->bb_numrecs) <=
cur->bc_ops->get_maxrecs(cur, level) && cur->bc_ops->get_maxrecs(cur, level) &&
block->bb_u.l.bb_leftsib && block->bb_u.l.bb_leftsib &&
(block->bb_u.l.bb_leftsib == cpu_to_be64(NULLDFSBNO) || (block->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK) ||
XFS_FSB_SANITY_CHECK(mp, XFS_FSB_SANITY_CHECK(mp,
be64_to_cpu(block->bb_u.l.bb_leftsib))) && be64_to_cpu(block->bb_u.l.bb_leftsib))) &&
block->bb_u.l.bb_rightsib && block->bb_u.l.bb_rightsib &&
(block->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO) || (block->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK) ||
XFS_FSB_SANITY_CHECK(mp, XFS_FSB_SANITY_CHECK(mp,
be64_to_cpu(block->bb_u.l.bb_rightsib))); be64_to_cpu(block->bb_u.l.bb_rightsib)));
@ -166,12 +166,12 @@ xfs_btree_check_block(
int /* error (0 or EFSCORRUPTED) */ int /* error (0 or EFSCORRUPTED) */
xfs_btree_check_lptr( xfs_btree_check_lptr(
struct xfs_btree_cur *cur, /* btree cursor */ struct xfs_btree_cur *cur, /* btree cursor */
xfs_dfsbno_t bno, /* btree block disk address */ xfs_fsblock_t bno, /* btree block disk address */
int level) /* btree block level */ int level) /* btree block level */
{ {
XFS_WANT_CORRUPTED_RETURN( XFS_WANT_CORRUPTED_RETURN(
level > 0 && level > 0 &&
bno != NULLDFSBNO && bno != NULLFSBLOCK &&
XFS_FSB_SANITY_CHECK(cur->bc_mp, bno)); XFS_FSB_SANITY_CHECK(cur->bc_mp, bno));
return 0; return 0;
} }
@ -594,7 +594,7 @@ xfs_btree_islastblock(
block = xfs_btree_get_block(cur, level, &bp); block = xfs_btree_get_block(cur, level, &bp);
xfs_btree_check_block(cur, block, level, bp); xfs_btree_check_block(cur, block, level, bp);
if (cur->bc_flags & XFS_BTREE_LONG_PTRS) if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
return block->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO); return block->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK);
else else
return block->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK); return block->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK);
} }
@ -770,16 +770,16 @@ xfs_btree_readahead_lblock(
struct xfs_btree_block *block) struct xfs_btree_block *block)
{ {
int rval = 0; int rval = 0;
xfs_dfsbno_t left = be64_to_cpu(block->bb_u.l.bb_leftsib); xfs_fsblock_t left = be64_to_cpu(block->bb_u.l.bb_leftsib);
xfs_dfsbno_t right = be64_to_cpu(block->bb_u.l.bb_rightsib); xfs_fsblock_t right = be64_to_cpu(block->bb_u.l.bb_rightsib);
if ((lr & XFS_BTCUR_LEFTRA) && left != NULLDFSBNO) { if ((lr & XFS_BTCUR_LEFTRA) && left != NULLFSBLOCK) {
xfs_btree_reada_bufl(cur->bc_mp, left, 1, xfs_btree_reada_bufl(cur->bc_mp, left, 1,
cur->bc_ops->buf_ops); cur->bc_ops->buf_ops);
rval++; rval++;
} }
if ((lr & XFS_BTCUR_RIGHTRA) && right != NULLDFSBNO) { if ((lr & XFS_BTCUR_RIGHTRA) && right != NULLFSBLOCK) {
xfs_btree_reada_bufl(cur->bc_mp, right, 1, xfs_btree_reada_bufl(cur->bc_mp, right, 1,
cur->bc_ops->buf_ops); cur->bc_ops->buf_ops);
rval++; rval++;
@ -851,7 +851,7 @@ xfs_btree_ptr_to_daddr(
union xfs_btree_ptr *ptr) union xfs_btree_ptr *ptr)
{ {
if (cur->bc_flags & XFS_BTREE_LONG_PTRS) { if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
ASSERT(ptr->l != cpu_to_be64(NULLDFSBNO)); ASSERT(ptr->l != cpu_to_be64(NULLFSBLOCK));
return XFS_FSB_TO_DADDR(cur->bc_mp, be64_to_cpu(ptr->l)); return XFS_FSB_TO_DADDR(cur->bc_mp, be64_to_cpu(ptr->l));
} else { } else {
@ -899,9 +899,9 @@ xfs_btree_setbuf(
b = XFS_BUF_TO_BLOCK(bp); b = XFS_BUF_TO_BLOCK(bp);
if (cur->bc_flags & XFS_BTREE_LONG_PTRS) { if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
if (b->bb_u.l.bb_leftsib == cpu_to_be64(NULLDFSBNO)) if (b->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK))
cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA; cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
if (b->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO)) if (b->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK))
cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA; cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
} else { } else {
if (b->bb_u.s.bb_leftsib == cpu_to_be32(NULLAGBLOCK)) if (b->bb_u.s.bb_leftsib == cpu_to_be32(NULLAGBLOCK))
@ -917,7 +917,7 @@ xfs_btree_ptr_is_null(
union xfs_btree_ptr *ptr) union xfs_btree_ptr *ptr)
{ {
if (cur->bc_flags & XFS_BTREE_LONG_PTRS) if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
return ptr->l == cpu_to_be64(NULLDFSBNO); return ptr->l == cpu_to_be64(NULLFSBLOCK);
else else
return ptr->s == cpu_to_be32(NULLAGBLOCK); return ptr->s == cpu_to_be32(NULLAGBLOCK);
} }
@ -928,7 +928,7 @@ xfs_btree_set_ptr_null(
union xfs_btree_ptr *ptr) union xfs_btree_ptr *ptr)
{ {
if (cur->bc_flags & XFS_BTREE_LONG_PTRS) if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
ptr->l = cpu_to_be64(NULLDFSBNO); ptr->l = cpu_to_be64(NULLFSBLOCK);
else else
ptr->s = cpu_to_be32(NULLAGBLOCK); ptr->s = cpu_to_be32(NULLAGBLOCK);
} }
@ -996,8 +996,8 @@ xfs_btree_init_block_int(
buf->bb_numrecs = cpu_to_be16(numrecs); buf->bb_numrecs = cpu_to_be16(numrecs);
if (flags & XFS_BTREE_LONG_PTRS) { if (flags & XFS_BTREE_LONG_PTRS) {
buf->bb_u.l.bb_leftsib = cpu_to_be64(NULLDFSBNO); buf->bb_u.l.bb_leftsib = cpu_to_be64(NULLFSBLOCK);
buf->bb_u.l.bb_rightsib = cpu_to_be64(NULLDFSBNO); buf->bb_u.l.bb_rightsib = cpu_to_be64(NULLFSBLOCK);
if (flags & XFS_BTREE_CRC_BLOCKS) { if (flags & XFS_BTREE_CRC_BLOCKS) {
buf->bb_u.l.bb_blkno = cpu_to_be64(blkno); buf->bb_u.l.bb_blkno = cpu_to_be64(blkno);
buf->bb_u.l.bb_owner = cpu_to_be64(owner); buf->bb_u.l.bb_owner = cpu_to_be64(owner);

2
fs/xfs/libxfs/xfs_btree.h
View File

@ -258,7 +258,7 @@ xfs_btree_check_block(
int /* error (0 or EFSCORRUPTED) */ int /* error (0 or EFSCORRUPTED) */
xfs_btree_check_lptr( xfs_btree_check_lptr(
struct xfs_btree_cur *cur, /* btree cursor */ struct xfs_btree_cur *cur, /* btree cursor */
xfs_dfsbno_t ptr, /* btree block disk address */ xfs_fsblock_t ptr, /* btree block disk address */
int level); /* btree block level */ int level); /* btree block level */
/* /*

2
fs/xfs/libxfs/xfs_da_btree.c
View File

@ -2004,7 +2004,7 @@ xfs_da_grow_inode_int(
struct xfs_trans *tp = args->trans; struct xfs_trans *tp = args->trans;
struct xfs_inode *dp = args->dp; struct xfs_inode *dp = args->dp;
int w = args->whichfork; int w = args->whichfork;
xfs_drfsbno_t nblks = dp->i_d.di_nblocks; xfs_rfsblock_t nblks = dp->i_d.di_nblocks;
struct xfs_bmbt_irec map, *mapp; struct xfs_bmbt_irec map, *mapp;
int nmap, error, got, i, mapi; int nmap, error, got, i, mapi;

45
fs/xfs/libxfs/xfs_dir2_sf.c
View File

@ -51,10 +51,9 @@ static void xfs_dir2_sf_check(xfs_da_args_t *args);
#else #else
#define xfs_dir2_sf_check(args) #define xfs_dir2_sf_check(args)
#endif /* DEBUG */ #endif /* DEBUG */
#if XFS_BIG_INUMS
static void xfs_dir2_sf_toino4(xfs_da_args_t *args); static void xfs_dir2_sf_toino4(xfs_da_args_t *args);
static void xfs_dir2_sf_toino8(xfs_da_args_t *args); static void xfs_dir2_sf_toino8(xfs_da_args_t *args);
#endif /* XFS_BIG_INUMS */
/* /*
* Given a block directory (dp/block), calculate its size as a shortform (sf) * Given a block directory (dp/block), calculate its size as a shortform (sf)
@ -117,10 +116,10 @@ xfs_dir2_block_sfsize(
isdotdot = isdotdot =
dep->namelen == 2 && dep->namelen == 2 &&
dep->name[0] == '.' && dep->name[1] == '.'; dep->name[0] == '.' && dep->name[1] == '.';
#if XFS_BIG_INUMS
if (!isdot) if (!isdot)
i8count += be64_to_cpu(dep->inumber) > XFS_DIR2_MAX_SHORT_INUM; i8count += be64_to_cpu(dep->inumber) > XFS_DIR2_MAX_SHORT_INUM;
#endif
/* take into account the file type field */ /* take into account the file type field */
if (!isdot && !isdotdot) { if (!isdot && !isdotdot) {
count++; count++;
@ -318,7 +317,7 @@ xfs_dir2_sf_addname(
*/ */
incr_isize = dp->d_ops->sf_entsize(sfp, args->namelen); incr_isize = dp->d_ops->sf_entsize(sfp, args->namelen);
objchange = 0; objchange = 0;
#if XFS_BIG_INUMS
/* /*
* Do we have to change to 8 byte inodes? * Do we have to change to 8 byte inodes?
*/ */
@ -332,7 +331,7 @@ xfs_dir2_sf_addname(
(uint)sizeof(xfs_dir2_ino4_t)); (uint)sizeof(xfs_dir2_ino4_t));
objchange = 1; objchange = 1;
} }
#endif
new_isize = (int)dp->i_d.di_size + incr_isize; new_isize = (int)dp->i_d.di_size + incr_isize;
/* /*
* Won't fit as shortform any more (due to size), * Won't fit as shortform any more (due to size),
@ -370,10 +369,8 @@ xfs_dir2_sf_addname(
*/ */
else { else {
ASSERT(pick == 2); ASSERT(pick == 2);
#if XFS_BIG_INUMS
if (objchange) if (objchange)
xfs_dir2_sf_toino8(args); xfs_dir2_sf_toino8(args);
#endif
xfs_dir2_sf_addname_hard(args, objchange, new_isize); xfs_dir2_sf_addname_hard(args, objchange, new_isize);
} }
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA); xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
@ -425,10 +422,8 @@ xfs_dir2_sf_addname_easy(
* Update the header and inode. * Update the header and inode.
*/ */
sfp->count++; sfp->count++;
#if XFS_BIG_INUMS
if (args->inumber > XFS_DIR2_MAX_SHORT_INUM) if (args->inumber > XFS_DIR2_MAX_SHORT_INUM)
sfp->i8count++; sfp->i8count++;
#endif
dp->i_d.di_size = new_isize; dp->i_d.di_size = new_isize;
xfs_dir2_sf_check(args); xfs_dir2_sf_check(args);
} }
@ -516,10 +511,8 @@ xfs_dir2_sf_addname_hard(
dp->d_ops->sf_put_ino(sfp, sfep, args->inumber); dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
dp->d_ops->sf_put_ftype(sfep, args->filetype); dp->d_ops->sf_put_ftype(sfep, args->filetype);
sfp->count++; sfp->count++;
#if XFS_BIG_INUMS
if (args->inumber > XFS_DIR2_MAX_SHORT_INUM && !objchange) if (args->inumber > XFS_DIR2_MAX_SHORT_INUM && !objchange)
sfp->i8count++; sfp->i8count++;
#endif
/* /*
* If there's more left to copy, do that. * If there's more left to copy, do that.
*/ */
@ -593,13 +586,8 @@ xfs_dir2_sf_addname_pick(
/* /*
* If changing the inode number size, do it the hard way. * If changing the inode number size, do it the hard way.
*/ */
#if XFS_BIG_INUMS if (objchange)
if (objchange) {
return 2; return 2;
}
#else
ASSERT(objchange == 0);
#endif
/* /*
* If it won't fit at the end then do it the hard way (use the hole). * If it won't fit at the end then do it the hard way (use the hole).
*/ */
@ -650,7 +638,6 @@ xfs_dir2_sf_check(
ASSERT(dp->d_ops->sf_get_ftype(sfep) < XFS_DIR3_FT_MAX); ASSERT(dp->d_ops->sf_get_ftype(sfep) < XFS_DIR3_FT_MAX);
} }
ASSERT(i8count == sfp->i8count); ASSERT(i8count == sfp->i8count);
ASSERT(XFS_BIG_INUMS || i8count == 0);
ASSERT((char *)sfep - (char *)sfp == dp->i_d.di_size); ASSERT((char *)sfep - (char *)sfp == dp->i_d.di_size);
ASSERT(offset + ASSERT(offset +
(sfp->count + 2) * (uint)sizeof(xfs_dir2_leaf_entry_t) + (sfp->count + 2) * (uint)sizeof(xfs_dir2_leaf_entry_t) +
@ -870,7 +857,6 @@ xfs_dir2_sf_removename(
*/ */
xfs_idata_realloc(dp, newsize - oldsize, XFS_DATA_FORK); xfs_idata_realloc(dp, newsize - oldsize, XFS_DATA_FORK);
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data; sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
#if XFS_BIG_INUMS
/* /*
* Are we changing inode number size? * Are we changing inode number size?
*/ */
@ -880,7 +866,6 @@ xfs_dir2_sf_removename(
else else
sfp->i8count--; sfp->i8count--;
} }
#endif
xfs_dir2_sf_check(args); xfs_dir2_sf_check(args);
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA); xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
return 0; return 0;
@ -895,12 +880,8 @@ xfs_dir2_sf_replace(
{ {
xfs_inode_t *dp; /* incore directory inode */ xfs_inode_t *dp; /* incore directory inode */
int i; /* entry index */ int i; /* entry index */
#if XFS_BIG_INUMS || defined(DEBUG)
xfs_ino_t ino=0; /* entry old inode number */ xfs_ino_t ino=0; /* entry old inode number */
#endif
#if XFS_BIG_INUMS
int i8elevated; /* sf_toino8 set i8count=1 */ int i8elevated; /* sf_toino8 set i8count=1 */
#endif
xfs_dir2_sf_entry_t *sfep; /* shortform directory entry */ xfs_dir2_sf_entry_t *sfep; /* shortform directory entry */
xfs_dir2_sf_hdr_t *sfp; /* shortform structure */ xfs_dir2_sf_hdr_t *sfp; /* shortform structure */
@ -920,7 +901,7 @@ xfs_dir2_sf_replace(
ASSERT(dp->i_df.if_u1.if_data != NULL); ASSERT(dp->i_df.if_u1.if_data != NULL);
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data; sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->i8count)); ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->i8count));
#if XFS_BIG_INUMS
/* /*
* New inode number is large, and need to convert to 8-byte inodes. * New inode number is large, and need to convert to 8-byte inodes.
*/ */
@ -951,17 +932,15 @@ xfs_dir2_sf_replace(
sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data; sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
} else } else
i8elevated = 0; i8elevated = 0;
#endif
ASSERT(args->namelen != 1 || args->name[0] != '.'); ASSERT(args->namelen != 1 || args->name[0] != '.');
/* /*
* Replace ..'s entry. * Replace ..'s entry.
*/ */
if (args->namelen == 2 && if (args->namelen == 2 &&
args->name[0] == '.' && args->name[1] == '.') { args->name[0] == '.' && args->name[1] == '.') {
#if XFS_BIG_INUMS || defined(DEBUG)
ino = dp->d_ops->sf_get_parent_ino(sfp); ino = dp->d_ops->sf_get_parent_ino(sfp);
ASSERT(args->inumber != ino); ASSERT(args->inumber != ino);
#endif
dp->d_ops->sf_put_parent_ino(sfp, args->inumber); dp->d_ops->sf_put_parent_ino(sfp, args->inumber);
} }
/* /*
@ -972,10 +951,8 @@ xfs_dir2_sf_replace(
i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep)) { i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep)) {
if (xfs_da_compname(args, sfep->name, sfep->namelen) == if (xfs_da_compname(args, sfep->name, sfep->namelen) ==
XFS_CMP_EXACT) { XFS_CMP_EXACT) {
#if XFS_BIG_INUMS || defined(DEBUG)
ino = dp->d_ops->sf_get_ino(sfp, sfep); ino = dp->d_ops->sf_get_ino(sfp, sfep);
ASSERT(args->inumber != ino); ASSERT(args->inumber != ino);
#endif
dp->d_ops->sf_put_ino(sfp, sfep, args->inumber); dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
dp->d_ops->sf_put_ftype(sfep, args->filetype); dp->d_ops->sf_put_ftype(sfep, args->filetype);
break; break;
@ -986,14 +963,11 @@ xfs_dir2_sf_replace(
*/ */
if (i == sfp->count) { if (i == sfp->count) {
ASSERT(args->op_flags & XFS_DA_OP_OKNOENT); ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
#if XFS_BIG_INUMS
if (i8elevated) if (i8elevated)
xfs_dir2_sf_toino4(args); xfs_dir2_sf_toino4(args);
#endif
return -ENOENT; return -ENOENT;
} }
} }
#if XFS_BIG_INUMS
/* /*
* See if the old number was large, the new number is small. * See if the old number was large, the new number is small.
*/ */
@ -1020,13 +994,11 @@ xfs_dir2_sf_replace(
if (!i8elevated) if (!i8elevated)
sfp->i8count++; sfp->i8count++;
} }
#endif
xfs_dir2_sf_check(args); xfs_dir2_sf_check(args);
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_DDATA); xfs_trans_log_inode(args->trans, dp, XFS_ILOG_DDATA);
return 0; return 0;
} }
#if XFS_BIG_INUMS
/* /*
* Convert from 8-byte inode numbers to 4-byte inode numbers. * Convert from 8-byte inode numbers to 4-byte inode numbers.
* The last 8-byte inode number is gone, but the count is still 1. * The last 8-byte inode number is gone, but the count is still 1.
@ -1181,4 +1153,3 @@ xfs_dir2_sf_toino8(
dp->i_d.di_size = newsize; dp->i_d.di_size = newsize;
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA); xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
} }
#endif /* XFS_BIG_INUMS */

14
fs/xfs/libxfs/xfs_format.h
View File

@ -68,11 +68,7 @@ struct xfs_ifork;
#define XFS_RTLOBIT(w) xfs_lowbit32(w) #define XFS_RTLOBIT(w) xfs_lowbit32(w)
#define XFS_RTHIBIT(w) xfs_highbit32(w) #define XFS_RTHIBIT(w) xfs_highbit32(w)
#if XFS_BIG_BLKNOS
#define XFS_RTBLOCKLOG(b) xfs_highbit64(b) #define XFS_RTBLOCKLOG(b) xfs_highbit64(b)
#else
#define XFS_RTBLOCKLOG(b) xfs_highbit32(b)
#endif
/* /*
* Dquot and dquot block format definitions * Dquot and dquot block format definitions
@ -304,23 +300,15 @@ typedef struct xfs_bmbt_rec_host {
* Values and macros for delayed-allocation startblock fields. * Values and macros for delayed-allocation startblock fields.
*/ */
#define STARTBLOCKVALBITS 17 #define STARTBLOCKVALBITS 17
#define STARTBLOCKMASKBITS (15 + XFS_BIG_BLKNOS * 20) #define STARTBLOCKMASKBITS (15 + 20)
#define DSTARTBLOCKMASKBITS (15 + 20)
#define STARTBLOCKMASK \ #define STARTBLOCKMASK \
(((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS) (((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
#define DSTARTBLOCKMASK \
(((((xfs_dfsbno_t)1) << DSTARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
static inline int isnullstartblock(xfs_fsblock_t x) static inline int isnullstartblock(xfs_fsblock_t x)
{ {
return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK; return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
} }
static inline int isnulldstartblock(xfs_dfsbno_t x)
{
return ((x) & DSTARTBLOCKMASK) == DSTARTBLOCKMASK;
}
static inline xfs_fsblock_t nullstartblock(int k) static inline xfs_fsblock_t nullstartblock(int k)
{ {
ASSERT(k < (1 << STARTBLOCKVALBITS)); ASSERT(k < (1 << STARTBLOCKVALBITS));

4
fs/xfs/libxfs/xfs_inode_fork.c
View File

@ -528,7 +528,7 @@ xfs_iroot_realloc(
ifp->if_broot_bytes = (int)new_size; ifp->if_broot_bytes = (int)new_size;
ASSERT(XFS_BMAP_BMDR_SPACE(ifp->if_broot) <= ASSERT(XFS_BMAP_BMDR_SPACE(ifp->if_broot) <=
XFS_IFORK_SIZE(ip, whichfork)); XFS_IFORK_SIZE(ip, whichfork));
memmove(np, op, cur_max * (uint)sizeof(xfs_dfsbno_t)); memmove(np, op, cur_max * (uint)sizeof(xfs_fsblock_t));
return; return;
} }
@ -575,7 +575,7 @@ xfs_iroot_realloc(
ifp->if_broot_bytes); ifp->if_broot_bytes);
np = (char *)XFS_BMAP_BROOT_PTR_ADDR(mp, new_broot, 1, np = (char *)XFS_BMAP_BROOT_PTR_ADDR(mp, new_broot, 1,
(int)new_size); (int)new_size);
memcpy(np, op, new_max * (uint)sizeof(xfs_dfsbno_t)); memcpy(np, op, new_max * (uint)sizeof(xfs_fsblock_t));
} }
kmem_free(ifp->if_broot); kmem_free(ifp->if_broot);
ifp->if_broot = new_broot; ifp->if_broot = new_broot;

4
fs/xfs/libxfs/xfs_inum.h
View File

@ -54,11 +54,7 @@ struct xfs_mount;
#define XFS_OFFBNO_TO_AGINO(mp,b,o) \ #define XFS_OFFBNO_TO_AGINO(mp,b,o) \
((xfs_agino_t)(((b) << XFS_INO_OFFSET_BITS(mp)) | (o))) ((xfs_agino_t)(((b) << XFS_INO_OFFSET_BITS(mp)) | (o)))
#if XFS_BIG_INUMS
#define XFS_MAXINUMBER ((xfs_ino_t)((1ULL << 56) - 1ULL)) #define XFS_MAXINUMBER ((xfs_ino_t)((1ULL << 56) - 1ULL))
#else
#define XFS_MAXINUMBER ((xfs_ino_t)((1ULL << 32) - 1ULL))
#endif
#define XFS_MAXINUMBER_32 ((xfs_ino_t)((1ULL << 32) - 1ULL)) #define XFS_MAXINUMBER_32 ((xfs_ino_t)((1ULL << 32) - 1ULL))
#endif /* __XFS_INUM_H__ */ #endif /* __XFS_INUM_H__ */

4
fs/xfs/libxfs/xfs_log_format.h
View File

@ -380,7 +380,7 @@ typedef struct xfs_icdinode {
xfs_ictimestamp_t di_mtime; /* time last modified */ xfs_ictimestamp_t di_mtime; /* time last modified */
xfs_ictimestamp_t di_ctime; /* time created/inode modified */ xfs_ictimestamp_t di_ctime; /* time created/inode modified */
xfs_fsize_t di_size; /* number of bytes in file */ xfs_fsize_t di_size; /* number of bytes in file */
xfs_drfsbno_t di_nblocks; /* # of direct & btree blocks used */ xfs_rfsblock_t di_nblocks; /* # of direct & btree blocks used */
xfs_extlen_t di_extsize; /* basic/minimum extent size for file */ xfs_extlen_t di_extsize; /* basic/minimum extent size for file */
xfs_extnum_t di_nextents; /* number of extents in data fork */ xfs_extnum_t di_nextents; /* number of extents in data fork */
xfs_aextnum_t di_anextents; /* number of extents in attribute fork*/ xfs_aextnum_t di_anextents; /* number of extents in attribute fork*/
@ -516,7 +516,7 @@ xfs_blft_from_flags(struct xfs_buf_log_format *blf)
* EFI/EFD log format definitions * EFI/EFD log format definitions
*/ */
typedef struct xfs_extent { typedef struct xfs_extent {
xfs_dfsbno_t ext_start; xfs_fsblock_t ext_start;
xfs_extlen_t ext_len; xfs_extlen_t ext_len;
} xfs_extent_t; } xfs_extent_t;

8
fs/xfs/libxfs/xfs_sb.h
View File

@ -87,11 +87,11 @@ struct xfs_trans;
typedef struct xfs_sb { typedef struct xfs_sb {
__uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */ __uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */
__uint32_t sb_blocksize; /* logical block size, bytes */ __uint32_t sb_blocksize; /* logical block size, bytes */
xfs_drfsbno_t sb_dblocks; /* number of data blocks */ xfs_rfsblock_t sb_dblocks; /* number of data blocks */
xfs_drfsbno_t sb_rblocks; /* number of realtime blocks */ xfs_rfsblock_t sb_rblocks; /* number of realtime blocks */
xfs_drtbno_t sb_rextents; /* number of realtime extents */ xfs_rtblock_t sb_rextents; /* number of realtime extents */
uuid_t sb_uuid; /* file system unique id */ uuid_t sb_uuid; /* file system unique id */
xfs_dfsbno_t sb_logstart; /* starting block of log if internal */ xfs_fsblock_t sb_logstart; /* starting block of log if internal */
xfs_ino_t sb_rootino; /* root inode number */ xfs_ino_t sb_rootino; /* root inode number */
xfs_ino_t sb_rbmino; /* bitmap inode for realtime extents */ xfs_ino_t sb_rbmino; /* bitmap inode for realtime extents */
xfs_ino_t sb_rsumino; /* summary inode for rt bitmap */ xfs_ino_t sb_rsumino; /* summary inode for rt bitmap */

2
fs/xfs/xfs_bmap_util.c
View File

@ -478,7 +478,7 @@ xfs_bmap_count_blocks(
ASSERT(level > 0); ASSERT(level > 0);
pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
bno = be64_to_cpu(*pp); bno = be64_to_cpu(*pp);
ASSERT(bno != NULLDFSBNO); ASSERT(bno != NULLFSBLOCK);
ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount); ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks); ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);

4
fs/xfs/xfs_fs.h
View File

@ -255,8 +255,8 @@ typedef struct xfs_fsop_resblks {
((2 * 1024 * 1024 * 1024ULL) - XFS_MIN_LOG_BYTES) ((2 * 1024 * 1024 * 1024ULL) - XFS_MIN_LOG_BYTES)
/* Used for sanity checks on superblock */ /* Used for sanity checks on superblock */
#define XFS_MAX_DBLOCKS(s) ((xfs_drfsbno_t)(s)->sb_agcount * (s)->sb_agblocks) #define XFS_MAX_DBLOCKS(s) ((xfs_rfsblock_t)(s)->sb_agcount * (s)->sb_agblocks)
#define XFS_MIN_DBLOCKS(s) ((xfs_drfsbno_t)((s)->sb_agcount - 1) * \ #define XFS_MIN_DBLOCKS(s) ((xfs_rfsblock_t)((s)->sb_agcount - 1) * \
(s)->sb_agblocks + XFS_MIN_AG_BLOCKS) (s)->sb_agblocks + XFS_MIN_AG_BLOCKS)
/* /*

12
fs/xfs/xfs_linux.h
View File

@ -20,18 +20,6 @@
#include <linux/types.h> #include <linux/types.h>
/*
* XFS_BIG_BLKNOS needs block layer disk addresses to be 64 bits.
* XFS_BIG_INUMS requires XFS_BIG_BLKNOS to be set.
*/
#if defined(CONFIG_LBDAF) || (BITS_PER_LONG == 64)
# define XFS_BIG_BLKNOS 1
# define XFS_BIG_INUMS 1
#else
# define XFS_BIG_BLKNOS 0
# define XFS_BIG_INUMS 0
#endif
/* /*
* Kernel specific type declarations for XFS * Kernel specific type declarations for XFS
*/ */

6
fs/xfs/xfs_mount.c
View File

@ -173,13 +173,9 @@ xfs_sb_validate_fsb_count(
ASSERT(PAGE_SHIFT >= sbp->sb_blocklog); ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
ASSERT(sbp->sb_blocklog >= BBSHIFT); ASSERT(sbp->sb_blocklog >= BBSHIFT);
#if XFS_BIG_BLKNOS /* Limited by ULONG_MAX of page cache index */ /* Limited by ULONG_MAX of page cache index */
if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX) if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
return -EFBIG; return -EFBIG;
#else /* Limited by UINT_MAX of sectors */
if (nblocks << (sbp->sb_blocklog - BBSHIFT) > UINT_MAX)
return -EFBIG;
#endif
return 0; return 0;
} }

4
fs/xfs/xfs_rtalloc.c
View File

@ -944,9 +944,9 @@ xfs_growfs_rt(
xfs_buf_t *bp; /* temporary buffer */ xfs_buf_t *bp; /* temporary buffer */
int error; /* error return value */ int error; /* error return value */
xfs_mount_t *nmp; /* new (fake) mount structure */ xfs_mount_t *nmp; /* new (fake) mount structure */
xfs_drfsbno_t nrblocks; /* new number of realtime blocks */ xfs_rfsblock_t nrblocks; /* new number of realtime blocks */
xfs_extlen_t nrbmblocks; /* new number of rt bitmap blocks */ xfs_extlen_t nrbmblocks; /* new number of rt bitmap blocks */
xfs_drtbno_t nrextents; /* new number of realtime extents */ xfs_rtblock_t nrextents; /* new number of realtime extents */
uint8_t nrextslog; /* new log2 of sb_rextents */ uint8_t nrextslog; /* new log2 of sb_rextents */
xfs_extlen_t nrsumblocks; /* new number of summary blocks */ xfs_extlen_t nrsumblocks; /* new number of summary blocks */
uint nrsumlevels; /* new rt summary levels */ uint nrsumlevels; /* new rt summary levels */

8
fs/xfs/xfs_super.c
View File

@ -204,9 +204,6 @@ xfs_parseargs(
*/ */
mp->m_flags |= XFS_MOUNT_BARRIER; mp->m_flags |= XFS_MOUNT_BARRIER;
mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE; mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
#if !XFS_BIG_INUMS
mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
#endif
/* /*
* These can be overridden by the mount option parsing. * These can be overridden by the mount option parsing.
@ -313,11 +310,6 @@ xfs_parseargs(
mp->m_flags |= XFS_MOUNT_SMALL_INUMS; mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
} else if (!strcmp(this_char, MNTOPT_64BITINODE)) { } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS; mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
#if !XFS_BIG_INUMS
xfs_warn(mp, "%s option not allowed on this system",
this_char);
return -EINVAL;
#endif
} else if (!strcmp(this_char, MNTOPT_NOUUID)) { } else if (!strcmp(this_char, MNTOPT_NOUUID)) {
mp->m_flags |= XFS_MOUNT_NOUUID; mp->m_flags |= XFS_MOUNT_NOUUID;
} else if (!strcmp(this_char, MNTOPT_BARRIER)) { } else if (!strcmp(this_char, MNTOPT_BARRIER)) {

11
fs/xfs/xfs_super.h
View File

@ -44,16 +44,6 @@ extern void xfs_qm_exit(void);
# define XFS_REALTIME_STRING # define XFS_REALTIME_STRING
#endif #endif
#if XFS_BIG_BLKNOS
# if XFS_BIG_INUMS
# define XFS_BIGFS_STRING "large block/inode numbers, "
# else
# define XFS_BIGFS_STRING "large block numbers, "
# endif
#else
# define XFS_BIGFS_STRING
#endif
#ifdef DEBUG #ifdef DEBUG
# define XFS_DBG_STRING "debug" # define XFS_DBG_STRING "debug"
#else #else
@ -64,7 +54,6 @@ extern void xfs_qm_exit(void);
#define XFS_BUILD_OPTIONS XFS_ACL_STRING \ #define XFS_BUILD_OPTIONS XFS_ACL_STRING \
XFS_SECURITY_STRING \ XFS_SECURITY_STRING \
XFS_REALTIME_STRING \ XFS_REALTIME_STRING \
XFS_BIGFS_STRING \
XFS_DBG_STRING /* DBG must be last */ XFS_DBG_STRING /* DBG must be last */
struct xfs_inode; struct xfs_inode;

29
fs/xfs/xfs_types.h
View File

@ -38,43 +38,18 @@ typedef __int32_t xfs_tid_t; /* transaction identifier */
typedef __uint32_t xfs_dablk_t; /* dir/attr block number (in file) */ typedef __uint32_t xfs_dablk_t; /* dir/attr block number (in file) */
typedef __uint32_t xfs_dahash_t; /* dir/attr hash value */ typedef __uint32_t xfs_dahash_t; /* dir/attr hash value */
/*
* These types are 64 bits on disk but are either 32 or 64 bits in memory.
* Disk based types:
*/
typedef __uint64_t xfs_dfsbno_t; /* blockno in filesystem (agno|agbno) */
typedef __uint64_t xfs_drfsbno_t; /* blockno in filesystem (raw) */
typedef __uint64_t xfs_drtbno_t; /* extent (block) in realtime area */
typedef __uint64_t xfs_dfiloff_t; /* block number in a file */
typedef __uint64_t xfs_dfilblks_t; /* number of blocks in a file */
/*
* Memory based types are conditional.
*/
#if XFS_BIG_BLKNOS
typedef __uint64_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */ typedef __uint64_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */
typedef __uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */ typedef __uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */
typedef __uint64_t xfs_rtblock_t; /* extent (block) in realtime area */ typedef __uint64_t xfs_rtblock_t; /* extent (block) in realtime area */
typedef __int64_t xfs_srtblock_t; /* signed version of xfs_rtblock_t */
#else
typedef __uint32_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */
typedef __uint32_t xfs_rfsblock_t; /* blockno in filesystem (raw) */
typedef __uint32_t xfs_rtblock_t; /* extent (block) in realtime area */
typedef __int32_t xfs_srtblock_t; /* signed version of xfs_rtblock_t */
#endif
typedef __uint64_t xfs_fileoff_t; /* block number in a file */ typedef __uint64_t xfs_fileoff_t; /* block number in a file */
typedef __int64_t xfs_sfiloff_t; /* signed block number in a file */
typedef __uint64_t xfs_filblks_t; /* number of blocks in a file */ typedef __uint64_t xfs_filblks_t; /* number of blocks in a file */
typedef __int64_t xfs_srtblock_t; /* signed version of xfs_rtblock_t */
typedef __int64_t xfs_sfiloff_t; /* signed block number in a file */
/* /*
* Null values for the types. * Null values for the types.
*/ */
#define NULLDFSBNO ((xfs_dfsbno_t)-1)
#define NULLDRFSBNO ((xfs_drfsbno_t)-1)
#define NULLDRTBNO ((xfs_drtbno_t)-1)
#define NULLDFILOFF ((xfs_dfiloff_t)-1)
#define NULLFSBLOCK ((xfs_fsblock_t)-1) #define NULLFSBLOCK ((xfs_fsblock_t)-1)
#define NULLRFSBLOCK ((xfs_rfsblock_t)-1) #define NULLRFSBLOCK ((xfs_rfsblock_t)-1)
#define NULLRTBLOCK ((xfs_rtblock_t)-1) #define NULLRTBLOCK ((xfs_rtblock_t)-1)