xfs: patches for 3.13
cover xfs: patches for 3.13
Hi Ben,
This is a repost of the previous series with all the issues your review found fixed up. It also has a few new patches, the first of which is fixing the dir2/ftype offset issue you noticed.
The remaining new patches add a new validity check to the directory block checking code to avoid a reference outside the directory buffer, the patch to avoid stack overflows from the page cache which has been updated to remove the AOP_FLAG_NOFS usage in XFS, and then a final patch to clean up a bunch of new sparse warnings introduced by the recent round of code movement.
Cheers,
Dave.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 1/15 xfs: xfs_remove deadlocks due to inverted AGF vs AGI lock ordering
From: Dave Chinner <[email protected]>
Removing an inode from the namespace involves removing the directory entry and dropping the link count on the inode. Removing the directory entry can result in locking an AGF (directory blocks were freed) and removing a link count can result in placing the inode on an unlinked list which results in locking an AGI.
The big problem here is that we have an ordering constraint on AGF and AGI locking - inode allocation locks the AGI, then can allocate a new extent for new inodes, locking the AGF after the AGI. Similarly, freeing the inode removes the inode from the unlinked list, requiring that we lock the AGI first, and then freeing the inode can result in an inode chunk being freed and hence freeing disk space requiring that we lock an AGF.
Hence the ordering that is imposed by other parts of the code is AGI before AGF. This means we cannot remove the directory entry before we drop the inode reference count and put it on the unlinked list as this results in a lock order of AGF then AGI, and this can deadlock against inode allocation and freeing. Therefore we must drop the link counts before we remove the directory entry.
This is still safe from a transactional point of view - it is not until we get to xfs_bmap_finish() that we have the possibility of multiple transactions in this operation. Hence as long as we remove the directory entry and drop the link count in the first transaction of the remove operation, there are no transactional constraints on the ordering here.
Change the ordering of the operations in the xfs_remove() function to align the ordering of AGI and AGF locking to match that of the rest of the code.
--- fs/xfs/xfs_inode.c | 72 +++++++++++++++++++++++++++++++++--------------------- 1 file changed, 44 insertions(+), 28 deletions(-)
fs/xfs/xfs_inode.c +44 -28
@@ -2404,6 +2404,33 @@ xfs_iunpin_wait(__xfs_iunpin_wait (ip); } +/* +* Removing an inode from the namespace involves removing the directory entry +* and dropping the link count on the inode. Removing the directory entry can +* result in locking an AGF (directory blocks were freed) and removing a link +* count can result in placing the inode on an unlinked list which results in +* locking an AGI. +* +* The big problem here is that we have an ordering constraint on AGF and AGI +* locking - inode allocation locks the AGI, then can allocate a new extent for +* new inodes, locking the AGF after the AGI. Similarly, freeing the inode +* removes the inode from the unlinked list, requiring that we lock the AGI +* first, and then freeing the inode can result in an inode chunk being freed +* and hence freeing disk space requiring that we lock an AGF. +* +* Hence the ordering that is imposed by other parts of the code is AGI before +* AGF. This means we cannot remove the directory entry before we drop the inode +* reference count and put it on the unlinked list as this results in a lock +* order of AGF then AGI, and this can deadlock against inode allocation and +* freeing. Therefore we must drop the link counts before we remove the +* directory entry. +* +* This is still safe from a transactional point of view - it is not until we +* get to xfs_bmap_finish() that we have the possibility of multiple +* transactions in this operation. Hence as long as we remove the directory +* entry and drop the link count in the first transaction of the remove +* operation, there are no transactional constraints on the ordering here. +*/ int xfs_remove( xfs_inode_t *dp,
@@ -2473,6 +2500,7 @@ xfs_remove(/* * If we're removing a directory perform some additional validation. */ + cancel_flags |=XFS_TRANS_ABORT ;if (is_dir) {ASSERT (ip->i_d.di_nlink >=2 );if (ip->i_d.di_nlink !=2 ) {
@@ -2483,31 +2511,16 @@ xfs_remove( error =XFS_ERROR (ENOTEMPTY ); goto out_trans_cancel; } - } -xfs_bmap_init (&free_list, &first_block); - error =xfs_dir_removename (tp, dp, name, ip->i_ino, - &first_block, &free_list, resblks); -if (error) { -ASSERT (error !=ENOENT ); - goto out_bmap_cancel; - } -xfs_trans_ichgtime (tp, dp,XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ); - -if (is_dir) { -/* -* Drop the link from ip's "..". -*/ +/* Drop the link from ip's "..". */ error =xfs_droplink (tp, dp);if (error) - goto out_bmap_cancel; + goto out_trans_cancel; -/* -* Drop the "." link from ip to self. -*/ +/* Drop the "." link from ip to self. */ error =xfs_droplink (tp, ip);if (error) - goto out_bmap_cancel; + goto out_trans_cancel; }else {/* * When removing a non-directory we need to log the parent
@@ -2516,20 +2529,24 @@ xfs_remove(*/ xfs_trans_log_inode (tp, dp,XFS_ILOG_CORE ); } +xfs_trans_ichgtime (tp, dp,XFS_ICHGTIME_MOD |XFS_ICHGTIME_CHG ); -/* -* Drop the link from dp to ip. -*/ +/* Drop the link from dp to ip. */ error =xfs_droplink (tp, ip);if (error) - goto out_bmap_cancel; + goto out_trans_cancel; -/* -* Determine if this is the last link while -* we are in the transaction. -*/ +/* Determine if this is the last link while the inode is locked */ link_zero = (ip->i_d.di_nlink ==0 ); +xfs_bmap_init (&free_list, &first_block); + error =xfs_dir_removename (tp, dp, name, ip->i_ino, + &first_block, &free_list, resblks); +if (error) { +ASSERT (error !=ENOENT ); + goto out_bmap_cancel; + } +/* * If this is a synchronous mount, make sure that the * remove transaction goes to disk before returning to
@@ -2559,7 +2576,6 @@ xfs_remove( out_bmap_cancel:xfs_bmap_cancel (&free_list); - cancel_flags |=XFS_TRANS_ABORT ; out_trans_cancel:xfs_trans_cancel (tp, cancel_flags); std_return:
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 01/15] xfs: xfs_remove deadlocks due to inverted AGF vs AGI lock ordering
Quoted 30 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Removing an inode from the namespace involves removing the directory entry and dropping the link count on the inode. Removing the directory entry can result in locking an AGF (directory blocks were freed) and removing a link count can result in placing the inode on an unlinked list which results in locking an AGI.
The big problem here is that we have an ordering constraint on AGF and AGI locking - inode allocation locks the AGI, then can allocate a new extent for new inodes, locking the AGF after the AGI. Similarly, freeing the inode removes the inode from the unlinked list, requiring that we lock the AGI first, and then freeing the inode can result in an inode chunk being freed and hence freeing disk space requiring that we lock an AGF.
Hence the ordering that is imposed by other parts of the code is AGI before AGF. This means we cannot remove the directory entry before we drop the inode reference count and put it on the unlinked list as this results in a lock order of AGF then AGI, and this can deadlock against inode allocation and freeing. Therefore we must drop the link counts before we remove the directory entry.
This is still safe from a transactional point of view - it is not until we get to
xfs_bmap_finish()that we have the possibility of multiple transactions in this operation. Hence as long as we remove the directory entry and drop the link count in the first transaction of the remove operation, there are no transactional constraints on the ordering here.
Quoted 5 lines
Change the ordering of the operations in the
xfs_remove()function to align the ordering of AGI and AGF locking to match that of the rest of the code.Signed-off-by Dave Chinner <[email protected]>
These two codepaths look plausible for the deadlock you described:
inode allocation locking:xfs_create
xfs_dir_ialloc
xfs_ialloc
xfs_dialloc
xfs_ialloc_read_agi * takes agi
xfs_ialloc_ag_alloc
xfs_alloc_vextent
xfs_alloc_fix_freelist
xfs_alloc_read_agf * takes agf
vs
xfs_remove
xfs_dir_removename
xfs_dir2_node_removename
xfs_dir2_leafn_remove
xfs_dir2_shrink_inode
xfs_bunmapi
. xfs_bmap_del_extent
. xfs_btree_delete
. xfs_btree_delrec
. .free_block
. xfs_bmbt_free_block
. xfs_bmap_add_free * adds to free list, doesn't take agf
xfs_bmap_extents_to_btree
xfs_alloc_vextent * takes agf
xfs_droplink
xfs_iunlink
xfs_read_agi * takes agi
I was thinking I'd find something in .free_block, but I didn't. But it does look like we'll take the agf if we have to convert between directory formats in xfs_dir2_leafn_remove, and it looks like there are a few more opportunities to take the agf in xfs_bunmapi...
Looks good.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 01/15] xfs: xfs_remove deadlocks due to inverted AGF vs AGI lock ordering
Quoted 52 lines · Ben Myers
Quoted 30 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Removing an inode from the namespace involves removing the directory entry and dropping the link count on the inode. Removing the directory entry can result in locking an AGF (directory blocks were freed) and removing a link count can result in placing the inode on an unlinked list which results in locking an AGI.
The big problem here is that we have an ordering constraint on AGF and AGI locking - inode allocation locks the AGI, then can allocate a new extent for new inodes, locking the AGF after the AGI. Similarly, freeing the inode removes the inode from the unlinked list, requiring that we lock the AGI first, and then freeing the inode can result in an inode chunk being freed and hence freeing disk space requiring that we lock an AGF.
Hence the ordering that is imposed by other parts of the code is AGI before AGF. This means we cannot remove the directory entry before we drop the inode reference count and put it on the unlinked list as this results in a lock order of AGF then AGI, and this can deadlock against inode allocation and freeing. Therefore we must drop the link counts before we remove the directory entry.
This is still safe from a transactional point of view - it is not until we get to
xfs_bmap_finish()that we have the possibility of multiple transactions in this operation. Hence as long as we remove the directory entry and drop the link count in the first transaction of the remove operation, there are no transactional constraints on the ordering here.Quoted 5 lines
Change the ordering of the operations in the
xfs_remove()function to align the ordering of AGI and AGF locking to match that of the rest of the code.Signed-off-by Dave Chinner <[email protected]>These two codepaths look plausible for the deadlock you described:
inode allocation locking:
xfs_create
xfs_dir_ialloc
xfs_ialloc
xfs_dialloc
xfs_ialloc_read_agi* takes agi
xfs_ialloc_ag_alloc
xfs_alloc_vextent
xfs_alloc_fix_freelist
xfs_alloc_read_agf* takes agfvs
Quoted 14 lines
xfs_remove
xfs_dir_removename
xfs_dir2_node_removename
xfs_dir2_leafn_remove
xfs_dir2_shrink_inode
xfs_bunmapi
.xfs_bmap_del_extent
.xfs_btree_delete
.xfs_btree_delrec
. .free_block
.xfs_bmbt_free_block
.xfs_bmap_add_free* adds to free list, doesn't take agf
xfs_bmap_extents_to_btree
xfs_alloc_vextent* takes agf
Yeah, that's not the obvious or common path, but it has the same cause of allocation - it's a bmbt block that gets allocated. i.e. removing a block from the middle of a contiguous extent can result in the extent tree growing, and hence needing allocation of block for the new entry. This is the path I was hitting:
....
xfs_dir2_shrink_inode
xfs_bunmapi
xfs_bmap_del_extent
case 0: /* delete middle of extent */ xfs_btree_update xfs_btree_increment xfs_btree_insert
xfs_btree_insrec
xfs_btree_make_block_unfull
xfs_btree_split
.alloc_block
xfs_bmbt_alloc_block
xfs_alloc_vextent * takes agf
Quoted 1 line
I was thinking I'd find something in .free_block, but I didn't.
Right, data extents are added to the free list that is later walked and freed via xfs_bmap_finish() after it adds an EFI to match the free list to the current transaction the free list belongs to and commits it.
Quoted 4 lines
But it does
look like we'll take the agf if we have to convert between directory formats inxfs_dir2_leafn_remove, and it looks like there are a few more opportunities to take the agf inxfs_bunmapi...
Yup, but with the above call chain, any random block removal can cause a bmbt allocation to occur, so we don't really need to look any further. Indeed, you should just assume that any call to xfs_bunmapi() to free an extent will require block allocation....
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Ben Myers
AppliedRe: [PATCH 01/15] xfs: xfs_remove deadlocks due to inverted AGF vs AGI lock ordering
Quoted 102 lines · Dave Chinner
Quoted 52 lines · Ben Myers
Quoted 30 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Removing an inode from the namespace involves removing the directory entry and dropping the link count on the inode. Removing the directory entry can result in locking an AGF (directory blocks were freed) and removing a link count can result in placing the inode on an unlinked list which results in locking an AGI.
The big problem here is that we have an ordering constraint on AGF and AGI locking - inode allocation locks the AGI, then can allocate a new extent for new inodes, locking the AGF after the AGI. Similarly, freeing the inode removes the inode from the unlinked list, requiring that we lock the AGI first, and then freeing the inode can result in an inode chunk being freed and hence freeing disk space requiring that we lock an AGF.
Hence the ordering that is imposed by other parts of the code is AGI before AGF. This means we cannot remove the directory entry before we drop the inode reference count and put it on the unlinked list as this results in a lock order of AGF then AGI, and this can deadlock against inode allocation and freeing. Therefore we must drop the link counts before we remove the directory entry.
This is still safe from a transactional point of view - it is not until we get to
xfs_bmap_finish()that we have the possibility of multiple transactions in this operation. Hence as long as we remove the directory entry and drop the link count in the first transaction of the remove operation, there are no transactional constraints on the ordering here.Quoted 5 lines
Change the ordering of the operations in the
xfs_remove()function to align the ordering of AGI and AGF locking to match that of the rest of the code.Signed-off-by Dave Chinner <[email protected]>These two codepaths look plausible for the deadlock you described:
inode allocation locking:
xfs_create
xfs_dir_ialloc
xfs_ialloc
xfs_dialloc
xfs_ialloc_read_agi* takes agi
xfs_ialloc_ag_alloc
xfs_alloc_vextent
xfs_alloc_fix_freelist
xfs_alloc_read_agf* takes agfvs
Quoted 14 lines
xfs_remove
xfs_dir_removename
xfs_dir2_node_removename
xfs_dir2_leafn_remove
xfs_dir2_shrink_inode
xfs_bunmapi
.xfs_bmap_del_extent
.xfs_btree_delete
.xfs_btree_delrec
. .free_block
.xfs_bmbt_free_block
.xfs_bmap_add_free* adds to free list, doesn't take agf
xfs_bmap_extents_to_btree
xfs_alloc_vextent* takes agfYeah, that's not the obvious or common path, but it has the same cause of allocation - it's a bmbt block that gets allocated. i.e. removing a block from the middle of a contiguous extent can result in the extent tree growing, and hence needing allocation of block for the new entry. This is the path I was hitting:
....
xfs_dir2_shrink_inode
xfs_bunmapi
xfs_bmap_del_extent
case 0: /* delete middle of extent */xfs_btree_updatexfs_btree_incrementxfs_btree_insert
xfs_btree_insrec
xfs_btree_make_block_unfull
xfs_btree_split
.alloc_block
xfs_bmbt_alloc_block
xfs_alloc_vextent* takes agfQuoted 1 line
I was thinking I'd find something in .free_block, but I didn't.
Right, data extents are added to the free list that is later walked and freed via
xfs_bmap_finish()after it adds an EFI to match the free list to the current transaction the free list belongs to and commits it.Quoted 4 lines
But it does
look like we'll take the agf if we have to convert between directory formats inxfs_dir2_leafn_remove, and it looks like there are a few more opportunities to take the agf inxfs_bunmapi...
Quoted 4 lines
Yup, but with the above call chain, any random block removal can cause a bmbt allocation to occur, so we don't really need to look any further. Indeed, you should just assume that any call to
xfs_bunmapi()to free an extent will require block allocation....
Applied this. Thanks Dave.
-Ben
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 2/15 xfs: open code inc_inode_iversion when logging an inode
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Michael L Semon reported that generic/069 runtime increased on v5 superblocks by 100% compared to v4 superblocks. his perf-based analysis pointed directly at the timestamp updates being done by the write path in this workload. The append writers are doing 4-byte writes, so there are lots of timestamp updates occurring.
The thing is, they aren't being triggered by timestamp changes - they are being triggered by the inode change counter needing to be updated. That is, every write(2) system call needs to bump the inode version count, and it does that through the timestamp update mechanism. Hence for v5 filesystems, test generic/069 is running 3 orders of magnitude more timestmap update transactions on v5 filesystems due to the fact it does a huge number of *4 byte* write(2) calls.
This isn't a real world scenario we really need to address - anyone doing such sequential IO should be using fwrite(3), not write(2). i.e. fwrite(3) buffers the writes in userspace to minimise the number of write(2) syscalls, and the problem goes away.
However, there is a small change we can make to improve the situation - removing the expensive lock operation on the change counter update. All inode version counter changes in XFS occur under the ip->i_ilock during a transaction, and therefore we don't actually need the spin lock that provides exclusive access to it through inc_inode_iversion().
Hence avoid the lock and just open code the increment ourselves when logging the inode.
--- fs/xfs/xfs_trans_inode.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)
fs/xfs/xfs_trans_inode.c +5 -3
@@ -111,12 +111,14 @@ xfs_trans_log_inode(/* * First time we log the inode in a transaction, bump the inode change -* counter if it is configured for this to occur. +* counter if it is configured for this to occur. We don't use +* inode_inc_version() because there is no need for extra locking around +* i_version as we already hold the inode locked exclusively for +* metadata modification. */ if (!(ip->i_itemp->ili_item.li_desc->lid_flags &XFS_LID_DIRTY ) &&IS_I_VERSION (VFS_I (ip))) { -inode_inc_iversion (VFS_I (ip)); - ip->i_d.di_changecount =VFS_I (ip)->i_version; + ip->i_d.di_changecount = ++VFS_I (ip)->i_version; flags |=XFS_ILOG_CORE ; }
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 3/15 xfs: abstract the differences in dir2/dir3 via an ops vector
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Lots of the dir code now goes through switches to determine what is the correct on-disk format to parse. It generally involves a "xfs_sbversion_hasfoo" check, deferencing the superblock version and feature fields and hence touching several cache lines per operation in the process. Some operations do multiple checks because they nest conditional operations and they don't pass the information in a direct fashion between each other.
Hence, add an ops vector to the xfs_inode structure that is configured when the inode is initialised to point to all the correct decode and encoding operations. This will significantly reduce the branchiness and cacheline footprint of the directory object decoding and encoding.
This is the first patch in a series of conversion patches. It will introduce the ops structure, the setup of it and add the first operation to the vector. Subsequent patches will convert directory ops one at a time to keep the changes simple and obvious.
Just this patch shows the benefit of such an approach on code size. Just converting the two shortform dir operations as this patch does decreases the built binary size by ~1500 bytes:
$ size fs/xfs/xfs.o.orig fs/xfs/xfs.o.p1 text data bss dec hex filename 794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 $
That's a significant decrease in the instruction cache footprint of the directory code for such a simple change, and indicates that this approach is definitely worth pursuing further.
--- fs/xfs/Makefile | 1 + fs/xfs/xfs_da_btree.h | 1 + fs/xfs/xfs_da_format.c | 85 +++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_da_format.h | 26 --------------- fs/xfs/xfs_dir2.c | 7 ++++ fs/xfs/xfs_dir2.h | 14 ++++++++ fs/xfs/xfs_dir2_block.c | 2 +- fs/xfs/xfs_dir2_readdir.c | 4 +-- fs/xfs/xfs_dir2_sf.c | 31 +++++++++-------- fs/xfs/xfs_inode.h | 3 ++ fs/xfs/xfs_iops.c | 1 + fs/xfs/xfs_mount.h | 2 ++ 12 files changed, 132 insertions(+), 45 deletions(-) create mode 100644 fs/xfs/xfs_da_format.c
fs/xfs/Makefile +1 -0
@@ -66,6 +66,7 @@ xfs-y += xfs_alloc.o \ xfs_bmap_btree.o \ xfs_btree.o \ xfs_da_btree.o \ + xfs_da_format.o \ xfs_dir2.o \ xfs_dir2_block.o \ xfs_dir2_data.o \
fs/xfs/xfs_da_btree.h +1 -0
@@ -23,6 +23,7 @@ struct xfs_bmap_free;struct xfs_inode ;struct xfs_trans ;struct zone ; +struct xfs_dir_ops ;/*======================================================================== * Btree searching and modification structure definitions.
fs/xfs/xfs_da_format.c new file +85 -0
85 lines not on this page · raw message
fs/xfs/xfs_da_format.h +0 -26
@@ -329,32 +329,6 @@ xfs_dir2_sf_firstentry(struct xfs_dir2_sf_hdr *hdr) ((char *)hdr +xfs_dir2_sf_hdr_size (hdr->i8count)); } -static inline int -xfs_dir3_sf_entsize ( -struct xfs_mount *mp, -struct xfs_dir2_sf_hdr *hdr, -int len) -{ -int count =sizeof (struct xfs_dir2_sf_entry );/* namelen + offset */ - - count += len;/* name */ - count += hdr->i8count ?sizeof (xfs_dir2_ino8_t) : -sizeof (xfs_dir2_ino4_t);/* ino # */ -if (xfs_sb_version_hasftype (&mp->m_sb)) - count +=sizeof (__uint8_t);/* file type */ -return count; -} - -static inline struct xfs_dir2_sf_entry * -xfs_dir3_sf_nextentry ( -struct xfs_mount *mp, -struct xfs_dir2_sf_hdr *hdr, -struct xfs_dir2_sf_entry *sfep) -{ -return (struct xfs_dir2_sf_entry *) - ((char *)sfep +xfs_dir3_sf_entsize (mp, hdr, sfep->namelen)); -} -/* * in dir3 shortform directories, the file type field is stored at a variable * offset after the inode number. Because it's only a single byte, endian
fs/xfs/xfs_dir2.c +7 -0
@@ -112,6 +112,13 @@ xfs_dir_mount( mp->m_dirnameops = &xfs_ascii_ci_nameops; else mp->m_dirnameops = &xfs_default_nameops; + +if (xfs_sb_version_hascrc (&mp->m_sb)) + mp->m_dir_inode_ops = &xfs_dir3_ops; +else if (xfs_sb_version_hasftype (&mp->m_sb)) + mp->m_dir_inode_ops = &xfs_dir2_ftype_ops; +else + mp->m_dir_inode_ops = &xfs_dir2_ops; }/*
fs/xfs/xfs_dir2.h +14 -0
@@ -32,6 +32,20 @@ struct xfs_dir2_data_unused;extern struct xfs_name xfs_name_dotdot;/* +* directory operations vector for encode/decode routines +*/ +struct xfs_dir_ops { +int (*sf_entsize)(struct xfs_dir2_sf_hdr *hdr,int len); +struct xfs_dir2_sf_entry * + (*sf_nextentry)(struct xfs_dir2_sf_hdr *hdr, +struct xfs_dir2_sf_entry *sfep); +}; + +extern const struct xfs_dir_ops xfs_dir2_ops; +extern const struct xfs_dir_ops xfs_dir2_ftype_ops; +extern const struct xfs_dir_ops xfs_dir3_ops; + +/* * Generic directory interface routines */ extern void xfs_dir_startup (void );
fs/xfs/xfs_dir2_block.c +1 -1
@@ -1240,7 +1240,7 @@ xfs_dir2_sf_to_block(if (++i == sfp->count) sfep =NULL ;else - sfep =xfs_dir3_sf_nextentry (mp, sfp, sfep); + sfep = dp->d_ops->sf_nextentry (sfp, sfep); }/* Done with the temporary buffer */ kmem_free (sfp);
fs/xfs/xfs_dir2_readdir.c +2 -2
@@ -153,7 +153,7 @@ xfs_dir2_sf_getdents( xfs_dir2_sf_get_offset(sfep));if (ctx->pos > off) { - sfep =xfs_dir3_sf_nextentry (mp, sfp, sfep); + sfep = dp->d_ops->sf_nextentry (sfp, sfep);continue ; }
@@ -163,7 +163,7 @@ xfs_dir2_sf_getdents(if (!dir_emit (ctx, (char *)sfep->name, sfep->namelen, ino,xfs_dir3_get_dtype (mp, filetype)))return 0 ; - sfep =xfs_dir3_sf_nextentry (mp, sfp, sfep); + sfep = dp->d_ops->sf_nextentry (sfp, sfep); } ctx->pos = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk + 1, 0) &
fs/xfs/xfs_dir2_sf.c +15 -16
@@ -336,7 +336,7 @@ xfs_dir2_block_to_sf(xfs_dir3_sfe_put_ftype (mp, sfp, sfep,xfs_dir3_dirent_get_ftype (mp, dep)); - sfep =xfs_dir3_sf_nextentry (mp, sfp, sfep); + sfep = dp->d_ops->sf_nextentry (sfp, sfep); } ptr +=xfs_dir3_data_entsize (mp, dep->namelen); }
@@ -389,7 +389,7 @@ xfs_dir2_sf_addname(/* * Compute entry (and change in) size. */ - add_entsize =xfs_dir3_sf_entsize (dp->i_mount, sfp, args->namelen); + add_entsize = dp->d_ops->sf_entsize (sfp, args->namelen); incr_isize = add_entsize; objchange =0 ;#if XFS_BIG_INUMS
@@ -483,8 +483,7 @@ xfs_dir2_sf_addname_easy(/* * Grow the in-inode space. */ -xfs_idata_realloc (dp, -xfs_dir3_sf_entsize (dp->i_mount, sfp, args->namelen), +xfs_idata_realloc (dp, dp->d_ops->sf_entsize (sfp, args->namelen),XFS_DATA_FORK );/* * Need to set up again due to realloc of the inode data.
@@ -563,7 +562,7 @@ xfs_dir2_sf_addname_hard( eof = (char *)oldsfep == &buf[old_isize]; !eof; offset = new_offset + xfs_dir3_data_entsize(mp, oldsfep->namelen), - oldsfep = xfs_dir3_sf_nextentry(mp, oldsfp, oldsfep), + oldsfep = dp->d_ops->sf_nextentry(oldsfp, oldsfep), eof = (char *)oldsfep == &buf[old_isize]) { new_offset =xfs_dir2_sf_get_offset (oldsfep);if (offset + add_datasize <= new_offset)
@@ -603,7 +602,7 @@ xfs_dir2_sf_addname_hard(* If there's more left to copy, do that. */ if (!eof) { - sfep =xfs_dir3_sf_nextentry (mp, sfp, sfep); + sfep = dp->d_ops->sf_nextentry (sfp, sfep);memcpy (sfep, oldsfep, old_isize - nbytes); }kmem_free (buf);
@@ -653,7 +652,7 @@ xfs_dir2_sf_addname_pick( holefit = offset + size <=xfs_dir2_sf_get_offset (sfep); offset =xfs_dir2_sf_get_offset (sfep) +xfs_dir3_data_entsize (mp, sfep->namelen); - sfep =xfs_dir3_sf_nextentry (mp, sfp, sfep); + sfep = dp->d_ops->sf_nextentry (sfp, sfep); }/* * Calculate data bytes used excluding the new entry, if this
@@ -719,7 +718,7 @@ xfs_dir2_sf_check(for (i =0 , sfep =xfs_dir2_sf_firstentry (sfp); i < sfp->count; - i++, sfep =xfs_dir3_sf_nextentry (mp, sfp, sfep)) { + i++, sfep = dp->d_ops->sf_nextentry (sfp, sfep)) {ASSERT (xfs_dir2_sf_get_offset (sfep) >= offset); ino =xfs_dir3_sfe_get_ino (mp, sfp, sfep); i8count += ino >XFS_DIR2_MAX_SHORT_INUM ;
@@ -848,7 +847,7 @@ xfs_dir2_sf_lookup(*/ ci_sfep =NULL ;for (i =0 , sfep =xfs_dir2_sf_firstentry (sfp); i < sfp->count; - i++, sfep =xfs_dir3_sf_nextentry (dp->i_mount, sfp, sfep)) { + i++, sfep = dp->d_ops->sf_nextentry (sfp, sfep)) {/* * Compare name and if it's an exact match, return the inode * number. If it's the first case-insensitive match, store the
@@ -917,7 +916,7 @@ xfs_dir2_sf_removename(* Find the one we're deleting. */ for (i =0 , sfep =xfs_dir2_sf_firstentry (sfp); i < sfp->count; - i++, sfep =xfs_dir3_sf_nextentry (dp->i_mount, sfp, sfep)) { + i++, sfep = dp->d_ops->sf_nextentry (sfp, sfep)) {if (xfs_da_compname (args, sfep->name, sfep->namelen) ==XFS_CMP_EXACT ) { ASSERT(xfs_dir3_sfe_get_ino(dp->i_mount, sfp, sfep) ==
@@ -934,7 +933,7 @@ xfs_dir2_sf_removename(* Calculate sizes. */ byteoff = (int )((char *)sfep - (char *)sfp); - entsize =xfs_dir3_sf_entsize (dp->i_mount, sfp, args->namelen); + entsize = dp->d_ops->sf_entsize (sfp, args->namelen); newsize = oldsize - entsize;/* * Copy the part if any after the removed entry, sliding it down.
@@ -1051,7 +1050,7 @@ xfs_dir2_sf_replace(*/ else {for (i =0 , sfep =xfs_dir2_sf_firstentry (sfp); i < sfp->count; - i++, sfep =xfs_dir3_sf_nextentry (dp->i_mount, sfp, sfep)) { + i++, sfep = dp->d_ops->sf_nextentry (sfp, sfep)) {if (xfs_da_compname (args, sfep->name, sfep->namelen) ==XFS_CMP_EXACT ) {#if XFS_BIG_INUMS || defined(DEBUG )
@@ -1172,8 +1171,8 @@ xfs_dir2_sf_toino4(for (i =0 , sfep =xfs_dir2_sf_firstentry (sfp), oldsfep =xfs_dir2_sf_firstentry (oldsfp); i < sfp->count; - i++, sfep =xfs_dir3_sf_nextentry (mp, sfp, sfep), - oldsfep =xfs_dir3_sf_nextentry (mp, oldsfp, oldsfep)) { + i++, sfep = dp->d_ops->sf_nextentry (sfp, sfep), + oldsfep = dp->d_ops->sf_nextentry (oldsfp, oldsfep)) { sfep->namelen = oldsfep->namelen; sfep->offset = oldsfep->offset;memcpy (sfep->name, oldsfep->name, sfep->namelen);
@@ -1251,8 +1250,8 @@ xfs_dir2_sf_toino8(for (i =0 , sfep =xfs_dir2_sf_firstentry (sfp), oldsfep =xfs_dir2_sf_firstentry (oldsfp); i < sfp->count; - i++, sfep =xfs_dir3_sf_nextentry (mp, sfp, sfep), - oldsfep =xfs_dir3_sf_nextentry (mp, oldsfp, oldsfep)) { + i++, sfep = dp->d_ops->sf_nextentry (sfp, sfep), + oldsfep = dp->d_ops->sf_nextentry (oldsfp, oldsfep)) { sfep->namelen = oldsfep->namelen; sfep->offset = oldsfep->offset;memcpy (sfep->name, oldsfep->name, sfep->namelen);
fs/xfs/xfs_inode.h +3 -0
@@ -49,6 +49,9 @@ typedef struct xfs_inode {xfs_ifork_t *i_afp;/* attribute fork pointer */ xfs_ifork_t i_df;/* data fork */ +/* operations vectors */ +const struct xfs_dir_ops *d_ops;/* directory ops vector */ +/* Transaction and locking information. */ struct xfs_inode_log_item *i_itemp;/* logging information */ mrlock_t i_lock;/* inode lock */
fs/xfs/xfs_iops.c +1 -0
@@ -1215,6 +1215,7 @@ xfs_setup_inode(else inode->i_op = &xfs_dir_inode_operations; inode->i_fop = &xfs_dir_file_operations; + ip->d_ops = ip->i_mount->m_dir_inode_ops;break ;case S_IFLNK : inode->i_op = &xfs_symlink_inode_operations;
fs/xfs/xfs_mount.h +2 -0
@@ -26,6 +26,7 @@ struct xfs_mru_cache;struct xfs_nameops ;struct xfs_ail ;struct xfs_quotainfo ; +struct xfs_dir_ops ;#ifdef HAVE_PERCPU_SB
@@ -148,6 +149,7 @@ typedef struct xfs_mount {int m_dir_magicpct;/* 37% of the dir blocksize */ __uint8_t m_sectbb_log;/* sectlog - BBSHIFT */ const struct xfs_nameops *m_dirnameops;/* vector of dir name ops */ +const struct xfs_dir_ops *m_dir_inode_ops;/* vector of dir inode ops */ int m_dirblksize;/* directory block sz--bytes */ int m_dirblkfsbs;/* directory block sz--fsbs */ xfs_dablk_t m_dirdatablk;/* blockno of dir data v2 */
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 4/15 xfs: vectorise remaining shortform dir2 ops
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Following from the initial patch to introduce the directory operations vector, convert the rest of the shortform directory operations to use vectored ops rather than superblock feature checks. This further reduces the size of the built binary:
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2
--- fs/xfs/xfs_da_format.c | 152 ++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_da_format.h | 47 -------------- fs/xfs/xfs_dir2.h | 20 +++--- fs/xfs/xfs_dir2_block.c | 6 +- fs/xfs/xfs_dir2_readdir.c | 6 +- fs/xfs/xfs_dir2_sf.c | 151 +++++++++------------------------------------ 6 files changed, 199 insertions(+), 183 deletions(-)
fs/xfs/xfs_da_format.c +152 -0
@@ -69,17 +69,169 @@ xfs_dir3_sf_nextentry( } +/* +* For filetype enabled shortform directories, the file type field is stored at +* the end of the name. Because it's only a single byte, endian conversion is +* not necessary. For non-filetype enable directories, the type is always +* unknown and we never store the value. +*/ +static __uint8_t +xfs_dir2_sfe_get_ftype ( +struct xfs_dir2_sf_entry *sfep) +{ +return XFS_DIR3_FT_UNKNOWN ; +} + +static void +xfs_dir2_sfe_put_ftype ( +struct xfs_dir2_sf_entry *sfep, +__uint8_t ftype) +{ +ASSERT (ftype <XFS_DIR3_FT_MAX ); +} + +static __uint8_t +xfs_dir3_sfe_get_ftype ( +struct xfs_dir2_sf_entry *sfep) +{ +__uint8_t ftype; + + ftype = sfep->name[sfep->namelen]; +if (ftype >=XFS_DIR3_FT_MAX ) +return XFS_DIR3_FT_UNKNOWN ; +return ftype; +} + +static void +xfs_dir3_sfe_put_ftype ( +struct xfs_dir2_sf_entry *sfep, +__uint8_t ftype) +{ +ASSERT (ftype <XFS_DIR3_FT_MAX ); + + sfep->name[sfep->namelen] = ftype; +} + +/* +* Inode numbers in short-form directories can come in two versions, +* either 4 bytes or 8 bytes wide. These helpers deal with the +* two forms transparently by looking at the headers i8count field. +* +* For 64-bit inode number the most significant byte must be zero. +*/ +static xfs_ino_t +xfs_dir2_sf_get_ino ( +struct xfs_dir2_sf_hdr *hdr, +xfs_dir2_inou_t *from) +{ +if (hdr->i8count) +return get_unaligned_be64 (&from->i8.i) &0x00ffffffffffffffULL ; +else +return get_unaligned_be32 (&from->i4.i); +} + +static void +xfs_dir2_sf_put_ino ( +struct xfs_dir2_sf_hdr *hdr, +xfs_dir2_inou_t *to, +xfs_ino_t ino) +{ +ASSERT ((ino &0xff00000000000000ULL ) ==0 ); + +if (hdr->i8count) +put_unaligned_be64 (ino, &to->i8.i); +else +put_unaligned_be32 (ino, &to->i4.i); +} + +static xfs_ino_t +xfs_dir2_sf_get_parent_ino ( +struct xfs_dir2_sf_hdr *hdr) +{ +return xfs_dir2_sf_get_ino (hdr, &hdr->parent); +} + +static void +xfs_dir2_sf_put_parent_ino ( +struct xfs_dir2_sf_hdr *hdr, +xfs_ino_t ino) +{ +xfs_dir2_sf_put_ino (hdr, &hdr->parent, ino); +} + +/* +* In short-form directory entries the inode numbers are stored at variable +* offset behind the entry name. If the entry stores a filetype value, then it +* sits between the name and the inode number. Hence the inode numbers may only +* be accessed through the helpers below. +*/ +static xfs_ino_t +xfs_dir2_sfe_get_ino ( +struct xfs_dir2_sf_hdr *hdr, +struct xfs_dir2_sf_entry *sfep) +{ +return xfs_dir2_sf_get_ino (hdr, + (xfs_dir2_inou_t *)&sfep->name[sfep->namelen]); +} + +static void +xfs_dir2_sfe_put_ino ( +struct xfs_dir2_sf_hdr *hdr, +struct xfs_dir2_sf_entry *sfep, +xfs_ino_t ino) +{ +xfs_dir2_sf_put_ino (hdr, + (xfs_dir2_inou_t *)&sfep->name[sfep->namelen], ino); +} + +static xfs_ino_t +xfs_dir3_sfe_get_ino ( +struct xfs_dir2_sf_hdr *hdr, +struct xfs_dir2_sf_entry *sfep) +{ +return xfs_dir2_sf_get_ino (hdr, + (xfs_dir2_inou_t *)&sfep->name[sfep->namelen +1 ]); +} + +static void +xfs_dir3_sfe_put_ino ( +struct xfs_dir2_sf_hdr *hdr, +struct xfs_dir2_sf_entry *sfep, +xfs_ino_t ino) +{ +xfs_dir2_sf_put_ino (hdr, + (xfs_dir2_inou_t *)&sfep->name[sfep->namelen +1 ], ino); +} +const struct xfs_dir_ops xfs_dir2_ops = { .sf_entsize = xfs_dir2_sf_entsize, .sf_nextentry = xfs_dir2_sf_nextentry, + .sf_get_ftype = xfs_dir2_sfe_get_ftype, + .sf_put_ftype = xfs_dir2_sfe_put_ftype, + .sf_get_ino = xfs_dir2_sfe_get_ino, + .sf_put_ino = xfs_dir2_sfe_put_ino, + .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino, + .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino, };const struct xfs_dir_ops xfs_dir2_ftype_ops = { .sf_entsize = xfs_dir3_sf_entsize, .sf_nextentry = xfs_dir3_sf_nextentry, + .sf_get_ftype = xfs_dir3_sfe_get_ftype, + .sf_put_ftype = xfs_dir3_sfe_put_ftype, + .sf_get_ino = xfs_dir3_sfe_get_ino, + .sf_put_ino = xfs_dir3_sfe_put_ino, + .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino, + .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino, };const struct xfs_dir_ops xfs_dir3_ops = { .sf_entsize = xfs_dir3_sf_entsize, .sf_nextentry = xfs_dir3_sf_nextentry, + .sf_get_ftype = xfs_dir3_sfe_get_ftype, + .sf_put_ftype = xfs_dir3_sfe_put_ftype, + .sf_get_ino = xfs_dir3_sfe_get_ino, + .sf_put_ino = xfs_dir3_sfe_put_ino, + .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino, + .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino, };
fs/xfs/xfs_da_format.h +0 -47
53 lines not on this page · raw message
fs/xfs/xfs_dir2.h +11 -9
@@ -39,6 +39,17 @@ struct xfs_dir_ops {struct xfs_dir2_sf_entry * (*sf_nextentry)(struct xfs_dir2_sf_hdr *hdr,struct xfs_dir2_sf_entry *sfep); +__uint8_t (*sf_get_ftype)(struct xfs_dir2_sf_entry *sfep); +void (*sf_put_ftype)(struct xfs_dir2_sf_entry *sfep, +__uint8_t ftype); +xfs_ino_t (*sf_get_ino)(struct xfs_dir2_sf_hdr *hdr, +struct xfs_dir2_sf_entry *sfep); +void (*sf_put_ino)(struct xfs_dir2_sf_hdr *hdr, +struct xfs_dir2_sf_entry *sfep, +xfs_ino_t ino); +xfs_ino_t (*sf_get_parent_ino)(struct xfs_dir2_sf_hdr *hdr); +void (*sf_put_parent_ino)(struct xfs_dir2_sf_hdr *hdr, +xfs_ino_t ino); };extern const struct xfs_dir_ops xfs_dir2_ops;
@@ -79,15 +90,6 @@ extern int xfs_dir2_sf_to_block(struct xfs_da_args *args);/* * Interface routines used by userspace utilities */ -extern xfs_ino_t xfs_dir2_sf_get_parent_ino (struct xfs_dir2_sf_hdr *sfp); -extern void xfs_dir2_sf_put_parent_ino (struct xfs_dir2_sf_hdr *sfp, -xfs_ino_t ino); -extern xfs_ino_t xfs_dir3_sfe_get_ino (struct xfs_mount *mp, -struct xfs_dir2_sf_hdr *sfp,struct xfs_dir2_sf_entry *sfep); -extern void xfs_dir3_sfe_put_ino (struct xfs_mount *mp, -struct xfs_dir2_sf_hdr *hdr,struct xfs_dir2_sf_entry *sfep, -xfs_ino_t ino); -extern int xfs_dir2_isblock (struct xfs_trans *tp,struct xfs_inode *dp,int *r);extern int xfs_dir2_isleaf (struct xfs_trans *tp,struct xfs_inode *dp,int *r); extern int xfs_dir2_shrink_inode(struct xfs_da_args *args, xfs_dir2_db_t db,
fs/xfs/xfs_dir2_block.c +3 -3
@@ -1173,7 +1173,7 @@ xfs_dir2_sf_to_block(* Create entry for .. */ dep =xfs_dir3_data_dotdot_entry_p (mp, hdr); - dep->inumber =cpu_to_be64 (xfs_dir2_sf_get_parent_ino (sfp)); + dep->inumber =cpu_to_be64 (dp->d_ops->sf_get_parent_ino (sfp)); dep->namelen =2 ; dep->name[0 ] = dep->name[1 ] ='.' ;xfs_dir3_dirent_put_ftype (mp, dep,XFS_DIR3_FT_DIR );
@@ -1222,10 +1222,10 @@ xfs_dir2_sf_to_block(* Copy a real entry. */ dep = (xfs_dir2_data_entry_t *)((char *)hdr + newoffset); - dep->inumber =cpu_to_be64 (xfs_dir3_sfe_get_ino (mp, sfp, sfep)); + dep->inumber =cpu_to_be64 (dp->d_ops->sf_get_ino (sfp, sfep)); dep->namelen = sfep->namelen;xfs_dir3_dirent_put_ftype (mp, dep, -xfs_dir3_sfe_get_ftype (mp, sfp, sfep)); + dp->d_ops->sf_get_ftype (sfep));memcpy (dep->name, sfep->name, dep->namelen); tagp =xfs_dir3_data_entry_tag_p (mp, dep); *tagp =cpu_to_be16 ((char *)dep - (char *)hdr);
fs/xfs/xfs_dir2_readdir.c +3 -3
@@ -136,7 +136,7 @@ xfs_dir2_sf_getdents(* Put .. entry unless we're starting past it. */ if (ctx->pos <= dotdot_offset) { - ino =xfs_dir2_sf_get_parent_ino (sfp); + ino = dp->d_ops->sf_get_parent_ino (sfp); ctx->pos = dotdot_offset &0x7fffffff ;if (!dir_emit (ctx,".." ,2 , ino,DT_DIR ))return 0 ;
@@ -157,8 +157,8 @@ xfs_dir2_sf_getdents(continue ; } - ino =xfs_dir3_sfe_get_ino (mp, sfp, sfep); - filetype =xfs_dir3_sfe_get_ftype (mp, sfp, sfep); + ino = dp->d_ops->sf_get_ino (sfp, sfep); + filetype = dp->d_ops->sf_get_ftype (sfep); ctx->pos = off &0x7fffffff ;if (!dir_emit (ctx, (char *)sfep->name, sfep->namelen, ino,xfs_dir3_get_dtype (mp, filetype)))
fs/xfs/xfs_dir2_sf.c +30 -121
267 lines not on this page · raw message
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 5/15 xfs: vectorise directory data operations
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Following from the initial patches to vectorise the shortform directory encode/decode operations, convert half the data block operations to use the vector. The rest will be done in a second patch.
This further reduces the size of the built binary:
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3
--- fs/xfs/xfs_da_format.c | 218 +++++++++++++++++++++++++++++++++++++++++++++- fs/xfs/xfs_da_format.h | 123 -------------------------- fs/xfs/xfs_dir2.h | 22 ++++- fs/xfs/xfs_dir2_block.c | 54 ++++++------ fs/xfs/xfs_dir2_data.c | 38 +++++--- fs/xfs/xfs_dir2_leaf.c | 22 ++--- fs/xfs/xfs_dir2_node.c | 23 ++--- fs/xfs/xfs_dir2_readdir.c | 14 +-- fs/xfs/xfs_dir2_sf.c | 20 ++--- 9 files changed, 329 insertions(+), 205 deletions(-)
fs/xfs/xfs_da_format.c +217 -1
@@ -28,7 +28,9 @@#include "xfs_inode.h" #include "xfs_dir2.h" - +/* +* Shortform directory ops +*/ static int xfs_dir2_sf_entsize( struct xfs_dir2_sf_hdr *hdr,
@@ -203,6 +205,184 @@ xfs_dir3_sfe_put_ino( (xfs_dir2_inou_t *)&sfep->name[sfep->namelen + 1], ino); } + +/* +* Directory data block operations +*/ +static int +__xfs_dir3_data_entsize ( +bool ftype, +int n) +{ + int size = offsetof(struct xfs_dir2_data_entry, name[0]); + + size += n; + size +=sizeof (xfs_dir2_data_off_t); +if (ftype) + size +=sizeof (__uint8_t); +return roundup (size,XFS_DIR2_DATA_ALIGN ); +} + +static int +xfs_dir2_data_entsize ( +int n) +{ +return __xfs_dir3_data_entsize (false, n); +} +static int +xfs_dir3_data_entsize ( +int n) +{ +return __xfs_dir3_data_entsize (true, n); +} + +static __uint8_t +xfs_dir2_data_get_ftype ( +struct xfs_dir2_data_entry *dep) +{ +return XFS_DIR3_FT_UNKNOWN ; +} + +static void +xfs_dir2_data_put_ftype ( +struct xfs_dir2_data_entry *dep, +__uint8_t ftype) +{ +ASSERT (ftype <XFS_DIR3_FT_MAX ); +} + +static __uint8_t +xfs_dir3_data_get_ftype ( +struct xfs_dir2_data_entry *dep) +{ +__uint8_t ftype = dep->name[dep->namelen]; + +ASSERT (ftype <XFS_DIR3_FT_MAX ); +if (ftype >=XFS_DIR3_FT_MAX ) +return XFS_DIR3_FT_UNKNOWN ; +return ftype; +} + +static void +xfs_dir3_data_put_ftype ( +struct xfs_dir2_data_entry *dep, +__uint8_t type) +{ +ASSERT (type <XFS_DIR3_FT_MAX ); +ASSERT (dep->namelen !=0 ); + + dep->name[dep->namelen] = type; +} + +/* +* Pointer to an entry's tag word. +*/ +static __be16 * +xfs_dir2_data_entry_tag_p ( +struct xfs_dir2_data_entry *dep) +{ +return (__be16 *)((char *)dep + +xfs_dir2_data_entsize (dep->namelen) -sizeof (__be16)); +} + +static __be16 * +xfs_dir3_data_entry_tag_p ( +struct xfs_dir2_data_entry *dep) +{ +return (__be16 *)((char *)dep + +xfs_dir3_data_entsize (dep->namelen) -sizeof (__be16)); +} + +/* +* Offsets of . and .. in data space (always block 0) +*/ +static xfs_dir2_data_aoff_t +xfs_dir2_data_dot_offset (void ) +{ +return sizeof (struct xfs_dir2_data_hdr ); +} + +static xfs_dir2_data_aoff_t +xfs_dir2_data_dotdot_offset (void ) +{ +return xfs_dir2_data_dot_offset () +xfs_dir2_data_entsize (1 ); +} + +static xfs_dir2_data_aoff_t +xfs_dir2_data_first_offset (void ) +{ +return xfs_dir2_data_dotdot_offset () +xfs_dir2_data_entsize (2 ); +} + +static xfs_dir2_data_aoff_t +xfs_dir3_data_dot_offset (void ) +{ +return sizeof (struct xfs_dir3_data_hdr ); +} + +static xfs_dir2_data_aoff_t +xfs_dir3_data_dotdot_offset (void ) +{ +return xfs_dir3_data_dot_offset () +xfs_dir3_data_entsize (1 ); +} + +static xfs_dir2_data_aoff_t +xfs_dir3_data_first_offset (void ) +{ +return xfs_dir3_data_dotdot_offset () +xfs_dir3_data_entsize (2 ); +} + +/* +* location of . and .. in data space (always block 0) +*/ +static struct xfs_dir2_data_entry * +xfs_dir2_data_dot_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +xfs_dir2_data_dot_offset ()); +} + +static struct xfs_dir2_data_entry * +xfs_dir2_data_dotdot_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +xfs_dir2_data_dotdot_offset ()); +} + +static struct xfs_dir2_data_entry * +xfs_dir2_data_first_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +xfs_dir2_data_first_offset ()); +} + +static struct xfs_dir2_data_entry * +xfs_dir3_data_dot_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +xfs_dir3_data_dot_offset ()); +} + +static struct xfs_dir2_data_entry * +xfs_dir3_data_dotdot_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +xfs_dir3_data_dotdot_offset ()); +} + +static struct xfs_dir2_data_entry * +xfs_dir3_data_first_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +xfs_dir3_data_first_offset ()); +} +const struct xfs_dir_ops xfs_dir2_ops = { .sf_entsize = xfs_dir2_sf_entsize, .sf_nextentry = xfs_dir2_sf_nextentry,
@@ -212,6 +392,18 @@ const struct xfs_dir_ops xfs_dir2_ops = { .sf_put_ino = xfs_dir2_sfe_put_ino, .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino, .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino, + + .data_entsize = xfs_dir2_data_entsize, + .data_get_ftype = xfs_dir2_data_get_ftype, + .data_put_ftype = xfs_dir2_data_put_ftype, + .data_entry_tag_p = xfs_dir2_data_entry_tag_p, + + .data_dot_offset = xfs_dir2_data_dot_offset, + .data_dotdot_offset = xfs_dir2_data_dotdot_offset, + .data_first_offset = xfs_dir2_data_first_offset, + .data_dot_entry_p = xfs_dir2_data_dot_entry_p, + .data_dotdot_entry_p = xfs_dir2_data_dotdot_entry_p, + .data_first_entry_p = xfs_dir2_data_first_entry_p, };const struct xfs_dir_ops xfs_dir2_ftype_ops = {
@@ -223,6 +415,18 @@ const struct xfs_dir_ops xfs_dir2_ftype_ops = { .sf_put_ino = xfs_dir3_sfe_put_ino, .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino, .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino, + + .data_entsize = xfs_dir3_data_entsize, + .data_get_ftype = xfs_dir3_data_get_ftype, + .data_put_ftype = xfs_dir3_data_put_ftype, + .data_entry_tag_p = xfs_dir3_data_entry_tag_p, + + .data_dot_offset = xfs_dir2_data_dot_offset, + .data_dotdot_offset = xfs_dir2_data_dotdot_offset, + .data_first_offset = xfs_dir2_data_first_offset, + .data_dot_entry_p = xfs_dir2_data_dot_entry_p, + .data_dotdot_entry_p = xfs_dir2_data_dotdot_entry_p, + .data_first_entry_p = xfs_dir2_data_first_entry_p, };const struct xfs_dir_ops xfs_dir3_ops = {
@@ -234,4 +438,16 @@ const struct xfs_dir_ops xfs_dir3_ops = { .sf_put_ino = xfs_dir3_sfe_put_ino, .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino, .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino, + + .data_entsize = xfs_dir3_data_entsize, + .data_get_ftype = xfs_dir3_data_get_ftype, + .data_put_ftype = xfs_dir3_data_put_ftype, + .data_entry_tag_p = xfs_dir3_data_entry_tag_p, + + .data_dot_offset = xfs_dir3_data_dot_offset, + .data_dotdot_offset = xfs_dir3_data_dotdot_offset, + .data_first_offset = xfs_dir3_data_first_offset, + .data_dot_entry_p = xfs_dir3_data_dot_entry_p, + .data_dotdot_entry_p = xfs_dir3_data_dotdot_entry_p, + .data_first_entry_p = xfs_dir3_data_first_entry_p, };
fs/xfs/xfs_da_format.h +0 -123
135 lines not on this page · raw message
fs/xfs/xfs_dir2.h +19 -3
@@ -50,6 +50,22 @@ struct xfs_dir_ops {xfs_ino_t (*sf_get_parent_ino)(struct xfs_dir2_sf_hdr *hdr);void (*sf_put_parent_ino)(struct xfs_dir2_sf_hdr *hdr,xfs_ino_t ino); + +int (*data_entsize)(int len); +__uint8_t (*data_get_ftype)(struct xfs_dir2_data_entry *dep); +void (*data_put_ftype)(struct xfs_dir2_data_entry *dep, +__uint8_t ftype); +__be16 * (*data_entry_tag_p)(struct xfs_dir2_data_entry *dep); + +xfs_dir2_data_aoff_t (*data_dot_offset)(void); +xfs_dir2_data_aoff_t (*data_dotdot_offset)(void); +xfs_dir2_data_aoff_t (*data_first_offset)(void); +struct xfs_dir2_data_entry * + (*data_dot_entry_p)(struct xfs_dir2_data_hdr *hdr); +struct xfs_dir2_data_entry * + (*data_dotdot_entry_p)(struct xfs_dir2_data_hdr *hdr); +struct xfs_dir2_data_entry * + (*data_first_entry_p)(struct xfs_dir2_data_hdr *hdr); };extern const struct xfs_dir_ops xfs_dir2_ops;
@@ -95,10 +111,10 @@ extern int xfs_dir2_isleaf(struct xfs_trans *tp, struct xfs_inode *dp, int *r);extern int xfs_dir2_shrink_inode (struct xfs_da_args *args,xfs_dir2_db_t db,struct xfs_buf *bp); -extern void xfs_dir2_data_freescan (struct xfs_mount *mp, +extern void xfs_dir2_data_freescan (struct xfs_inode *dp,struct xfs_dir2_data_hdr *hdr,int *loghead); -extern void xfs_dir2_data_log_entry (struct xfs_trans *tp,struct xfs_buf *bp, -struct xfs_dir2_data_entry *dep); +extern void xfs_dir2_data_log_entry (struct xfs_trans *tp,struct xfs_inode *dp, +struct xfs_buf *bp,struct xfs_dir2_data_entry *dep);extern void xfs_dir2_data_log_header (struct xfs_trans *tp,struct xfs_buf *bp); extern void xfs_dir2_data_log_unused(struct xfs_trans *tp, struct xfs_buf *bp,
fs/xfs/xfs_dir2_block.c +27 -27
159 lines not on this page · raw message
fs/xfs/xfs_dir2_data.c +26 -12
@@ -62,12 +62,26 @@ __xfs_dir3_data_check(char *p;/* current data position */ int stale;/* count of stale leaves */ struct xfs_name name; +const struct xfs_dir_ops *ops; mp = bp->b_target->bt_mount; hdr = bp->b_addr; bf =xfs_dir3_data_bestfree_p (hdr); p = (char *)xfs_dir3_data_entry_p (hdr); +/* +* We can be passed a null dp here from a verifier, so manually +* configure the ops here in that case. +*/ +if (dp) + ops = dp->d_ops; +else if (xfs_sb_version_hascrc (&mp->m_sb)) + ops = &xfs_dir3_ops; +else if (xfs_sb_version_hasftype (&mp->m_sb)) + ops = &xfs_dir2_ftype_ops; +else + ops = &xfs_dir2_ops; +switch (hdr->magic) {case cpu_to_be32 (XFS_DIR3_BLOCK_MAGIC ):case cpu_to_be32 (XFS_DIR2_BLOCK_MAGIC ):
@@ -146,10 +160,10 @@ __xfs_dir3_data_check(XFS_WANT_CORRUPTED_RETURN ( !xfs_dir_ino_validate (mp,be64_to_cpu (dep->inumber)));XFS_WANT_CORRUPTED_RETURN ( -be16_to_cpu (*xfs_dir3_data_entry_tag_p (mp, dep)) == +be16_to_cpu (*ops->data_entry_tag_p (dep)) == (char *)dep - (char *)hdr);XFS_WANT_CORRUPTED_RETURN ( -xfs_dir3_dirent_get_ftype (mp, dep) <XFS_DIR3_FT_MAX ); + ops->data_get_ftype (dep) <XFS_DIR3_FT_MAX ); count++; lastfree =0 ; if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
@@ -167,7 +181,7 @@ __xfs_dir3_data_check( }XFS_WANT_CORRUPTED_RETURN (i <be32_to_cpu (btp->count)); } - p +=xfs_dir3_data_entsize (mp, dep->namelen); + p += ops->data_entsize (dep->namelen); }/* * Need to have seen all the entries and all the bestfree slots.
@@ -485,9 +499,9 @@ xfs_dir2_data_freeremove(*/ void xfs_dir2_data_freescan ( -xfs_mount_t *mp,/* filesystem mount point */ -xfs_dir2_data_hdr_t *hdr,/* data block header */ -int *loghead)/* out: log data header */ +struct xfs_inode *dp, +struct xfs_dir2_data_hdr *hdr, +int *loghead) {xfs_dir2_block_tail_t *btp;/* block tail */ xfs_dir2_data_entry_t *dep;/* active data entry */
@@ -513,10 +527,10 @@ xfs_dir2_data_freescan( p = (char *)xfs_dir3_data_entry_p (hdr);if (hdr->magic ==cpu_to_be32 (XFS_DIR2_BLOCK_MAGIC ) || hdr->magic ==cpu_to_be32 (XFS_DIR3_BLOCK_MAGIC )) { - btp =xfs_dir2_block_tail_p (mp, hdr); + btp =xfs_dir2_block_tail_p (dp->i_mount, hdr); endp = (char *)xfs_dir2_block_leaf_p (btp); }else - endp = (char *)hdr + mp->m_dirblksize; + endp = (char *)hdr + dp->i_mount->m_dirblksize;/* * Loop over the block's entries. */
@@ -537,8 +551,8 @@ xfs_dir2_data_freescan(else { dep = (xfs_dir2_data_entry_t *)p;ASSERT ((char *)dep - (char *)hdr == -be16_to_cpu (*xfs_dir3_data_entry_tag_p (mp, dep))); - p +=xfs_dir3_data_entsize (mp, dep->namelen); +be16_to_cpu (*dp->d_ops->data_entry_tag_p (dep))); + p += dp->d_ops->data_entsize (dep->namelen); } } }
@@ -625,11 +639,11 @@ xfs_dir3_data_init(void xfs_dir2_data_log_entry (struct xfs_trans *tp, +struct xfs_inode *dp,struct xfs_buf *bp,xfs_dir2_data_entry_t *dep)/* data entry pointer */ {struct xfs_dir2_data_hdr *hdr = bp->b_addr; -struct xfs_mount *mp = tp->t_mountp; ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) || hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
@@ -637,7 +651,7 @@ xfs_dir2_data_log_entry( hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));xfs_trans_log_buf (tp, bp, (uint)((char *)dep - (char *)hdr), - (uint)((char *)(xfs_dir3_data_entry_tag_p (mp, dep) +1 ) - + (uint)((char *)(dp->d_ops->data_entry_tag_p (dep) +1 ) - (char *)hdr -1 )); }
fs/xfs/xfs_dir2_leaf.c +11 -11
@@ -500,7 +500,7 @@ xfs_dir2_block_to_leaf( hdr->magic =cpu_to_be32 (XFS_DIR3_DATA_MAGIC );if (needscan) -xfs_dir2_data_freescan (mp, hdr, &needlog); +xfs_dir2_data_freescan (dp, hdr, &needlog);/* * Set up leaf tail and bests table. */
@@ -700,7 +700,7 @@ xfs_dir2_leaf_addname( ents =xfs_dir3_leaf_ents_p (leaf);xfs_dir3_leaf_hdr_from_disk (&leafhdr, leaf); bestsp =xfs_dir2_leaf_bests_p (ltp); - length =xfs_dir3_data_entsize (mp, args->namelen); + length = dp->d_ops->data_entsize (args->namelen);/* * See if there are any entries with the same hash value
@@ -901,20 +901,20 @@ xfs_dir2_leaf_addname( dep->inumber =cpu_to_be64 (args->inumber); dep->namelen = args->namelen;memcpy (dep->name, args->name, dep->namelen); -xfs_dir3_dirent_put_ftype (mp, dep, args->filetype); - tagp =xfs_dir3_data_entry_tag_p (mp, dep); + dp->d_ops->data_put_ftype (dep, args->filetype); + tagp = dp->d_ops->data_entry_tag_p (dep); *tagp =cpu_to_be16 ((char *)dep - (char *)hdr);/* * Need to scan fix up the bestfree table. */ if (needscan) -xfs_dir2_data_freescan (mp, hdr, &needlog); +xfs_dir2_data_freescan (dp, hdr, &needlog);/* * Need to log the data block's header. */ if (needlog)xfs_dir2_data_log_header (tp, dbp); -xfs_dir2_data_log_entry (tp, dbp, dep); +xfs_dir2_data_log_entry (tp, dp, dbp, dep);/* * If the bests table needs to be changed, do it. * Log the change unless we've already done that.
@@ -1230,7 +1230,7 @@ xfs_dir2_leaf_lookup(* Return the found inode number & CI name if appropriate */ args->inumber =be64_to_cpu (dep->inumber); - args->filetype =xfs_dir3_dirent_get_ftype (dp->i_mount, dep); + args->filetype = dp->d_ops->data_get_ftype (dep); error =xfs_dir_cilookup_result (args, dep->name, dep->namelen);xfs_trans_brelse (tp, dbp);xfs_trans_brelse (tp, lbp);
@@ -1433,7 +1433,7 @@ xfs_dir2_leaf_removename(*/ xfs_dir2_data_make_free (tp, dbp, (xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr), -xfs_dir3_data_entsize (mp, dep->namelen), &needlog, &needscan); + dp->d_ops->data_entsize (dep->namelen), &needlog, &needscan);/* * We just mark the leaf entry stale by putting a null in it. */
@@ -1449,7 +1449,7 @@ xfs_dir2_leaf_removename(* log the data block header if necessary. */ if (needscan) -xfs_dir2_data_freescan (mp, hdr, &needlog); +xfs_dir2_data_freescan (dp, hdr, &needlog);if (needlog)xfs_dir2_data_log_header (tp, dbp);/*
@@ -1561,9 +1561,9 @@ xfs_dir2_leaf_replace(* Put the new inode number in, log it. */ dep->inumber =cpu_to_be64 (args->inumber); -xfs_dir3_dirent_put_ftype (dp->i_mount, dep, args->filetype); + dp->d_ops->data_put_ftype (dep, args->filetype); tp = args->trans; -xfs_dir2_data_log_entry (tp, dbp, dep); +xfs_dir2_data_log_entry (tp, dp, dbp, dep);xfs_dir3_leaf_check (dp->i_mount, lbp);xfs_trans_brelse (tp, lbp);return 0 ;
fs/xfs/xfs_dir2_node.c +12 -11
@@ -604,7 +604,7 @@ xfs_dir2_leafn_lookup_for_addname(ASSERT (free->hdr.magic ==cpu_to_be32 (XFS_DIR2_FREE_MAGIC ) || free->hdr.magic ==cpu_to_be32 (XFS_DIR3_FREE_MAGIC )); } - length =xfs_dir3_data_entsize (mp, args->namelen); + length = dp->d_ops->data_entsize (args->namelen);/* * Loop over leaf entries with the right hash value. */
@@ -815,7 +815,7 @@ xfs_dir2_leafn_lookup_for_entry(xfs_trans_brelse (tp, state->extrablk.bp); args->cmpresult = cmp; args->inumber =be64_to_cpu (dep->inumber); - args->filetype =xfs_dir3_dirent_get_ftype (mp, dep); + args->filetype = dp->d_ops->data_get_ftype (dep); *indexp = index; state->extravalid =1 ; state->extrablk.bp = curbp;
@@ -1259,13 +1259,13 @@ xfs_dir2_leafn_remove( longest =be16_to_cpu (bf[0 ].length); needlog = needscan =0 ;xfs_dir2_data_make_free (tp, dbp, off, -xfs_dir3_data_entsize (mp, dep->namelen), &needlog, &needscan); + dp->d_ops->data_entsize (dep->namelen), &needlog, &needscan);/* * Rescan the data block freespaces for bestfree. * Log the data block header if needed. */ if (needscan) -xfs_dir2_data_freescan (mp, hdr, &needlog); +xfs_dir2_data_freescan (dp, hdr, &needlog);if (needlog)xfs_dir2_data_log_header (tp, dbp);xfs_dir3_data_check (dp, dbp);
@@ -1711,7 +1711,7 @@ xfs_dir2_node_addname_int( dp = args->dp; mp = dp->i_mount; tp = args->trans; - length =xfs_dir3_data_entsize (mp, args->namelen); + length = dp->d_ops->data_entsize (args->namelen);/* * If we came in with a freespace block that means that lookup * found an entry with our hash value. This is the freespace
@@ -2007,15 +2007,15 @@ xfs_dir2_node_addname_int( dep->inumber =cpu_to_be64 (args->inumber); dep->namelen = args->namelen;memcpy (dep->name, args->name, dep->namelen); -xfs_dir3_dirent_put_ftype (mp, dep, args->filetype); - tagp =xfs_dir3_data_entry_tag_p (mp, dep); + dp->d_ops->data_put_ftype (dep, args->filetype); + tagp = dp->d_ops->data_entry_tag_p (dep); *tagp =cpu_to_be16 ((char *)dep - (char *)hdr); -xfs_dir2_data_log_entry (tp, dbp, dep); +xfs_dir2_data_log_entry (tp, dp, dbp, dep);/* * Rescan the block for bestfree if needed. */ if (needscan) -xfs_dir2_data_freescan (mp, hdr, &needlog); +xfs_dir2_data_freescan (dp, hdr, &needlog);/* * Log the data block header if needed. */
@@ -2228,8 +2228,9 @@ xfs_dir2_node_replace(* Fill in the new inode number and log the entry. */ dep->inumber =cpu_to_be64 (inum); -xfs_dir3_dirent_put_ftype (state->mp, dep, args->filetype); -xfs_dir2_data_log_entry (args->trans, state->extrablk.bp, dep); + args->dp->d_ops->data_put_ftype (dep, args->filetype); +xfs_dir2_data_log_entry (args->trans, args->dp, + state->extrablk.bp, dep); rval =0 ; }/*
fs/xfs/xfs_dir2_readdir.c +7 -7
@@ -119,9 +119,9 @@ xfs_dir2_sf_getdents(* mp->m_dirdatablk. */ dot_offset =xfs_dir2_db_off_to_dataptr (mp, mp->m_dirdatablk, -xfs_dir3_data_dot_offset (mp)); + dp->d_ops->data_dot_offset ()); dotdot_offset =xfs_dir2_db_off_to_dataptr (mp, mp->m_dirdatablk, -xfs_dir3_data_dotdot_offset (mp)); + dp->d_ops->data_dotdot_offset ());/* * Put . entry unless we're starting past it.
@@ -237,7 +237,7 @@ xfs_dir2_block_getdents(/* * Bump pointer for the next iteration. */ - ptr +=xfs_dir3_data_entsize (mp, dep->namelen); + ptr += dp->d_ops->data_entsize (dep->namelen);/* * The entry is before the desired starting point, skip it. */
@@ -248,7 +248,7 @@ xfs_dir2_block_getdents( (char *)dep - (char *)hdr); ctx->pos = cook &0x7fffffff ; - filetype =xfs_dir3_dirent_get_ftype (mp, dep); + filetype = dp->d_ops->data_get_ftype (dep);/* * If it didn't fit, set the final offset to here & return. */
@@ -601,7 +601,7 @@ xfs_dir2_leaf_getdents( } dep = (xfs_dir2_data_entry_t *)ptr; length = -xfs_dir3_data_entsize (mp, dep->namelen); + dp->d_ops->data_entsize (dep->namelen); ptr += length; }/*
@@ -632,8 +632,8 @@ xfs_dir2_leaf_getdents( } dep = (xfs_dir2_data_entry_t *)ptr; - length =xfs_dir3_data_entsize (mp, dep->namelen); - filetype =xfs_dir3_dirent_get_ftype (mp, dep); + length = dp->d_ops->data_entsize (dep->namelen); + filetype = dp->d_ops->data_get_ftype (dep); ctx->pos =xfs_dir2_byte_to_dataptr (mp, curoff) &0x7fffffff ; if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
fs/xfs/xfs_dir2_sf.c +10 -10
@@ -251,11 +251,11 @@ xfs_dir2_block_to_sf( dp->d_ops->sf_put_ino (sfp, sfep,be64_to_cpu (dep->inumber)); dp->d_ops->sf_put_ftype (sfep, -xfs_dir3_dirent_get_ftype (mp, dep)); + dp->d_ops->data_get_ftype (dep)); sfep = dp->d_ops->sf_nextentry (sfp, sfep); } - ptr +=xfs_dir3_data_entsize (mp, dep->namelen); + ptr += dp->d_ops->data_entsize (dep->namelen); }ASSERT ((char *)sfep - (char *)sfp == size);xfs_dir2_sf_check (args);
@@ -473,12 +473,12 @@ xfs_dir2_sf_addname_hard(* to insert the new entry. * If it's going to end up at the end then oldsfep will point there. */ -for (offset =xfs_dir3_data_first_offset (mp), +for (offset = dp->d_ops->data_first_offset (), oldsfep =xfs_dir2_sf_firstentry (oldsfp), - add_datasize =xfs_dir3_data_entsize (mp, args->namelen), + add_datasize = dp->d_ops->data_entsize (args->namelen), eof = (char *)oldsfep == &buf[old_isize]; !eof; - offset = new_offset +xfs_dir3_data_entsize (mp, oldsfep->namelen), + offset = new_offset + dp->d_ops->data_entsize (oldsfep->namelen), oldsfep = dp->d_ops->sf_nextentry (oldsfp, oldsfep), eof = (char *)oldsfep == &buf[old_isize]) { new_offset =xfs_dir2_sf_get_offset (oldsfep);
@@ -555,8 +555,8 @@ xfs_dir2_sf_addname_pick( mp = dp->i_mount; sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data; - size =xfs_dir3_data_entsize (mp, args->namelen); - offset =xfs_dir3_data_first_offset (mp); + size = dp->d_ops->data_entsize (args->namelen); + offset = dp->d_ops->data_first_offset (); sfep =xfs_dir2_sf_firstentry (sfp); holefit =0 ;/*
@@ -568,7 +568,7 @@ xfs_dir2_sf_addname_pick(if (!holefit) holefit = offset + size <=xfs_dir2_sf_get_offset (sfep); offset =xfs_dir2_sf_get_offset (sfep) + -xfs_dir3_data_entsize (mp, sfep->namelen); + dp->d_ops->data_entsize (sfep->namelen); sfep = dp->d_ops->sf_nextentry (sfp, sfep); }/*
@@ -629,7 +629,7 @@ xfs_dir2_sf_check( mp = dp->i_mount; sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data; - offset =xfs_dir3_data_first_offset (mp); + offset = dp->d_ops->data_first_offset (); ino = dp->d_ops->sf_get_parent_ino (sfp); i8count = ino >XFS_DIR2_MAX_SHORT_INUM ;
@@ -641,7 +641,7 @@ xfs_dir2_sf_check( i8count += ino >XFS_DIR2_MAX_SHORT_INUM ; offset =xfs_dir2_sf_get_offset (sfep) + -xfs_dir3_data_entsize (mp, sfep->namelen); + dp->d_ops->data_entsize (sfep->namelen);ASSERT (dp->d_ops->sf_get_ftype (sfep) <XFS_DIR3_FT_MAX ); }ASSERT (i8count == sfp->i8count);
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 6/15 xfs: vectorise directory data operations part 2
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Convert the rest of the directory data block encode/decode operations to vector format.
This further reduces the size of the built binary:
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3 789005 96802 1096 886903 d8997 fs/xfs/xfs.o.p4
--- fs/xfs/xfs_da_format.c | 68 +++++++++++++++++++++++++++++ fs/xfs/xfs_da_format.h | 41 ------------------ fs/xfs/xfs_dir2.h | 22 +++++++--- fs/xfs/xfs_dir2_block.c | 33 ++++++++------- fs/xfs/xfs_dir2_data.c | 106 +++++++++++++++++++++++++--------------------- fs/xfs/xfs_dir2_leaf.c | 26 ++++++------ fs/xfs/xfs_dir2_node.c | 16 +++---- fs/xfs/xfs_dir2_priv.h | 3 +- fs/xfs/xfs_dir2_readdir.c | 6 +-- fs/xfs/xfs_dir2_sf.c | 2 +- 10 files changed, 186 insertions(+), 137 deletions(-)
fs/xfs/xfs_da_format.c +68 -0
@@ -383,6 +383,58 @@ xfs_dir3_data_first_entry_p( ((char *)hdr +xfs_dir3_data_first_offset ()); } +static struct xfs_dir2_data_free * +xfs_dir2_data_bestfree_p (struct xfs_dir2_data_hdr *hdr) +{ +return hdr->bestfree; +} + +static struct xfs_dir2_data_free * +xfs_dir3_data_bestfree_p (struct xfs_dir2_data_hdr *hdr) +{ +return ((struct xfs_dir3_data_hdr *)hdr)->best_free; +} + +static size_t +xfs_dir2_data_entry_offset (void ) +{ +return sizeof (struct xfs_dir2_data_hdr ); +} + +static struct xfs_dir2_data_entry * +xfs_dir2_data_entry_p (struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +xfs_dir2_data_entry_offset ()); +} + +static struct xfs_dir2_data_unused * +xfs_dir2_data_unused_p (struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_unused *) + ((char *)hdr +xfs_dir2_data_entry_offset ()); +} + +static size_t +xfs_dir3_data_entry_offset (void ) +{ +return sizeof (struct xfs_dir3_data_hdr ); +} + +static struct xfs_dir2_data_entry * +xfs_dir3_data_entry_p (struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +xfs_dir3_data_entry_offset ()); +} + +static struct xfs_dir2_data_unused * +xfs_dir3_data_unused_p (struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_unused *) + ((char *)hdr +xfs_dir3_data_entry_offset ()); +} +const struct xfs_dir_ops xfs_dir2_ops = { .sf_entsize = xfs_dir2_sf_entsize, .sf_nextentry = xfs_dir2_sf_nextentry,
@@ -397,13 +449,19 @@ const struct xfs_dir_ops xfs_dir2_ops = { .data_get_ftype = xfs_dir2_data_get_ftype, .data_put_ftype = xfs_dir2_data_put_ftype, .data_entry_tag_p = xfs_dir2_data_entry_tag_p, + .data_bestfree_p = xfs_dir2_data_bestfree_p, .data_dot_offset = xfs_dir2_data_dot_offset, .data_dotdot_offset = xfs_dir2_data_dotdot_offset, .data_first_offset = xfs_dir2_data_first_offset, + .data_entry_offset = xfs_dir2_data_entry_offset, + .data_dot_entry_p = xfs_dir2_data_dot_entry_p, .data_dotdot_entry_p = xfs_dir2_data_dotdot_entry_p, .data_first_entry_p = xfs_dir2_data_first_entry_p, + .data_entry_p = xfs_dir2_data_entry_p, + .data_unused_p = xfs_dir2_data_unused_p, + };const struct xfs_dir_ops xfs_dir2_ftype_ops = {
@@ -420,13 +478,18 @@ const struct xfs_dir_ops xfs_dir2_ftype_ops = { .data_get_ftype = xfs_dir3_data_get_ftype, .data_put_ftype = xfs_dir3_data_put_ftype, .data_entry_tag_p = xfs_dir3_data_entry_tag_p, + .data_bestfree_p = xfs_dir2_data_bestfree_p, .data_dot_offset = xfs_dir2_data_dot_offset, .data_dotdot_offset = xfs_dir2_data_dotdot_offset, .data_first_offset = xfs_dir2_data_first_offset, + .data_entry_offset = xfs_dir2_data_entry_offset, + .data_dot_entry_p = xfs_dir2_data_dot_entry_p, .data_dotdot_entry_p = xfs_dir2_data_dotdot_entry_p, .data_first_entry_p = xfs_dir2_data_first_entry_p, + .data_entry_p = xfs_dir2_data_entry_p, + .data_unused_p = xfs_dir2_data_unused_p, };const struct xfs_dir_ops xfs_dir3_ops = {
@@ -443,11 +506,16 @@ const struct xfs_dir_ops xfs_dir3_ops = { .data_get_ftype = xfs_dir3_data_get_ftype, .data_put_ftype = xfs_dir3_data_put_ftype, .data_entry_tag_p = xfs_dir3_data_entry_tag_p, + .data_bestfree_p = xfs_dir3_data_bestfree_p, .data_dot_offset = xfs_dir3_data_dot_offset, .data_dotdot_offset = xfs_dir3_data_dotdot_offset, .data_first_offset = xfs_dir3_data_first_offset, + .data_entry_offset = xfs_dir3_data_entry_offset, + .data_dot_entry_p = xfs_dir3_data_dot_entry_p, .data_dotdot_entry_p = xfs_dir3_data_dotdot_entry_p, .data_first_entry_p = xfs_dir3_data_first_entry_p, + .data_entry_p = xfs_dir3_data_entry_p, + .data_unused_p = xfs_dir3_data_unused_p, };
fs/xfs/xfs_da_format.h +0 -41
53 lines not on this page · raw message
fs/xfs/xfs_dir2.h +16 -6
@@ -56,16 +56,24 @@ struct xfs_dir_ops {void (*data_put_ftype)(struct xfs_dir2_data_entry *dep,__uint8_t ftype);__be16 * (*data_entry_tag_p)(struct xfs_dir2_data_entry *dep); +struct xfs_dir2_data_free * + (*data_bestfree_p)(struct xfs_dir2_data_hdr *hdr);xfs_dir2_data_aoff_t (*data_dot_offset)(void);xfs_dir2_data_aoff_t (*data_dotdot_offset)(void);xfs_dir2_data_aoff_t (*data_first_offset)(void); +size_t (*data_entry_offset)(void ); +struct xfs_dir2_data_entry * (*data_dot_entry_p)(struct xfs_dir2_data_hdr *hdr);struct xfs_dir2_data_entry * (*data_dotdot_entry_p)(struct xfs_dir2_data_hdr *hdr);struct xfs_dir2_data_entry * (*data_first_entry_p)(struct xfs_dir2_data_hdr *hdr); +struct xfs_dir2_data_entry * + (*data_entry_p)(struct xfs_dir2_data_hdr *hdr); +struct xfs_dir2_data_unused * + (*data_unused_p)(struct xfs_dir2_data_hdr *hdr); };extern const struct xfs_dir_ops xfs_dir2_ops;
@@ -115,19 +123,21 @@ extern void xfs_dir2_data_freescan(struct xfs_inode *dp, struct xfs_dir2_data_hdr *hdr, int *loghead);extern void xfs_dir2_data_log_entry (struct xfs_trans *tp,struct xfs_inode *dp,struct xfs_buf *bp,struct xfs_dir2_data_entry *dep); -extern void xfs_dir2_data_log_header (struct xfs_trans *tp, +extern void xfs_dir2_data_log_header (struct xfs_trans *tp,struct xfs_inode *dp,struct xfs_buf *bp);extern void xfs_dir2_data_log_unused (struct xfs_trans *tp,struct xfs_buf *bp,struct xfs_dir2_data_unused *dup); -extern void xfs_dir2_data_make_free (struct xfs_trans *tp,struct xfs_buf *bp, +extern void xfs_dir2_data_make_free (struct xfs_trans *tp,struct xfs_inode *dp, +struct xfs_buf *bp,xfs_dir2_data_aoff_t offset, +xfs_dir2_data_aoff_t len,int *needlogp,int *needscanp); +extern void xfs_dir2_data_use_free (struct xfs_trans *tp,struct xfs_inode *dp, +struct xfs_buf *bp,struct xfs_dir2_data_unused *dup,xfs_dir2_data_aoff_t offset,xfs_dir2_data_aoff_t len,int *needlogp,int *needscanp); -extern void xfs_dir2_data_use_free (struct xfs_trans *tp,struct xfs_buf *bp, -struct xfs_dir2_data_unused *dup,xfs_dir2_data_aoff_t offset, -xfs_dir2_data_aoff_t len,int *needlogp,int *needscanp);extern struct xfs_dir2_data_free *xfs_dir2_data_freefind ( -struct xfs_dir2_data_hdr *hdr,struct xfs_dir2_data_unused *dup); +struct xfs_dir2_data_hdr *hdr,struct xfs_dir2_data_free *bf, +struct xfs_dir2_data_unused *dup);extern const struct xfs_buf_ops xfs_dir3_block_buf_ops;extern const struct xfs_buf_ops xfs_dir3_leafn_buf_ops;
fs/xfs/xfs_dir2_block.c +18 -15
@@ -168,6 +168,7 @@ xfs_dir3_block_init( static void xfs_dir2_block_need_space( + struct xfs_inode *dp, struct xfs_dir2_data_hdr *hdr, struct xfs_dir2_block_tail *btp, struct xfs_dir2_leaf_entry *blp,
@@ -183,7 +184,7 @@ xfs_dir2_block_need_space(struct xfs_dir2_data_unused *enddup =NULL ; *compact =0 ; - bf =xfs_dir3_data_bestfree_p (hdr); + bf = dp->d_ops->data_bestfree_p (hdr);/* * If there are stale entries we'll use one for the leaf.
@@ -313,7 +314,7 @@ xfs_dir2_block_compact( *lfloglow = toidx +1 - (be32_to_cpu (btp->stale) -1 ); *lfloghigh -=be32_to_cpu (btp->stale) -1 ;be32_add_cpu (&btp->count, -(be32_to_cpu (btp->stale) -1 )); -xfs_dir2_data_make_free (tp, bp, +xfs_dir2_data_make_free (tp, dp, bp, (xfs_dir2_data_aoff_t)((char *)blp - (char *)hdr), (xfs_dir2_data_aoff_t)((be32_to_cpu (btp->stale) -1 ) *sizeof (*blp)), needlog, &needscan);
@@ -383,7 +384,7 @@ xfs_dir2_block_addname(* Find out if we can reuse stale entries or whether we need extra * space for entry and new leaf. */ -xfs_dir2_block_need_space (hdr, btp, blp, &tagp, &dup, +xfs_dir2_block_need_space (dp, hdr, btp, blp, &tagp, &dup, &enddup, &compact, len);/*
@@ -454,7 +455,7 @@ xfs_dir2_block_addname(/* * Mark the space needed for the new leaf entry, now in use. */ - xfs_dir2_data_use_free(tp, bp, enddup, + xfs_dir2_data_use_free(tp, dp, bp, enddup, (xfs_dir2_data_aoff_t) ((char *)enddup - (char *)hdr + be16_to_cpu(enddup->length) - sizeof(*blp)),
@@ -541,7 +542,7 @@ xfs_dir2_block_addname(/* * Mark space for the data entry used. */ -xfs_dir2_data_use_free (tp, bp, dup, +xfs_dir2_data_use_free (tp, dp, bp, dup, (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr), (xfs_dir2_data_aoff_t )len, &needlog, &needscan);/*
@@ -559,7 +560,7 @@ xfs_dir2_block_addname(if (needscan)xfs_dir2_data_freescan (dp, hdr, &needlog);if (needlog) -xfs_dir2_data_log_header (tp, bp); +xfs_dir2_data_log_header (tp, dp, bp);xfs_dir2_block_log_tail (tp, bp);xfs_dir2_data_log_entry (tp, dp, bp, dep);xfs_dir3_data_check (dp, bp);
@@ -800,7 +801,7 @@ xfs_dir2_block_removename(* Mark the data entry's space free. */ needlog = needscan =0 ; -xfs_dir2_data_make_free (tp, bp, +xfs_dir2_data_make_free (tp, dp, bp, (xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr), dp->d_ops->data_entsize (dep->namelen), &needlog, &needscan);/*
@@ -819,7 +820,7 @@ xfs_dir2_block_removename(if (needscan)xfs_dir2_data_freescan (dp, hdr, &needlog);if (needlog) -xfs_dir2_data_log_header (tp, bp); +xfs_dir2_data_log_header (tp, dp, bp);xfs_dir3_data_check (dp, bp);/* * See if the size as a shortform is good enough.
@@ -950,7 +951,7 @@ xfs_dir2_leaf_to_block(while (dp->i_d.di_size > mp->m_dirblksize) {int hdrsz; - hdrsz =xfs_dir3_data_hdr_size (xfs_sb_version_hascrc (&mp->m_sb)); + hdrsz = dp->d_ops->data_entry_offset (); bestsp =xfs_dir2_leaf_bests_p (ltp);if (be16_to_cpu (bestsp[be32_to_cpu (ltp->bestcount) -1 ]) == mp->m_dirblksize - hdrsz) {
@@ -1000,7 +1001,7 @@ xfs_dir2_leaf_to_block(/* * Use up the space at the end of the block (blp/btp). */ -xfs_dir2_data_use_free (tp, dbp, dup, mp->m_dirblksize - size, size, +xfs_dir2_data_use_free (tp, dp, dbp, dup, mp->m_dirblksize - size, size, &needlog, &needscan);/* * Initialize the block tail.
@@ -1026,7 +1027,7 @@ xfs_dir2_leaf_to_block(if (needscan)xfs_dir2_data_freescan (dp, hdr, &needlog);if (needlog) -xfs_dir2_data_log_header (tp, dbp); +xfs_dir2_data_log_header (tp, dp, dbp);/* * Pitch the old leaf block. */
@@ -1137,9 +1138,9 @@ xfs_dir2_sf_to_block(* The whole thing is initialized to free by the init routine. * Say we're using the leaf and tail area. */ - dup =xfs_dir3_data_unused_p (hdr); + dup = dp->d_ops->data_unused_p (hdr); needlog = needscan =0 ; -xfs_dir2_data_use_free (tp, bp, dup, mp->m_dirblksize - i, i, &needlog, +xfs_dir2_data_use_free (tp, dp, bp, dup, mp->m_dirblksize - i, i, &needlog, &needscan);ASSERT (needscan ==0 );/*
@@ -1153,7 +1154,7 @@ xfs_dir2_sf_to_block(/* * Remove the freespace, we'll manage it. */ -xfs_dir2_data_use_free (tp, bp, dup, +xfs_dir2_data_use_free (tp, dp, bp, dup, (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr),be16_to_cpu (dup->length), &needlog, &needscan);/*
@@ -1215,7 +1216,9 @@ xfs_dir2_sf_to_block( *xfs_dir2_data_unused_tag_p (dup) =cpu_to_be16 ( ((char *)dup - (char *)hdr));xfs_dir2_data_log_unused (tp, bp, dup); -xfs_dir2_data_freeinsert (hdr, dup, &dummy); +xfs_dir2_data_freeinsert (hdr, + dp->d_ops->data_bestfree_p (hdr), + dup, &dummy); offset +=be16_to_cpu (dup->length);continue ; }
fs/xfs/xfs_dir2_data.c +57 -49
318 lines not on this page · raw message
fs/xfs/xfs_dir2_leaf.c +13 -13
@@ -460,7 +460,7 @@ xfs_dir2_block_to_leaf(xfs_dir3_data_check (dp, dbp); btp =xfs_dir2_block_tail_p (mp, hdr); blp =xfs_dir2_block_leaf_p (btp); - bf =xfs_dir3_data_bestfree_p (hdr); + bf = dp->d_ops->data_bestfree_p (hdr); ents =xfs_dir3_leaf_ents_p (leaf);/*
@@ -484,7 +484,7 @@ xfs_dir2_block_to_leaf(* Make the space formerly occupied by the leaf entries and block * tail be free. */ - xfs_dir2_data_make_free(tp, dbp, + xfs_dir2_data_make_free(tp, dp, dbp, (xfs_dir2_data_aoff_t)((char *)blp - (char *)hdr), (xfs_dir2_data_aoff_t)((char *)hdr + mp->m_dirblksize - (char *)blp),
@@ -512,7 +512,7 @@ xfs_dir2_block_to_leaf(* Log the data header and leaf bests table. */ if (needlog) -xfs_dir2_data_log_header (tp, dbp); +xfs_dir2_data_log_header (tp, dp, dbp);xfs_dir3_leaf_check (mp, lbp);xfs_dir3_data_check (dp, dbp);xfs_dir3_leaf_log_bests (tp, lbp,0 ,0 );
@@ -862,7 +862,7 @@ xfs_dir2_leaf_addname(else xfs_dir3_leaf_log_bests (tp, lbp, use_block, use_block); hdr = dbp->b_addr; - bf =xfs_dir3_data_bestfree_p (hdr); + bf = dp->d_ops->data_bestfree_p (hdr); bestsp[use_block] = bf[0 ].length; grown =1 ; }else {
@@ -878,7 +878,7 @@ xfs_dir2_leaf_addname(return error; } hdr = dbp->b_addr; - bf =xfs_dir3_data_bestfree_p (hdr); + bf = dp->d_ops->data_bestfree_p (hdr); grown =0 ; }/*
@@ -891,7 +891,7 @@ xfs_dir2_leaf_addname(/* * Mark the initial part of our freespace in use for the new entry. */ -xfs_dir2_data_use_free (tp, dbp, dup, +xfs_dir2_data_use_free (tp, dp, dbp, dup, (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr), length, &needlog, &needscan);/*
@@ -913,7 +913,7 @@ xfs_dir2_leaf_addname(* Need to log the data block's header. */ if (needlog) -xfs_dir2_data_log_header (tp, dbp); +xfs_dir2_data_log_header (tp, dp, dbp);xfs_dir2_data_log_entry (tp, dp, dbp, dep);/* * If the bests table needs to be changed, do it.
@@ -1413,7 +1413,7 @@ xfs_dir2_leaf_removename( leaf = lbp->b_addr; hdr = dbp->b_addr;xfs_dir3_data_check (dp, dbp); - bf =xfs_dir3_data_bestfree_p (hdr); + bf = dp->d_ops->data_bestfree_p (hdr);xfs_dir3_leaf_hdr_from_disk (&leafhdr, leaf); ents =xfs_dir3_leaf_ents_p (leaf);/*
@@ -1431,7 +1431,7 @@ xfs_dir2_leaf_removename(/* * Mark the former data entry unused. */ -xfs_dir2_data_make_free (tp, dbp, +xfs_dir2_data_make_free (tp, dp, dbp, (xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr), dp->d_ops->data_entsize (dep->namelen), &needlog, &needscan);/*
@@ -1451,7 +1451,7 @@ xfs_dir2_leaf_removename(if (needscan)xfs_dir2_data_freescan (dp, hdr, &needlog);if (needlog) -xfs_dir2_data_log_header (tp, dbp); +xfs_dir2_data_log_header (tp, dp, dbp);/* * If the longest freespace in the data block has changed, * put the new value in the bests table and log that.
@@ -1465,7 +1465,7 @@ xfs_dir2_leaf_removename(* If the data block is now empty then get rid of the data block. */ if (be16_to_cpu (bf[0 ].length) == - mp->m_dirblksize -xfs_dir3_data_entry_offset (hdr)) { + mp->m_dirblksize - dp->d_ops->data_entry_offset ()) {ASSERT (db != mp->m_dirdatablk);if ((error =xfs_dir2_shrink_inode (args, db, dbp))) {/*
@@ -1659,12 +1659,12 @@ xfs_dir2_leaf_trim_data(#ifdef DEBUG {struct xfs_dir2_data_hdr *hdr = dbp->b_addr; -struct xfs_dir2_data_free *bf =xfs_dir3_data_bestfree_p (hdr); +struct xfs_dir2_data_free *bf = dp->d_ops->data_bestfree_p (hdr);ASSERT (hdr->magic ==cpu_to_be32 (XFS_DIR2_DATA_MAGIC ) || hdr->magic ==cpu_to_be32 (XFS_DIR3_DATA_MAGIC ));ASSERT (be16_to_cpu (bf[0 ].length) == - mp->m_dirblksize -xfs_dir3_data_entry_offset (hdr)); + mp->m_dirblksize - dp->d_ops->data_entry_offset ());ASSERT (db ==be32_to_cpu (ltp->bestcount) -1 ); }#endif
fs/xfs/xfs_dir2_node.c +8 -8
@@ -1255,10 +1255,10 @@ xfs_dir2_leafn_remove( dbp = dblk->bp; hdr = dbp->b_addr; dep = (xfs_dir2_data_entry_t *)((char *)hdr + off); - bf =xfs_dir3_data_bestfree_p (hdr); + bf = dp->d_ops->data_bestfree_p (hdr); longest =be16_to_cpu (bf[0 ].length); needlog = needscan =0 ; -xfs_dir2_data_make_free (tp, dbp, off, +xfs_dir2_data_make_free (tp, dp, dbp, off, dp->d_ops->data_entsize (dep->namelen), &needlog, &needscan);/* * Rescan the data block freespaces for bestfree.
@@ -1267,7 +1267,7 @@ xfs_dir2_leafn_remove(if (needscan)xfs_dir2_data_freescan (dp, hdr, &needlog);if (needlog) -xfs_dir2_data_log_header (tp, dbp); +xfs_dir2_data_log_header (tp, dp, dbp);xfs_dir3_data_check (dp, dbp);/* * If the longest data block freespace changes, need to update
@@ -1308,7 +1308,7 @@ xfs_dir2_leafn_remove(* (usually). */ if (longest == mp->m_dirblksize - -xfs_dir3_data_entry_offset (hdr)) { + dp->d_ops->data_entry_offset ()) {/* * Try to punch out the data block. */
@@ -1962,7 +1962,7 @@ xfs_dir2_node_addname_int(* change again. */ hdr = dbp->b_addr; - bf =xfs_dir3_data_bestfree_p (hdr); + bf = dp->d_ops->data_bestfree_p (hdr); bests[findex] = bf[0 ].length; logfree =1 ; }
@@ -1984,7 +1984,7 @@ xfs_dir2_node_addname_int(if (error)return error; hdr = dbp->b_addr; - bf =xfs_dir3_data_bestfree_p (hdr); + bf = dp->d_ops->data_bestfree_p (hdr); logfree =0 ; }ASSERT (be16_to_cpu (bf[0 ].length) >= length);
@@ -1997,7 +1997,7 @@ xfs_dir2_node_addname_int(/* * Mark the first part of the unused space, inuse for us. */ -xfs_dir2_data_use_free (tp, dbp, dup, +xfs_dir2_data_use_free (tp, dp, dbp, dup, (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr), length, &needlog, &needscan);/*
@@ -2020,7 +2020,7 @@ xfs_dir2_node_addname_int(* Log the data block header if needed. */ if (needlog) -xfs_dir2_data_log_header (tp, dbp); +xfs_dir2_data_log_header (tp, dp, dbp);/* * If the freespace entry is now wrong, update it. */
fs/xfs/xfs_dir2_priv.h +2 -1
@@ -59,7 +59,8 @@ extern int xfs_dir3_data_readahead(struct xfs_trans *tp, struct xfs_inode *dp,extern struct xfs_dir2_data_free *xfs_dir2_data_freeinsert (struct xfs_dir2_data_hdr *hdr, -struct xfs_dir2_data_unused *dup,int *loghead); +struct xfs_dir2_data_free *bf,struct xfs_dir2_data_unused *dup, +int *loghead);extern int xfs_dir3_data_init (struct xfs_da_args *args,xfs_dir2_db_t blkno,struct xfs_buf **bpp);
fs/xfs/xfs_dir2_readdir.c +3 -3
@@ -213,7 +213,7 @@ xfs_dir2_block_getdents(* Set up values for the loop. */ btp =xfs_dir2_block_tail_p (mp, hdr); - ptr = (char *)xfs_dir3_data_entry_p (hdr); + ptr = (char *)dp->d_ops->data_entry_p (hdr); endptr = (char *)xfs_dir2_block_leaf_p (btp);/*
@@ -578,13 +578,13 @@ xfs_dir2_leaf_getdents(/* * Find our position in the block. */ - ptr = (char *)xfs_dir3_data_entry_p (hdr); + ptr = (char *)dp->d_ops->data_entry_p (hdr); byteoff =xfs_dir2_byte_to_off (mp, curoff);/* * Skip past the header. */ if (byteoff ==0 ) - curoff +=xfs_dir3_data_entry_offset (hdr); + curoff += dp->d_ops->data_entry_offset ();/* * Skip past entries until we reach our offset. */
fs/xfs/xfs_dir2_sf.c +1 -1
@@ -210,7 +210,7 @@ xfs_dir2_block_to_sf(* Set up to loop over the block's entries. */ btp =xfs_dir2_block_tail_p (mp, hdr); - ptr = (char *)xfs_dir3_data_entry_p (hdr); + ptr = (char *)dp->d_ops->data_entry_p (hdr); endptr = (char *)xfs_dir2_block_leaf_p (btp); sfep =xfs_dir2_sf_firstentry (sfp);/*
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 7/15 xfs: vectorise directory leaf operations
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Next step in the vectorisation process is the leaf block encode/decode operations. Most of the operations on leaves are handled by the data block vectors, so there are relatively few of them here.
Because of all the shuffling of code and having to pass more state to some functions, this patch doesn't directly reduce the size of the binary. It does open up many more opportunities for factoring and optimisation, however.
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3 789005 96802 1096 886903 d8997 fs/xfs/xfs.o.p4 789061 96802 1096 886959 d88af fs/xfs/xfs.o.p5
--- fs/xfs/xfs_da_btree.c | 19 ++++---- fs/xfs/xfs_da_format.c | 75 +++++++++++++++++++++++++++++++ fs/xfs/xfs_da_format.h | 30 ------------- fs/xfs/xfs_dir2.c | 7 +-- fs/xfs/xfs_dir2.h | 10 +++-- fs/xfs/xfs_dir2_block.c | 2 +- fs/xfs/xfs_dir2_data.c | 13 ++---- fs/xfs/xfs_dir2_leaf.c | 91 ++++++++++++++++++++----------------- fs/xfs/xfs_dir2_node.c | 117 ++++++++++++++++++++++++++---------------------- fs/xfs/xfs_dir2_priv.h | 13 +++--- 10 files changed, 218 insertions(+), 159 deletions(-)
fs/xfs/xfs_da_btree.c +10 -9
@@ -605,7 +605,7 @@ xfs_da3_root_split( leaf = (xfs_dir2_leaf_t *)oldroot;xfs_dir3_leaf_hdr_from_disk (&leafhdr, leaf); - ents =xfs_dir3_leaf_ents_p (leaf); + ents = dp->d_ops->leaf_ents_p (leaf);ASSERT (leafhdr.magic ==XFS_DIR2_LEAFN_MAGIC || leafhdr.magic ==XFS_DIR3_LEAFN_MAGIC );
@@ -1319,7 +1319,8 @@ xfs_da3_fixhashpath(return ;break ;case XFS_DIR2_LEAFN_MAGIC : - lasthash =xfs_dir2_leafn_lasthash (blk->bp, &count); + lasthash =xfs_dir2_leafn_lasthash (state->args->dp, + blk->bp, &count);if (count ==0 )return ;break ;
@@ -1536,7 +1537,8 @@ xfs_da3_node_lookup_int(if (blk->magic ==XFS_DIR2_LEAFN_MAGIC || blk->magic ==XFS_DIR3_LEAFN_MAGIC ) { blk->magic =XFS_DIR2_LEAFN_MAGIC ; - blk->hashval =xfs_dir2_leafn_lasthash (blk->bp,NULL ); + blk->hashval =xfs_dir2_leafn_lasthash (args->dp, + blk->bp,NULL );break ; }
@@ -1702,7 +1704,7 @@ xfs_da3_blk_link( before =xfs_attr_leaf_order (old_blk->bp, new_blk->bp);break ;case XFS_DIR2_LEAFN_MAGIC : - before =xfs_dir2_leafn_order (old_blk->bp, new_blk->bp); + before =xfs_dir2_leafn_order (args->dp, old_blk->bp, new_blk->bp);break ;case XFS_DA_NODE_MAGIC : before =xfs_da3_node_order (old_blk->bp, new_blk->bp);
@@ -1947,16 +1949,15 @@ xfs_da3_path_shift( blk->magic =XFS_ATTR_LEAF_MAGIC ;ASSERT (level == path->active-1 ); blk->index =0 ; - blk->hashval =xfs_attr_leaf_lasthash (blk->bp, -NULL ); + blk->hashval =xfs_attr_leaf_lasthash (blk->bp,NULL );break ;case XFS_DIR2_LEAFN_MAGIC :case XFS_DIR3_LEAFN_MAGIC : blk->magic =XFS_DIR2_LEAFN_MAGIC ;ASSERT (level == path->active-1 ); blk->index =0 ; - blk->hashval =xfs_dir2_leafn_lasthash (blk->bp, -NULL ); + blk->hashval =xfs_dir2_leafn_lasthash (args->dp, + blk->bp,NULL );break ;default :ASSERT (0 );
@@ -2223,7 +2224,7 @@ xfs_da3_swap_lastblock( dead_leaf2 = (xfs_dir2_leaf_t *)dead_info;xfs_dir3_leaf_hdr_from_disk (&leafhdr, dead_leaf2); - ents =xfs_dir3_leaf_ents_p (dead_leaf2); + ents = ip->d_ops->leaf_ents_p (dead_leaf2); dead_level =0 ; dead_hash =be32_to_cpu (ents[leafhdr.count -1 ].hashval); }else {
fs/xfs/xfs_da_format.c +75 -0
97 lines not on this page · raw message
fs/xfs/xfs_da_format.h +0 -30
@@ -551,36 +551,6 @@ struct xfs_dir3_leaf {extern void xfs_dir3_leaf_hdr_from_disk (struct xfs_dir3_icleaf_hdr *to,struct xfs_dir2_leaf *from); -static inline int -xfs_dir3_leaf_hdr_size (struct xfs_dir2_leaf *lp) -{ -if (lp->hdr.info.magic ==cpu_to_be16 (XFS_DIR3_LEAF1_MAGIC ) || - lp->hdr.info.magic ==cpu_to_be16 (XFS_DIR3_LEAFN_MAGIC )) -return sizeof (struct xfs_dir3_leaf_hdr ); -return sizeof (struct xfs_dir2_leaf_hdr ); -} - -static inline int -xfs_dir3_max_leaf_ents (struct xfs_mount *mp,struct xfs_dir2_leaf *lp) -{ -return (mp->m_dirblksize -xfs_dir3_leaf_hdr_size (lp)) / - (uint )sizeof (struct xfs_dir2_leaf_entry ); -} - -/* -* Get address of the bestcount field in the single-leaf block. -*/ -static inline struct xfs_dir2_leaf_entry * -xfs_dir3_leaf_ents_p (struct xfs_dir2_leaf *lp) -{ -if (lp->hdr.info.magic ==cpu_to_be16 (XFS_DIR3_LEAF1_MAGIC ) || - lp->hdr.info.magic ==cpu_to_be16 (XFS_DIR3_LEAFN_MAGIC )) { -struct xfs_dir3_leaf *lp3 = (struct xfs_dir3_leaf *)lp; -return lp3->__ents; - } -return lp->__ents; -} -/* * Get address of the bestcount field in the single-leaf block. */
fs/xfs/xfs_dir2.c +1 -6
@@ -113,12 +113,7 @@ xfs_dir_mount(else mp->m_dirnameops = &xfs_default_nameops; -if (xfs_sb_version_hascrc (&mp->m_sb)) - mp->m_dir_inode_ops = &xfs_dir3_ops; -else if (xfs_sb_version_hasftype (&mp->m_sb)) - mp->m_dir_inode_ops = &xfs_dir2_ftype_ops; -else - mp->m_dir_inode_ops = &xfs_dir2_ops; + mp->m_dir_inode_ops =xfs_dir_get_ops (mp,NULL ); }/*
fs/xfs/xfs_dir2.h +7 -3
@@ -74,11 +74,15 @@ struct xfs_dir_ops { (*data_entry_p)(struct xfs_dir2_data_hdr *hdr);struct xfs_dir2_data_unused * (*data_unused_p)(struct xfs_dir2_data_hdr *hdr); + +int (*leaf_hdr_size)(void ); +int (*leaf_max_ents)(struct xfs_mount *mp); +struct xfs_dir2_leaf_entry * + (*leaf_ents_p)(struct xfs_dir2_leaf *lp); }; -extern const struct xfs_dir_ops xfs_dir2_ops; -extern const struct xfs_dir_ops xfs_dir2_ftype_ops; -extern const struct xfs_dir_ops xfs_dir3_ops; +extern const struct xfs_dir_ops * +xfs_dir_get_ops (struct xfs_mount *mp,struct xfs_inode *dp);/* * Generic directory interface routines
fs/xfs/xfs_dir2_block.c +1 -1
@@ -937,7 +937,7 @@ xfs_dir2_leaf_to_block( mp = dp->i_mount; leaf = lbp->b_addr;xfs_dir3_leaf_hdr_from_disk (&leafhdr, leaf); - ents =xfs_dir3_leaf_ents_p (leaf); + ents = dp->d_ops->leaf_ents_p (leaf); ltp =xfs_dir2_leaf_tail_p (mp, leaf); ASSERT(leafhdr.magic == XFS_DIR2_LEAF1_MAGIC ||
fs/xfs/xfs_dir2_data.c +3 -10
@@ -68,17 +68,10 @@ __xfs_dir3_data_check( hdr = bp->b_addr;/* -* We can be passed a null dp here from a verifier, so manually -* configure the ops here in that case. +* We can be passed a null dp here from a verifier, so we need to go the +* hard way to get them. */ -if (dp) - ops = dp->d_ops; -else if (xfs_sb_version_hascrc (&mp->m_sb)) - ops = &xfs_dir3_ops; -else if (xfs_sb_version_hasftype (&mp->m_sb)) - ops = &xfs_dir2_ftype_ops; -else - ops = &xfs_dir2_ops; + ops =xfs_dir_get_ops (mp, dp);switch (hdr->magic) {case cpu_to_be32 (XFS_DIR3_BLOCK_MAGIC ):
fs/xfs/xfs_dir2_leaf.c +51 -40
280 lines not on this page · raw message
fs/xfs/xfs_dir2_node.c +63 -54
347 lines not on this page · raw message
fs/xfs/xfs_dir2_priv.h +7 -6
@@ -77,9 +77,9 @@ extern void xfs_dir3_leaf_compact_x1(struct xfs_dir3_icleaf_hdr *leafhdr, int *lowstalep, int *highstalep, int *lowlogp, int *highlogp);extern int xfs_dir3_leaf_get_buf (struct xfs_da_args *args,xfs_dir2_db_t bno,struct xfs_buf **bpp,__uint16_t magic); -extern void xfs_dir3_leaf_log_ents (struct xfs_trans *tp,struct xfs_buf *bp, -int first,int last); -extern void xfs_dir3_leaf_log_header (struct xfs_trans *tp, +extern void xfs_dir3_leaf_log_ents (struct xfs_trans *tp,struct xfs_inode *dp, +struct xfs_buf *bp,int first,int last); +extern void xfs_dir3_leaf_log_header (struct xfs_trans *tp,struct xfs_inode *dp,struct xfs_buf *bp);extern int xfs_dir2_leaf_lookup (struct xfs_da_args *args);extern int xfs_dir2_leaf_removename (struct xfs_da_args *args);
@@ -98,17 +98,18 @@ extern void xfs_dir3_leaf_hdr_from_disk(struct xfs_dir3_icleaf_hdr *to, struct xfs_dir2_leaf *from);extern void xfs_dir3_leaf_hdr_to_disk (struct xfs_dir2_leaf *to,struct xfs_dir3_icleaf_hdr *from); -extern bool xfs_dir3_leaf_check_int (struct xfs_mount *mp, +extern bool xfs_dir3_leaf_check_int (struct xfs_mount *mp,struct xfs_inode *dp,struct xfs_dir3_icleaf_hdr *hdr,struct xfs_dir2_leaf *leaf);/* xfs_dir2_node.c */ extern int xfs_dir2_leaf_to_node (struct xfs_da_args *args,struct xfs_buf *lbp); -extern xfs_dahash_t xfs_dir2_leafn_lasthash (struct xfs_buf *bp,int *count); +extern xfs_dahash_t xfs_dir2_leafn_lasthash (struct xfs_inode *dp, +struct xfs_buf *bp,int *count);extern int xfs_dir2_leafn_lookup_int (struct xfs_buf *bp,struct xfs_da_args *args,int *indexp,struct xfs_da_state *state); -extern int xfs_dir2_leafn_order (struct xfs_buf *leaf1_bp, +extern int xfs_dir2_leafn_order (struct xfs_inode *dp,struct xfs_buf *leaf1_bp,struct xfs_buf *leaf2_bp);extern int xfs_dir2_leafn_split (struct xfs_da_state *state,struct xfs_da_state_blk *oldblk,struct xfs_da_state_blk *newblk);
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 8/15 xfs: vectorise DA btree operations
In reply to Dave ChinnerThe remaining non-vectorised code for the directory structure is the node format blocks. This is shared with the attribute tree, and so is slightly more complex to vectorise.
Introduce a "non-directory" directory ops structure that is attached to all non-directory inodes so that attribute operations can be vectorised for all inodes.
Once we do this, we can vectorise all the da btree operations. Because this patch adds more infrastructure than it removes the binary size does not decrease:
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3 789005 96802 1096 886903 d8997 fs/xfs/xfs.o.p4 789061 96802 1096 886959 d88af fs/xfs/xfs.o.p5 789733 96802 1096 887631 d8b4f fs/xfs/xfs.o.p6
--- fs/xfs/xfs_attr_inactive.c | 3 +- fs/xfs/xfs_attr_leaf.c | 3 +- fs/xfs/xfs_attr_list.c | 11 ++--- fs/xfs/xfs_da_btree.c | 104 +++++++++++++++++++++++++-------------------- fs/xfs/xfs_da_format.c | 59 +++++++++++++++++++++++++ fs/xfs/xfs_da_format.h | 25 ----------- fs/xfs/xfs_dir2.c | 7 ++- fs/xfs/xfs_dir2.h | 6 +++ fs/xfs/xfs_iops.c | 1 + fs/xfs/xfs_mount.h | 1 + 10 files changed, 139 insertions(+), 81 deletions(-)
fs/xfs/xfs_attr_inactive.c +2 -1
@@ -40,6 +40,7 @@#include "xfs_quota.h" #include "xfs_trace.h" #include "xfs_dinode.h" +#include "xfs_dir2.h" /* * Look at all the extents for this logical region,
@@ -236,7 +237,7 @@ xfs_attr3_node_inactive(xfs_trans_brelse (*trans, bp);return 0 ; } - btree =xfs_da3_node_tree_p (node); + btree = dp->d_ops->node_tree_p (node); child_fsb =be32_to_cpu (btree[0 ].before);xfs_trans_brelse (*trans, bp);/* no locks for later trans */
fs/xfs/xfs_attr_leaf.c +2 -1
@@ -41,6 +41,7 @@#include "xfs_buf_item.h" #include "xfs_cksum.h" #include "xfs_dinode.h" +#include "xfs_dir2.h" /*
@@ -916,7 +917,7 @@ xfs_attr3_leaf_to_node( goto out; node = bp1->b_addr;xfs_da3_node_hdr_from_disk (&icnodehdr, node); - btree =xfs_da3_node_tree_p (node); + btree = dp->d_ops->node_tree_p (node); leaf = bp2->b_addr;xfs_attr3_leaf_hdr_from_disk (&icleafhdr, leaf);
fs/xfs/xfs_attr_list.c +6 -5
@@ -40,6 +40,7 @@#include "xfs_buf_item.h" #include "xfs_cksum.h" #include "xfs_dinode.h" +#include "xfs_dir2.h" STATIC intxfs_attr_shortform_compare (const void *a,const void *b)
@@ -226,6 +227,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)struct xfs_da_node_entry *btree;int error, i;struct xfs_buf *bp; +struct xfs_inode *dp = context->dp;trace_xfs_attr_node_list (context);
@@ -239,7 +241,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)*/ bp =NULL ;if (cursor->blkno >0 ) { - error =xfs_da3_node_read (NULL , context->dp, cursor->blkno,-1 , + error =xfs_da3_node_read (NULL , dp, cursor->blkno,-1 , &bp,XFS_ATTR_FORK );if ((error !=0 ) && (error !=EFSCORRUPTED ))return (error);
@@ -289,7 +291,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)for (;;) {__uint16_t magic; - error =xfs_da3_node_read (NULL , context->dp, + error =xfs_da3_node_read (NULL , dp, cursor->blkno,-1 , &bp,XFS_ATTR_FORK );if (error)
@@ -310,7 +312,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context) }xfs_da3_node_hdr_from_disk (&nodehdr, node); - btree =xfs_da3_node_tree_p (node); + btree = dp->d_ops->node_tree_p (node);for (i =0 ; i < nodehdr.count; btree++, i++) {if (cursor->hashval <=be32_to_cpu (btree->hashval)) {
@@ -346,8 +348,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)break ; cursor->blkno = leafhdr.forw;xfs_trans_brelse (NULL , bp); - error =xfs_attr3_leaf_read (NULL , context->dp, cursor->blkno,-1 , - &bp); + error =xfs_attr3_leaf_read (NULL , dp, cursor->blkno,-1 , &bp);if (error)return error; }
fs/xfs/xfs_da_btree.c +57 -47
392 lines not on this page · raw message
fs/xfs/xfs_da_format.c +59 -0
86 lines not on this page · raw message
fs/xfs/xfs_da_format.h +0 -25
@@ -127,31 +127,6 @@ extern void xfs_da3_node_hdr_from_disk(struct xfs_da3_icnode_hdr *to,extern void xfs_da3_node_hdr_to_disk (struct xfs_da_intnode *to,struct xfs_da3_icnode_hdr *from); -static inline int -__xfs_da3_node_hdr_size (bool v3) -{ -if (v3) -return sizeof (struct xfs_da3_node_hdr ); -return sizeof (struct xfs_da_node_hdr ); -} -static inline int -xfs_da3_node_hdr_size (struct xfs_da_intnode *dap) -{ -bool v3 = dap->hdr.info.magic ==cpu_to_be16 (XFS_DA3_NODE_MAGIC ); - -return __xfs_da3_node_hdr_size (v3); -} - -static inline struct xfs_da_node_entry * -xfs_da3_node_tree_p (struct xfs_da_intnode *dap) -{ -if (dap->hdr.info.magic ==cpu_to_be16 (XFS_DA3_NODE_MAGIC )) { -struct xfs_da3_intnode *dap3 = (struct xfs_da3_intnode *)dap; -return dap3->__btree; - } -return dap->__btree; -} -extern void xfs_da3_intnode_from_disk (struct xfs_da3_icnode_hdr *to,struct xfs_da_intnode *from); extern void xfs_da3_intnode_to_disk(struct xfs_da_intnode *to,
fs/xfs/xfs_dir2.c +5 -2
@@ -95,13 +95,17 @@ xfs_dir_mount(ASSERT (xfs_sb_version_hasdirv2 (&mp->m_sb));ASSERT ((1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog)) <=XFS_MAX_BLOCKSIZE ); + + mp->m_dir_inode_ops =xfs_dir_get_ops (mp,NULL ); + mp->m_nondir_inode_ops =xfs_nondir_get_ops (mp,NULL ); + mp->m_dirblksize =1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog); mp->m_dirblkfsbs =1 << mp->m_sb.sb_dirblklog; mp->m_dirdatablk =xfs_dir2_db_to_da (mp,XFS_DIR2_DATA_FIRSTDB (mp)); mp->m_dirleafblk =xfs_dir2_db_to_da (mp,XFS_DIR2_LEAF_FIRSTDB (mp)); mp->m_dirfreeblk =xfs_dir2_db_to_da (mp,XFS_DIR2_FREE_FIRSTDB (mp)); - nodehdr_size =__xfs_da3_node_hdr_size (xfs_sb_version_hascrc (&mp->m_sb)); + nodehdr_size = mp->m_dir_inode_ops->node_hdr_size (); mp->m_attr_node_ents = (mp->m_sb.sb_blocksize - nodehdr_size) / (uint )sizeof (xfs_da_node_entry_t); mp->m_dir_node_ents = (mp->m_dirblksize - nodehdr_size) /
@@ -113,7 +117,6 @@ xfs_dir_mount(else mp->m_dirnameops = &xfs_default_nameops; - mp->m_dir_inode_ops =xfs_dir_get_ops (mp,NULL ); }/*
fs/xfs/xfs_dir2.h +6 -0
@@ -79,10 +79,16 @@ struct xfs_dir_ops {int (*leaf_max_ents)(struct xfs_mount *mp);struct xfs_dir2_leaf_entry * (*leaf_ents_p)(struct xfs_dir2_leaf *lp); + +int (*node_hdr_size)(void ); +struct xfs_da_node_entry * + (*node_tree_p)(struct xfs_da_intnode *dap); };extern const struct xfs_dir_ops *xfs_dir_get_ops (struct xfs_mount *mp,struct xfs_inode *dp); +extern const struct xfs_dir_ops * +xfs_nondir_get_ops (struct xfs_mount *mp,struct xfs_inode *dp);/* * Generic directory interface routines
fs/xfs/xfs_iops.c +1 -0
@@ -1203,6 +1203,7 @@ xfs_setup_inode( inode->i_ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;xfs_diflags_to_iflags (inode, ip); + ip->d_ops = ip->i_mount->m_nondir_inode_ops;switch (inode->i_mode &S_IFMT ) {case S_IFREG : inode->i_op = &xfs_inode_operations;
fs/xfs/xfs_mount.h +1 -0
@@ -150,6 +150,7 @@ typedef struct xfs_mount {__uint8_t m_sectbb_log;/* sectlog - BBSHIFT */ const struct xfs_nameops *m_dirnameops;/* vector of dir name ops */ const struct xfs_dir_ops *m_dir_inode_ops;/* vector of dir inode ops */ +const struct xfs_dir_ops *m_nondir_inode_ops;/* !dir inode ops */ int m_dirblksize;/* directory block sz--bytes */ int m_dirblkfsbs;/* directory block sz--fsbs */ xfs_dablk_t m_dirdatablk;/* blockno of dir data v2 */
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 9/15 xfs: vectorise encoding/decoding directory headers
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Conversion from on-disk structures to in-core header structures currently relies on magic number checks. If the magic number is wrong, but one of the supported values, we do the wrong thing with the encode/decode operation. Split these functions so that there are discrete operations for the specific directory format we are handling.
In doing this, move all the header encode/decode functions to xfs_da_format.c as they are directly manipulating the on-disk format. It should be noted that all the growth in binary size is from xfs_da_format.c - the rest of the code actaully shrinks.
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3 789005 96802 1096 886903 d8997 fs/xfs/xfs.o.p4 789061 96802 1096 886959 d88af fs/xfs/xfs.o.p5 789733 96802 1096 887631 d8b4f fs/xfs/xfs.o.p6 791421 96802 1096 889319 d91e7 fs/xfs/xfs.o.p7
--- fs/xfs/xfs_attr_inactive.c | 2 +- fs/xfs/xfs_attr_leaf.c | 4 +- fs/xfs/xfs_attr_list.c | 2 +- fs/xfs/xfs_da_btree.c | 141 +++++++++++------------------- fs/xfs/xfs_da_format.c | 209 ++++++++++++++++++++++++++++++++++++++++++++- fs/xfs/xfs_da_format.h | 16 ---- fs/xfs/xfs_dir2.h | 13 +++ fs/xfs/xfs_dir2_block.c | 2 +- fs/xfs/xfs_dir2_leaf.c | 100 ++++++---------------- fs/xfs/xfs_dir2_node.c | 126 +++++++++------------------ fs/xfs/xfs_dir2_priv.h | 4 - 11 files changed, 338 insertions(+), 281 deletions(-)
fs/xfs/xfs_attr_inactive.c +1 -1
@@ -231,7 +231,7 @@ xfs_attr3_node_inactive( } node = bp->b_addr; -xfs_da3_node_hdr_from_disk (&ichdr, node); + dp->d_ops->node_hdr_from_disk (&ichdr, node); parent_blkno = bp->b_bn;if (!ichdr.count) {xfs_trans_brelse (*trans, bp);
fs/xfs/xfs_attr_leaf.c +2 -2
@@ -916,7 +916,7 @@ xfs_attr3_leaf_to_node(if (error) goto out; node = bp1->b_addr; -xfs_da3_node_hdr_from_disk (&icnodehdr, node); + dp->d_ops->node_hdr_from_disk (&icnodehdr, node); btree = dp->d_ops->node_tree_p (node); leaf = bp2->b_addr;
@@ -927,7 +927,7 @@ xfs_attr3_leaf_to_node( btree[0 ].hashval = entries[icleafhdr.count -1 ].hashval; btree[0 ].before =cpu_to_be32 (blkno); icnodehdr.count =1 ; -xfs_da3_node_hdr_to_disk (node, &icnodehdr); + dp->d_ops->node_hdr_to_disk (node, &icnodehdr);xfs_trans_log_buf (args->trans, bp1,0 ,XFS_LBSIZE (mp) -1 ); error =0 ; out:
fs/xfs/xfs_attr_list.c +1 -1
@@ -311,7 +311,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)return XFS_ERROR (EFSCORRUPTED ); } -xfs_da3_node_hdr_from_disk (&nodehdr, node); + dp->d_ops->node_hdr_from_disk (&nodehdr, node); btree = dp->d_ops->node_tree_p (node);for (i =0 ; i < nodehdr.count; btree++, i++) { if (cursor->hashval
fs/xfs/xfs_da_btree.c +49 -92
379 lines not on this page · raw message
fs/xfs/xfs_da_format.c +207 -2
274 lines not on this page · raw message
fs/xfs/xfs_da_format.h +0 -16
@@ -122,16 +122,6 @@ struct xfs_da3_icnode_hdr {__uint16_t level; }; -extern void xfs_da3_node_hdr_from_disk (struct xfs_da3_icnode_hdr *to, -struct xfs_da_intnode *from); -extern void xfs_da3_node_hdr_to_disk (struct xfs_da_intnode *to, -struct xfs_da3_icnode_hdr *from); - -extern void xfs_da3_intnode_from_disk (struct xfs_da3_icnode_hdr *to, -struct xfs_da_intnode *from); -extern void xfs_da3_intnode_to_disk (struct xfs_da_intnode *to, -struct xfs_da3_icnode_hdr *from); -#define XFS_LBSIZE (mp) (mp)->m_sb.sb_blocksize/*
@@ -523,9 +513,6 @@ struct xfs_dir3_leaf {#define XFS_DIR3_LEAF_CRC_OFF offsetof(struct xfs_dir3_leaf_hdr, info.crc) -extern void xfs_dir3_leaf_hdr_from_disk (struct xfs_dir3_icleaf_hdr *to, -struct xfs_dir2_leaf *from); -/* * Get address of the bestcount field in the single-leaf block. */
@@ -717,9 +704,6 @@ struct xfs_dir3_icfree_hdr { }; -void xfs_dir3_free_hdr_from_disk (struct xfs_dir3_icfree_hdr *to, -struct xfs_dir2_free *from); -static inline int xfs_dir3_free_hdr_size (struct xfs_mount *mp) {
fs/xfs/xfs_dir2.h +13 -0
@@ -76,13 +76,26 @@ struct xfs_dir_ops { (*data_unused_p)(struct xfs_dir2_data_hdr *hdr);int (*leaf_hdr_size)(void ); +void (*leaf_hdr_to_disk)(struct xfs_dir2_leaf *to, +struct xfs_dir3_icleaf_hdr *from); +void (*leaf_hdr_from_disk)(struct xfs_dir3_icleaf_hdr *to, +struct xfs_dir2_leaf *from);int (*leaf_max_ents)(struct xfs_mount *mp);struct xfs_dir2_leaf_entry * (*leaf_ents_p)(struct xfs_dir2_leaf *lp);int (*node_hdr_size)(void ); +void (*node_hdr_to_disk)(struct xfs_da_intnode *to, +struct xfs_da3_icnode_hdr *from); +void (*node_hdr_from_disk)(struct xfs_da3_icnode_hdr *to, +struct xfs_da_intnode *from);struct xfs_da_node_entry * (*node_tree_p)(struct xfs_da_intnode *dap); + +void (*free_hdr_to_disk)(struct xfs_dir2_free *to, +struct xfs_dir3_icfree_hdr *from); +void (*free_hdr_from_disk)(struct xfs_dir3_icfree_hdr *to, +struct xfs_dir2_free *from); }; extern const struct xfs_dir_ops *
fs/xfs/xfs_dir2_block.c +1 -1
@@ -936,7 +936,7 @@ xfs_dir2_leaf_to_block( tp = args->trans; mp = dp->i_mount; leaf = lbp->b_addr; -xfs_dir3_leaf_hdr_from_disk (&leafhdr, leaf); + dp->d_ops->leaf_hdr_from_disk (&leafhdr, leaf); ents = dp->d_ops->leaf_ents_p (leaf); ltp =xfs_dir2_leaf_tail_p (mp, leaf);
fs/xfs/xfs_dir2_leaf.c +24 -76
217 lines not on this page · raw message
fs/xfs/xfs_dir2_node.c +40 -86
317 lines not on this page · raw message
fs/xfs/xfs_dir2_priv.h +0 -4
@@ -94,10 +94,6 @@ xfs_dir3_leaf_find_entry(struct xfs_dir3_icleaf_hdr *leafhdr, int lowstale, int highstale, int *lfloglow, int *lfloghigh);extern int xfs_dir2_node_to_leaf (struct xfs_da_state *state); -extern void xfs_dir3_leaf_hdr_from_disk (struct xfs_dir3_icleaf_hdr *to, -struct xfs_dir2_leaf *from); -extern void xfs_dir3_leaf_hdr_to_disk (struct xfs_dir2_leaf *to, -struct xfs_dir3_icleaf_hdr *from);extern bool xfs_dir3_leaf_check_int (struct xfs_mount *mp,struct xfs_inode *dp,struct xfs_dir3_icleaf_hdr *hdr,struct xfs_dir2_leaf *leaf);
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 09/15] xfs: vectorise encoding/decoding directory headers
Quoted 25 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Conversion from on-disk structures to in-core header structures currently relies on magic number checks. If the magic number is wrong, but one of the supported values, we do the wrong thing with the encode/decode operation. Split these functions so that there are discrete operations for the specific directory format we are handling.
In doing this, move all the header encode/decode functions to
xfs_da_format.cas they are directly manipulating the on-disk format. It should be noted that all the growth in binary size is fromxfs_da_format.c- the rest of the code actaully shrinks.text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3 789005 96802 1096 886903 d8997 fs/xfs/xfs.o.p4 789061 96802 1096 886959 d88af fs/xfs/xfs.o.p5 789733 96802 1096 887631 d8b4f fs/xfs/xfs.o.p6 791421 96802 1096 889319 d91e7 fs/xfs/xfs.o.p7
Quoted 1 line
Signed-off-by Dave Chinner <[email protected]>
Looks good.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 10/15 xfs: vectorise directory leaf operations
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Next step in the vectorisation process is the directory free block encode/decode operations. There are relatively few of these, though there are quite a numberof calls to them.
Binary sizes:
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3 789005 96802 1096 886903 d8997 fs/xfs/xfs.o.p4 789061 96802 1096 886959 d88af fs/xfs/xfs.o.p5 789733 96802 1096 887631 d8b4f fs/xfs/xfs.o.p6 791421 96802 1096 889319 d91e7 fs/xfs/xfs.o.p7 791701 96802 1096 889599 d92ff fs/xfs/xfs.o.p8
--- fs/xfs/xfs_da_format.c | 89 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_da_format.h | 39 ---------------------- fs/xfs/xfs_dir2.h | 5 +++ fs/xfs/xfs_dir2_leaf.c | 2 +- fs/xfs/xfs_dir2_node.c | 61 +++++++++++++++++----------------- 5 files changed, 126 insertions(+), 70 deletions(-)
fs/xfs/xfs_da_format.c +89 -0
@@ -629,6 +629,80 @@ xfs_da3_node_hdr_to_disk(/* * Directory free space block operations */ +static int +xfs_dir2_free_hdr_size (void ) +{ +return sizeof (struct xfs_dir2_free_hdr ); +} + +static int +xfs_dir2_free_max_bests (struct xfs_mount *mp) +{ +return (mp->m_dirblksize -xfs_dir2_free_hdr_size ()) / +sizeof (xfs_dir2_data_off_t); +} + +static __be16 * +xfs_dir2_free_bests_p (struct xfs_dir2_free *free) +{ +return (__be16 *)((char *)free +xfs_dir2_free_hdr_size ()); +} + +/* +* Convert data space db to the corresponding free db. +*/ +static xfs_dir2_db_t +xfs_dir2_db_to_fdb (struct xfs_mount *mp,xfs_dir2_db_t db) +{ +return XFS_DIR2_FREE_FIRSTDB (mp) + db /xfs_dir2_free_max_bests (mp); +} + +/* +* Convert data space db to the corresponding index in a free db. +*/ +static int +xfs_dir2_db_to_fdindex (struct xfs_mount *mp,xfs_dir2_db_t db) +{ +return db %xfs_dir2_free_max_bests (mp); +} + +static int +xfs_dir3_free_hdr_size (void ) +{ +return sizeof (struct xfs_dir3_free_hdr ); +} + +static int +xfs_dir3_free_max_bests (struct xfs_mount *mp) +{ +return (mp->m_dirblksize -xfs_dir3_free_hdr_size ()) / +sizeof (xfs_dir2_data_off_t); +} + +static __be16 * +xfs_dir3_free_bests_p (struct xfs_dir2_free *free) +{ +return (__be16 *)((char *)free +xfs_dir3_free_hdr_size ()); +} + +/* +* Convert data space db to the corresponding free db. +*/ +static xfs_dir2_db_t +xfs_dir3_db_to_fdb (struct xfs_mount *mp,xfs_dir2_db_t db) +{ +return XFS_DIR2_FREE_FIRSTDB (mp) + db /xfs_dir3_free_max_bests (mp); +} + +/* +* Convert data space db to the corresponding index in a free db. +*/ +static int +xfs_dir3_db_to_fdindex (struct xfs_mount *mp,xfs_dir2_db_t db) +{ +return db %xfs_dir3_free_max_bests (mp); +} + static void xfs_dir2_free_hdr_from_disk( struct xfs_dir3_icfree_hdr *to,
@@ -722,8 +796,13 @@ const struct xfs_dir_ops xfs_dir2_ops = { .node_hdr_from_disk = xfs_da2_node_hdr_from_disk, .node_tree_p = xfs_da2_node_tree_p, + .free_hdr_size = xfs_dir2_free_hdr_size, .free_hdr_to_disk = xfs_dir2_free_hdr_to_disk, .free_hdr_from_disk = xfs_dir2_free_hdr_from_disk, + .free_max_bests = xfs_dir2_free_max_bests, + .free_bests_p = xfs_dir2_free_bests_p, + .db_to_fdb = xfs_dir2_db_to_fdb, + .db_to_fdindex = xfs_dir2_db_to_fdindex, };const struct xfs_dir_ops xfs_dir2_ftype_ops = {
@@ -764,8 +843,13 @@ const struct xfs_dir_ops xfs_dir2_ftype_ops = { .node_hdr_from_disk = xfs_da2_node_hdr_from_disk, .node_tree_p = xfs_da2_node_tree_p, + .free_hdr_size = xfs_dir2_free_hdr_size, .free_hdr_to_disk = xfs_dir2_free_hdr_to_disk, .free_hdr_from_disk = xfs_dir2_free_hdr_from_disk, + .free_max_bests = xfs_dir2_free_max_bests, + .free_bests_p = xfs_dir2_free_bests_p, + .db_to_fdb = xfs_dir2_db_to_fdb, + .db_to_fdindex = xfs_dir2_db_to_fdindex, };const struct xfs_dir_ops xfs_dir3_ops = {
@@ -806,8 +890,13 @@ const struct xfs_dir_ops xfs_dir3_ops = { .node_hdr_from_disk = xfs_da3_node_hdr_from_disk, .node_tree_p = xfs_da3_node_tree_p, + .free_hdr_size = xfs_dir3_free_hdr_size, .free_hdr_to_disk = xfs_dir3_free_hdr_to_disk, .free_hdr_from_disk = xfs_dir3_free_hdr_from_disk, + .free_max_bests = xfs_dir3_free_max_bests, + .free_bests_p = xfs_dir3_free_bests_p, + .db_to_fdb = xfs_dir3_db_to_fdb, + .db_to_fdindex = xfs_dir3_db_to_fdindex, };const struct xfs_dir_ops xfs_dir2_nondir_ops = {
fs/xfs/xfs_da_format.h +0 -39
@@ -704,45 +704,6 @@ struct xfs_dir3_icfree_hdr { }; -static inline int -xfs_dir3_free_hdr_size (struct xfs_mount *mp) -{ -if (xfs_sb_version_hascrc (&mp->m_sb)) -return sizeof (struct xfs_dir3_free_hdr ); -return sizeof (struct xfs_dir2_free_hdr ); -} - -static inline int -xfs_dir3_free_max_bests (struct xfs_mount *mp) -{ -return (mp->m_dirblksize -xfs_dir3_free_hdr_size (mp)) / -sizeof (xfs_dir2_data_off_t); -} - -static inline __be16 * -xfs_dir3_free_bests_p (struct xfs_mount *mp,struct xfs_dir2_free *free) -{ -return (__be16 *)((char *)free +xfs_dir3_free_hdr_size (mp)); -} - -/* -* Convert data space db to the corresponding free db. -*/ -static inline xfs_dir2_db_t -xfs_dir2_db_to_fdb (struct xfs_mount *mp,xfs_dir2_db_t db) -{ -return XFS_DIR2_FREE_FIRSTDB (mp) + db /xfs_dir3_free_max_bests (mp); -} - -/* -* Convert data space db to the corresponding index in a free db. -*/ -static inline int -xfs_dir2_db_to_fdindex (struct xfs_mount *mp,xfs_dir2_db_t db) -{ -return db %xfs_dir3_free_max_bests (mp); -} -/* * Single block format. *
fs/xfs/xfs_dir2.h +5 -0
@@ -92,10 +92,15 @@ struct xfs_dir_ops {struct xfs_da_node_entry * (*node_tree_p)(struct xfs_da_intnode *dap); +int (*free_hdr_size)(void );void (*free_hdr_to_disk)(struct xfs_dir2_free *to,struct xfs_dir3_icfree_hdr *from);void (*free_hdr_from_disk)(struct xfs_dir3_icfree_hdr *to,struct xfs_dir2_free *from); +int (*free_max_bests)(struct xfs_mount *mp); +__be16 * (*free_bests_p)(struct xfs_dir2_free *free); +xfs_dir2_db_t (*db_to_fdb)(struct xfs_mount *mp,xfs_dir2_db_t db); +int (*db_to_fdindex)(struct xfs_mount *mp,xfs_dir2_db_t db); }; extern const struct xfs_dir_ops *
fs/xfs/xfs_dir2_leaf.c +1 -1
@@ -1785,7 +1785,7 @@ xfs_dir2_node_to_leaf(/* * Set up the leaf bests table. */ -memcpy (xfs_dir2_leaf_bests_p (ltp),xfs_dir3_free_bests_p (mp, free), +memcpy (xfs_dir2_leaf_bests_p (ltp), dp->d_ops->free_bests_p (free), freehdr.nvalid *sizeof (xfs_dir2_data_off_t)); dp->d_ops->leaf_hdr_to_disk (leaf, &leafhdr);
fs/xfs/xfs_dir2_node.c +31 -30
231 lines not on this page · raw message
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 10/15] xfs: vectorise directory leaf operations
Quoted 19 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Next step in the vectorisation process is the directory free block encode/decode operations. There are relatively few of these, though there are quite a numberof calls to them.
Binary sizes:
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3 789005 96802 1096 886903 d8997 fs/xfs/xfs.o.p4 789061 96802 1096 886959 d88af fs/xfs/xfs.o.p5 789733 96802 1096 887631 d8b4f fs/xfs/xfs.o.p6 791421 96802 1096 889319 d91e7 fs/xfs/xfs.o.p7 791701 96802 1096 889599 d92ff fs/xfs/xfs.o.p8
Quoted 1 line
Signed-off-by Dave Chinner <[email protected]>
Looks good.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 11/15 xfs: convert directory vector functions to constants
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Many of the vectorised function calls now take no parameters and return a constant value. There is no reason for these to be vectored functions, so convert them to constants
Binary sizes:
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3 789005 96802 1096 886903 d8997 fs/xfs/xfs.o.p4 789061 96802 1096 886959 d88af fs/xfs/xfs.o.p5 789733 96802 1096 887631 d8b4f fs/xfs/xfs.o.p6 791421 96802 1096 889319 d91e7 fs/xfs/xfs.o.p7 791701 96802 1096 889599 d92ff fs/xfs/xfs.o.p8 791205 96802 1096 889103 d91cf fs/xfs/xfs.o.p9
--- fs/xfs/xfs_da_btree.c | 14 ++- fs/xfs/xfs_da_format.c | 220 +++++++++++++++++----------------------------- fs/xfs/xfs_dir2.c | 2 +- fs/xfs/xfs_dir2.h | 14 +-- fs/xfs/xfs_dir2_block.c | 4 +- fs/xfs/xfs_dir2_data.c | 8 +- fs/xfs/xfs_dir2_leaf.c | 6 +- fs/xfs/xfs_dir2_node.c | 8 +- fs/xfs/xfs_dir2_readdir.c | 6 +- fs/xfs/xfs_dir2_sf.c | 6 +- 10 files changed, 112 insertions(+), 176 deletions(-)
fs/xfs/xfs_da_btree.c +6 -8
@@ -333,8 +333,7 @@ xfs_da3_node_create( dp->d_ops->node_hdr_to_disk (node, &ichdr);xfs_trans_log_buf (tp, bp, -XFS_DA_LOGRANGE (node, &node->hdr, - dp->d_ops->node_hdr_size ())); +XFS_DA_LOGRANGE (node, &node->hdr, dp->d_ops->node_hdr_size)); *bpp = bp;return (0 );
@@ -838,13 +837,12 @@ xfs_da3_node_rebalance(*/ dp->d_ops->node_hdr_to_disk (node1, &nodehdr1);xfs_trans_log_buf (tp, blk1->bp, -XFS_DA_LOGRANGE (node1, &node1->hdr, - dp->d_ops->node_hdr_size ())); +XFS_DA_LOGRANGE (node1, &node1->hdr, dp->d_ops->node_hdr_size)); dp->d_ops->node_hdr_to_disk (node2, &nodehdr2);xfs_trans_log_buf (tp, blk2->bp,XFS_DA_LOGRANGE (node2, &node2->hdr, - dp->d_ops->node_hdr_size () + + dp->d_ops->node_hdr_size + (sizeof (btree2[0 ]) * nodehdr2.count)));/*
@@ -915,7 +913,7 @@ xfs_da3_node_add( nodehdr.count +=1 ; dp->d_ops->node_hdr_to_disk (node, &nodehdr);xfs_trans_log_buf (state->args->trans, oldblk->bp, -XFS_DA_LOGRANGE (node, &node->hdr, dp->d_ops->node_hdr_size ())); +XFS_DA_LOGRANGE (node, &node->hdr, dp->d_ops->node_hdr_size));/* * Copy the last hash value from the oldblk to propagate upwards.
@@ -1350,7 +1348,7 @@ xfs_da3_node_remove( nodehdr.count -=1 ; dp->d_ops->node_hdr_to_disk (node, &nodehdr);xfs_trans_log_buf (state->args->trans, drop_blk->bp, -XFS_DA_LOGRANGE (node, &node->hdr, dp->d_ops->node_hdr_size ())); +XFS_DA_LOGRANGE (node, &node->hdr, dp->d_ops->node_hdr_size));/* * Copy the last hash value from the block to propagate upwards.
@@ -1423,7 +1421,7 @@ xfs_da3_node_unbalance( dp->d_ops->node_hdr_to_disk (save_node, &save_hdr);xfs_trans_log_buf (tp, save_blk->bp,XFS_DA_LOGRANGE (save_node, &save_node->hdr, - dp->d_ops->node_hdr_size ())); + dp->d_ops->node_hdr_size));/* * Save the last hashval in the remaining block for upward propagation.
fs/xfs/xfs_da_format.c +79 -141
438 lines not on this page · raw message
fs/xfs/xfs_dir2.c +1 -1
@@ -105,7 +105,7 @@ xfs_dir_mount( mp->m_dirleafblk =xfs_dir2_db_to_da (mp,XFS_DIR2_LEAF_FIRSTDB (mp)); mp->m_dirfreeblk =xfs_dir2_db_to_da (mp,XFS_DIR2_FREE_FIRSTDB (mp)); - nodehdr_size = mp->m_dir_inode_ops->node_hdr_size (); + nodehdr_size = mp->m_dir_inode_ops->node_hdr_size; mp->m_attr_node_ents = (mp->m_sb.sb_blocksize - nodehdr_size) / (uint )sizeof (xfs_da_node_entry_t); mp->m_dir_node_ents = (mp->m_dirblksize - nodehdr_size) /
fs/xfs/xfs_dir2.h +7 -7
@@ -59,10 +59,10 @@ struct xfs_dir_ops {struct xfs_dir2_data_free * (*data_bestfree_p)(struct xfs_dir2_data_hdr *hdr); -xfs_dir2_data_aoff_t (*data_dot_offset)(void); -xfs_dir2_data_aoff_t (*data_dotdot_offset)(void); -xfs_dir2_data_aoff_t (*data_first_offset)(void); -size_t (*data_entry_offset)(void ); +xfs_dir2_data_aoff_t data_dot_offset; +xfs_dir2_data_aoff_t data_dotdot_offset; +xfs_dir2_data_aoff_t data_first_offset; +size_t data_entry_offset;struct xfs_dir2_data_entry * (*data_dot_entry_p)(struct xfs_dir2_data_hdr *hdr);
@@ -75,7 +75,7 @@ struct xfs_dir_ops {struct xfs_dir2_data_unused * (*data_unused_p)(struct xfs_dir2_data_hdr *hdr); -int (*leaf_hdr_size)(void ); +int leaf_hdr_size;void (*leaf_hdr_to_disk)(struct xfs_dir2_leaf *to,struct xfs_dir3_icleaf_hdr *from); void (*leaf_hdr_from_disk)(struct xfs_dir3_icleaf_hdr *to,
@@ -84,7 +84,7 @@ struct xfs_dir_ops {struct xfs_dir2_leaf_entry * (*leaf_ents_p)(struct xfs_dir2_leaf *lp); -int (*node_hdr_size)(void ); +int node_hdr_size;void (*node_hdr_to_disk)(struct xfs_da_intnode *to,struct xfs_da3_icnode_hdr *from); void (*node_hdr_from_disk)(struct xfs_da3_icnode_hdr *to,
@@ -92,7 +92,7 @@ struct xfs_dir_ops {struct xfs_da_node_entry * (*node_tree_p)(struct xfs_da_intnode *dap); -int (*free_hdr_size)(void ); +int free_hdr_size;void (*free_hdr_to_disk)(struct xfs_dir2_free *to,struct xfs_dir3_icfree_hdr *from); void (*free_hdr_from_disk)(struct xfs_dir3_icfree_hdr *to,
fs/xfs/xfs_dir2_block.c +2 -2
@@ -951,7 +951,7 @@ xfs_dir2_leaf_to_block(while (dp->i_d.di_size > mp->m_dirblksize) {int hdrsz; - hdrsz = dp->d_ops->data_entry_offset (); + hdrsz = dp->d_ops->data_entry_offset; bestsp =xfs_dir2_leaf_bests_p (ltp);if (be16_to_cpu (bestsp[be32_to_cpu (ltp->bestcount) -1 ]) == mp->m_dirblksize - hdrsz) {
@@ -1185,7 +1185,7 @@ xfs_dir2_sf_to_block( blp[1 ].hashval =cpu_to_be32 (xfs_dir_hash_dotdot); blp[1 ].address =cpu_to_be32 (xfs_dir2_byte_to_dataptr (mp, (char *)dep - (char *)hdr)); - offset = dp->d_ops->data_first_offset (); + offset = dp->d_ops->data_first_offset;/* * Loop over existing entries, stuff them in. */
fs/xfs/xfs_dir2_data.c +4 -4
@@ -598,7 +598,7 @@ xfs_dir3_data_init( hdr->magic =cpu_to_be32 (XFS_DIR2_DATA_MAGIC ); bf = dp->d_ops->data_bestfree_p (hdr); - bf[0 ].offset =cpu_to_be16 (dp->d_ops->data_entry_offset ()); + bf[0 ].offset =cpu_to_be16 (dp->d_ops->data_entry_offset);for (i =1 ; i <XFS_DIR2_DATA_FD_COUNT ; i++) { bf[i].length =0 ; bf[i].offset =0 ;
@@ -610,7 +610,7 @@ xfs_dir3_data_init( dup = dp->d_ops->data_unused_p (hdr); dup->freetag =cpu_to_be16 (XFS_DIR2_DATA_FREE_TAG ); - t = mp->m_dirblksize - (uint )dp->d_ops->data_entry_offset (); + t = mp->m_dirblksize - (uint )dp->d_ops->data_entry_offset; bf[0 ].length =cpu_to_be16 (t); dup->length =cpu_to_be16 (t); *xfs_dir2_data_unused_tag_p (dup) =cpu_to_be16 ((char *)dup - (char *)hdr);
@@ -663,7 +663,7 @@ xfs_dir2_data_log_header( hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));#endif -xfs_trans_log_buf (tp, bp,0 , dp->d_ops->data_entry_offset () -1 ); +xfs_trans_log_buf (tp, bp,0 , dp->d_ops->data_entry_offset -1 ); }/*
@@ -742,7 +742,7 @@ xfs_dir2_data_make_free(* If this isn't the start of the block, then back up to * the previous entry and see if it's free. */ -if (offset > dp->d_ops->data_entry_offset ()) { +if (offset > dp->d_ops->data_entry_offset) {__be16 *tagp;/* tag just before us */ tagp = (__be16 *)((char *)hdr + offset) -1 ;
fs/xfs/xfs_dir2_leaf.c +3 -3
@@ -1116,7 +1116,7 @@ xfs_dir3_leaf_log_header( leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));xfs_trans_log_buf (tp, bp, (uint)((char *)&leaf->hdr - (char *)leaf), - dp->d_ops->leaf_hdr_size () -1 ); + dp->d_ops->leaf_hdr_size -1 ); }/*
@@ -1424,7 +1424,7 @@ xfs_dir2_leaf_removename(* If the data block is now empty then get rid of the data block. */ if (be16_to_cpu (bf[0 ].length) == - mp->m_dirblksize - dp->d_ops->data_entry_offset ()) { + mp->m_dirblksize - dp->d_ops->data_entry_offset) {ASSERT (db != mp->m_dirdatablk);if ((error =xfs_dir2_shrink_inode (args, db, dbp))) {/*
@@ -1623,7 +1623,7 @@ xfs_dir2_leaf_trim_data(ASSERT (hdr->magic ==cpu_to_be32 (XFS_DIR2_DATA_MAGIC ) || hdr->magic ==cpu_to_be32 (XFS_DIR3_DATA_MAGIC ));ASSERT (be16_to_cpu (bf[0 ].length) == - mp->m_dirblksize - dp->d_ops->data_entry_offset ()); + mp->m_dirblksize - dp->d_ops->data_entry_offset); ASSERT(db == be32_to_cpu(ltp->bestcount) - 1); }#endif
fs/xfs/xfs_dir2_node.c +4 -4
@@ -274,7 +274,7 @@ xfs_dir2_free_log_header(ASSERT (free->hdr.magic ==cpu_to_be32 (XFS_DIR2_FREE_MAGIC ) || free->hdr.magic ==cpu_to_be32 (XFS_DIR3_FREE_MAGIC ));#endif -xfs_trans_log_buf (tp, bp,0 , dp->d_ops->free_hdr_size () -1 ); +xfs_trans_log_buf (tp, bp,0 , dp->d_ops->free_hdr_size -1 ); }/*
@@ -1268,7 +1268,7 @@ xfs_dir2_leafn_remove(* (usually). */ if (longest == mp->m_dirblksize - - dp->d_ops->data_entry_offset ()) { + dp->d_ops->data_entry_offset) {/* * Try to punch out the data block. */
@@ -1300,7 +1300,7 @@ xfs_dir2_leafn_remove(* Return indication of whether this leaf block is empty enough * to justify trying to join it with a neighbor. */ - *rval = (dp->d_ops->leaf_hdr_size () + + *rval = (dp->d_ops->leaf_hdr_size + (uint )sizeof (ents[0 ]) * (leafhdr.count - leafhdr.stale)) < mp->m_dir_magicpct;return 0 ;
@@ -1409,7 +1409,7 @@ xfs_dir2_leafn_toosmall(xfs_dir3_leaf_check (dp, blk->bp); count = leafhdr.count - leafhdr.stale; - bytes = dp->d_ops->leaf_hdr_size () + count *sizeof (ents[0 ]); + bytes = dp->d_ops->leaf_hdr_size + count *sizeof (ents[0 ]);if (bytes > (state->blocksize >>1 )) {/* * Blk over 50%, don't try to join.
fs/xfs/xfs_dir2_readdir.c +3 -3
@@ -119,9 +119,9 @@ xfs_dir2_sf_getdents(* mp->m_dirdatablk. */ dot_offset =xfs_dir2_db_off_to_dataptr (mp, mp->m_dirdatablk, - dp->d_ops->data_dot_offset ()); + dp->d_ops->data_dot_offset); dotdot_offset =xfs_dir2_db_off_to_dataptr (mp, mp->m_dirdatablk, - dp->d_ops->data_dotdot_offset ()); + dp->d_ops->data_dotdot_offset);/* * Put . entry unless we're starting past it.
@@ -584,7 +584,7 @@ xfs_dir2_leaf_getdents(* Skip past the header. */ if (byteoff ==0 ) - curoff += dp->d_ops->data_entry_offset (); + curoff += dp->d_ops->data_entry_offset;/* * Skip past entries until we reach our offset. */
fs/xfs/xfs_dir2_sf.c +3 -3
@@ -473,7 +473,7 @@ xfs_dir2_sf_addname_hard(* to insert the new entry. * If it's going to end up at the end then oldsfep will point there. */ - for (offset = dp->d_ops->data_first_offset(), + for (offset = dp->d_ops->data_first_offset, oldsfep = xfs_dir2_sf_firstentry(oldsfp), add_datasize = dp->d_ops->data_entsize(args->namelen), eof = (char *)oldsfep == &buf[old_isize];
@@ -556,7 +556,7 @@ xfs_dir2_sf_addname_pick( sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data; size = dp->d_ops->data_entsize (args->namelen); - offset = dp->d_ops->data_first_offset (); + offset = dp->d_ops->data_first_offset; sfep =xfs_dir2_sf_firstentry (sfp); holefit =0 ;/*
@@ -629,7 +629,7 @@ xfs_dir2_sf_check( mp = dp->i_mount; sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data; - offset = dp->d_ops->data_first_offset (); + offset = dp->d_ops->data_first_offset; ino = dp->d_ops->sf_get_parent_ino (sfp); i8count = ino >XFS_DIR2_MAX_SHORT_INUM ;
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 11/15] xfs: convert directory vector functions to constants
Quoted 20 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Many of the vectorised function calls now take no parameters and return a constant value. There is no reason for these to be vectored functions, so convert them to constants
Binary sizes:
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3 789005 96802 1096 886903 d8997 fs/xfs/xfs.o.p4 789061 96802 1096 886959 d88af fs/xfs/xfs.o.p5 789733 96802 1096 887631 d8b4f fs/xfs/xfs.o.p6 791421 96802 1096 889319 d91e7 fs/xfs/xfs.o.p7 791701 96802 1096 889599 d92ff fs/xfs/xfs.o.p8 791205 96802 1096 889103 d91cf fs/xfs/xfs.o.p9
Quoted 1 line
Signed-off-by Dave Chinner <[email protected]>
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 11/15 xfs: convert directory vector functions to constants
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Many of the vectorised function calls now take no parameters and return a constant value. There is no reason for these to be vectored functions, so convert them to constants
Binary sizes:
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3 789005 96802 1096 886903 d8997 fs/xfs/xfs.o.p4 789061 96802 1096 886959 d88af fs/xfs/xfs.o.p5 789733 96802 1096 887631 d8b4f fs/xfs/xfs.o.p6 791421 96802 1096 889319 d91e7 fs/xfs/xfs.o.p7 791701 96802 1096 889599 d92ff fs/xfs/xfs.o.p8 791205 96802 1096 889103 d91cf fs/xfs/xfs.o.p9
---
V2: fix dir3 dotdot offset calculation to use DIR3_ENTSIZE macro for explicit ftype accounting support.
fs/xfs/xfs_da_btree.c | 14 ++- fs/xfs/xfs_da_format.c | 220 +++++++++++++++++----------------------------- fs/xfs/xfs_dir2.c | 2 +- fs/xfs/xfs_dir2.h | 14 +-- fs/xfs/xfs_dir2_block.c | 4 +- fs/xfs/xfs_dir2_data.c | 8 +- fs/xfs/xfs_dir2_leaf.c | 6 +- fs/xfs/xfs_dir2_node.c | 8 +- fs/xfs/xfs_dir2_readdir.c | 6 +- fs/xfs/xfs_dir2_sf.c | 6 +- 10 files changed, 112 insertions(+), 176 deletions(-)
fs/xfs/xfs_da_btree.c +6 -8
@@ -333,8 +333,7 @@ xfs_da3_node_create( dp->d_ops->node_hdr_to_disk (node, &ichdr);xfs_trans_log_buf (tp, bp, -XFS_DA_LOGRANGE (node, &node->hdr, - dp->d_ops->node_hdr_size ())); +XFS_DA_LOGRANGE (node, &node->hdr, dp->d_ops->node_hdr_size)); *bpp = bp;return (0 );
@@ -838,13 +837,12 @@ xfs_da3_node_rebalance(*/ dp->d_ops->node_hdr_to_disk (node1, &nodehdr1);xfs_trans_log_buf (tp, blk1->bp, -XFS_DA_LOGRANGE (node1, &node1->hdr, - dp->d_ops->node_hdr_size ())); +XFS_DA_LOGRANGE (node1, &node1->hdr, dp->d_ops->node_hdr_size)); dp->d_ops->node_hdr_to_disk (node2, &nodehdr2);xfs_trans_log_buf (tp, blk2->bp,XFS_DA_LOGRANGE (node2, &node2->hdr, - dp->d_ops->node_hdr_size () + + dp->d_ops->node_hdr_size + (sizeof (btree2[0 ]) * nodehdr2.count)));/*
@@ -915,7 +913,7 @@ xfs_da3_node_add( nodehdr.count +=1 ; dp->d_ops->node_hdr_to_disk (node, &nodehdr);xfs_trans_log_buf (state->args->trans, oldblk->bp, -XFS_DA_LOGRANGE (node, &node->hdr, dp->d_ops->node_hdr_size ())); +XFS_DA_LOGRANGE (node, &node->hdr, dp->d_ops->node_hdr_size));/* * Copy the last hash value from the oldblk to propagate upwards.
@@ -1350,7 +1348,7 @@ xfs_da3_node_remove( nodehdr.count -=1 ; dp->d_ops->node_hdr_to_disk (node, &nodehdr);xfs_trans_log_buf (state->args->trans, drop_blk->bp, -XFS_DA_LOGRANGE (node, &node->hdr, dp->d_ops->node_hdr_size ())); +XFS_DA_LOGRANGE (node, &node->hdr, dp->d_ops->node_hdr_size));/* * Copy the last hash value from the block to propagate upwards.
@@ -1423,7 +1421,7 @@ xfs_da3_node_unbalance( dp->d_ops->node_hdr_to_disk (save_node, &save_hdr);xfs_trans_log_buf (tp, save_blk->bp,XFS_DA_LOGRANGE (save_node, &save_node->hdr, - dp->d_ops->node_hdr_size ())); + dp->d_ops->node_hdr_size));/* * Save the last hashval in the remaining block for upward propagation.
fs/xfs/xfs_da_format.c +79 -141
438 lines not on this page · raw message
fs/xfs/xfs_dir2.c +1 -1
@@ -105,7 +105,7 @@ xfs_dir_mount( mp->m_dirleafblk =xfs_dir2_db_to_da (mp,XFS_DIR2_LEAF_FIRSTDB (mp)); mp->m_dirfreeblk =xfs_dir2_db_to_da (mp,XFS_DIR2_FREE_FIRSTDB (mp)); - nodehdr_size = mp->m_dir_inode_ops->node_hdr_size (); + nodehdr_size = mp->m_dir_inode_ops->node_hdr_size; mp->m_attr_node_ents = (mp->m_sb.sb_blocksize - nodehdr_size) / (uint )sizeof (xfs_da_node_entry_t); mp->m_dir_node_ents = (mp->m_dirblksize - nodehdr_size) /
fs/xfs/xfs_dir2.h +7 -7
@@ -59,10 +59,10 @@ struct xfs_dir_ops {struct xfs_dir2_data_free * (*data_bestfree_p)(struct xfs_dir2_data_hdr *hdr); -xfs_dir2_data_aoff_t (*data_dot_offset)(void); -xfs_dir2_data_aoff_t (*data_dotdot_offset)(void); -xfs_dir2_data_aoff_t (*data_first_offset)(void); -size_t (*data_entry_offset)(void ); +xfs_dir2_data_aoff_t data_dot_offset; +xfs_dir2_data_aoff_t data_dotdot_offset; +xfs_dir2_data_aoff_t data_first_offset; +size_t data_entry_offset;struct xfs_dir2_data_entry * (*data_dot_entry_p)(struct xfs_dir2_data_hdr *hdr);
@@ -75,7 +75,7 @@ struct xfs_dir_ops {struct xfs_dir2_data_unused * (*data_unused_p)(struct xfs_dir2_data_hdr *hdr); -int (*leaf_hdr_size)(void ); +int leaf_hdr_size;void (*leaf_hdr_to_disk)(struct xfs_dir2_leaf *to,struct xfs_dir3_icleaf_hdr *from); void (*leaf_hdr_from_disk)(struct xfs_dir3_icleaf_hdr *to,
@@ -84,7 +84,7 @@ struct xfs_dir_ops {struct xfs_dir2_leaf_entry * (*leaf_ents_p)(struct xfs_dir2_leaf *lp); -int (*node_hdr_size)(void ); +int node_hdr_size;void (*node_hdr_to_disk)(struct xfs_da_intnode *to,struct xfs_da3_icnode_hdr *from); void (*node_hdr_from_disk)(struct xfs_da3_icnode_hdr *to,
@@ -92,7 +92,7 @@ struct xfs_dir_ops {struct xfs_da_node_entry * (*node_tree_p)(struct xfs_da_intnode *dap); -int (*free_hdr_size)(void ); +int free_hdr_size;void (*free_hdr_to_disk)(struct xfs_dir2_free *to,struct xfs_dir3_icfree_hdr *from); void (*free_hdr_from_disk)(struct xfs_dir3_icfree_hdr *to,
fs/xfs/xfs_dir2_block.c +2 -2
@@ -951,7 +951,7 @@ xfs_dir2_leaf_to_block(while (dp->i_d.di_size > mp->m_dirblksize) {int hdrsz; - hdrsz = dp->d_ops->data_entry_offset (); + hdrsz = dp->d_ops->data_entry_offset; bestsp =xfs_dir2_leaf_bests_p (ltp);if (be16_to_cpu (bestsp[be32_to_cpu (ltp->bestcount) -1 ]) == mp->m_dirblksize - hdrsz) {
@@ -1185,7 +1185,7 @@ xfs_dir2_sf_to_block( blp[1 ].hashval =cpu_to_be32 (xfs_dir_hash_dotdot); blp[1 ].address =cpu_to_be32 (xfs_dir2_byte_to_dataptr (mp, (char *)dep - (char *)hdr)); - offset = dp->d_ops->data_first_offset (); + offset = dp->d_ops->data_first_offset;/* * Loop over existing entries, stuff them in. */
fs/xfs/xfs_dir2_data.c +4 -4
@@ -598,7 +598,7 @@ xfs_dir3_data_init( hdr->magic =cpu_to_be32 (XFS_DIR2_DATA_MAGIC ); bf = dp->d_ops->data_bestfree_p (hdr); - bf[0 ].offset =cpu_to_be16 (dp->d_ops->data_entry_offset ()); + bf[0 ].offset =cpu_to_be16 (dp->d_ops->data_entry_offset);for (i =1 ; i <XFS_DIR2_DATA_FD_COUNT ; i++) { bf[i].length =0 ; bf[i].offset =0 ;
@@ -610,7 +610,7 @@ xfs_dir3_data_init( dup = dp->d_ops->data_unused_p (hdr); dup->freetag =cpu_to_be16 (XFS_DIR2_DATA_FREE_TAG ); - t = mp->m_dirblksize - (uint )dp->d_ops->data_entry_offset (); + t = mp->m_dirblksize - (uint )dp->d_ops->data_entry_offset; bf[0 ].length =cpu_to_be16 (t); dup->length =cpu_to_be16 (t); *xfs_dir2_data_unused_tag_p (dup) =cpu_to_be16 ((char *)dup - (char *)hdr);
@@ -663,7 +663,7 @@ xfs_dir2_data_log_header( hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));#endif -xfs_trans_log_buf (tp, bp,0 , dp->d_ops->data_entry_offset () -1 ); +xfs_trans_log_buf (tp, bp,0 , dp->d_ops->data_entry_offset -1 ); }/*
@@ -742,7 +742,7 @@ xfs_dir2_data_make_free(* If this isn't the start of the block, then back up to * the previous entry and see if it's free. */ -if (offset > dp->d_ops->data_entry_offset ()) { +if (offset > dp->d_ops->data_entry_offset) {__be16 *tagp;/* tag just before us */ tagp = (__be16 *)((char *)hdr + offset) -1 ;
fs/xfs/xfs_dir2_leaf.c +3 -3
@@ -1116,7 +1116,7 @@ xfs_dir3_leaf_log_header( leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));xfs_trans_log_buf (tp, bp, (uint)((char *)&leaf->hdr - (char *)leaf), - dp->d_ops->leaf_hdr_size () -1 ); + dp->d_ops->leaf_hdr_size -1 ); }/*
@@ -1424,7 +1424,7 @@ xfs_dir2_leaf_removename(* If the data block is now empty then get rid of the data block. */ if (be16_to_cpu (bf[0 ].length) == - mp->m_dirblksize - dp->d_ops->data_entry_offset ()) { + mp->m_dirblksize - dp->d_ops->data_entry_offset) {ASSERT (db != mp->m_dirdatablk);if ((error =xfs_dir2_shrink_inode (args, db, dbp))) {/*
@@ -1623,7 +1623,7 @@ xfs_dir2_leaf_trim_data(ASSERT (hdr->magic ==cpu_to_be32 (XFS_DIR2_DATA_MAGIC ) || hdr->magic ==cpu_to_be32 (XFS_DIR3_DATA_MAGIC ));ASSERT (be16_to_cpu (bf[0 ].length) == - mp->m_dirblksize - dp->d_ops->data_entry_offset ()); + mp->m_dirblksize - dp->d_ops->data_entry_offset); ASSERT(db == be32_to_cpu(ltp->bestcount) - 1); }#endif
fs/xfs/xfs_dir2_node.c +4 -4
@@ -274,7 +274,7 @@ xfs_dir2_free_log_header(ASSERT (free->hdr.magic ==cpu_to_be32 (XFS_DIR2_FREE_MAGIC ) || free->hdr.magic ==cpu_to_be32 (XFS_DIR3_FREE_MAGIC ));#endif -xfs_trans_log_buf (tp, bp,0 , dp->d_ops->free_hdr_size () -1 ); +xfs_trans_log_buf (tp, bp,0 , dp->d_ops->free_hdr_size -1 ); }/*
@@ -1268,7 +1268,7 @@ xfs_dir2_leafn_remove(* (usually). */ if (longest == mp->m_dirblksize - - dp->d_ops->data_entry_offset ()) { + dp->d_ops->data_entry_offset) {/* * Try to punch out the data block. */
@@ -1300,7 +1300,7 @@ xfs_dir2_leafn_remove(* Return indication of whether this leaf block is empty enough * to justify trying to join it with a neighbor. */ - *rval = (dp->d_ops->leaf_hdr_size () + + *rval = (dp->d_ops->leaf_hdr_size + (uint )sizeof (ents[0 ]) * (leafhdr.count - leafhdr.stale)) < mp->m_dir_magicpct;return 0 ;
@@ -1409,7 +1409,7 @@ xfs_dir2_leafn_toosmall(xfs_dir3_leaf_check (dp, blk->bp); count = leafhdr.count - leafhdr.stale; - bytes = dp->d_ops->leaf_hdr_size () + count *sizeof (ents[0 ]); + bytes = dp->d_ops->leaf_hdr_size + count *sizeof (ents[0 ]);if (bytes > (state->blocksize >>1 )) {/* * Blk over 50%, don't try to join.
fs/xfs/xfs_dir2_readdir.c +3 -3
@@ -119,9 +119,9 @@ xfs_dir2_sf_getdents(* mp->m_dirdatablk. */ dot_offset =xfs_dir2_db_off_to_dataptr (mp, mp->m_dirdatablk, - dp->d_ops->data_dot_offset ()); + dp->d_ops->data_dot_offset); dotdot_offset =xfs_dir2_db_off_to_dataptr (mp, mp->m_dirdatablk, - dp->d_ops->data_dotdot_offset ()); + dp->d_ops->data_dotdot_offset);/* * Put . entry unless we're starting past it.
@@ -584,7 +584,7 @@ xfs_dir2_leaf_getdents(* Skip past the header. */ if (byteoff ==0 ) - curoff += dp->d_ops->data_entry_offset (); + curoff += dp->d_ops->data_entry_offset;/* * Skip past entries until we reach our offset. */
fs/xfs/xfs_dir2_sf.c +3 -3
@@ -473,7 +473,7 @@ xfs_dir2_sf_addname_hard(* to insert the new entry. * If it's going to end up at the end then oldsfep will point there. */ - for (offset = dp->d_ops->data_first_offset(), + for (offset = dp->d_ops->data_first_offset, oldsfep = xfs_dir2_sf_firstentry(oldsfp), add_datasize = dp->d_ops->data_entsize(args->namelen), eof = (char *)oldsfep == &buf[old_isize];
@@ -556,7 +556,7 @@ xfs_dir2_sf_addname_pick( sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data; size = dp->d_ops->data_entsize (args->namelen); - offset = dp->d_ops->data_first_offset (); + offset = dp->d_ops->data_first_offset; sfep =xfs_dir2_sf_firstentry (sfp); holefit =0 ;/*
@@ -629,7 +629,7 @@ xfs_dir2_sf_check( mp = dp->i_mount; sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data; - offset = dp->d_ops->data_first_offset (); + offset = dp->d_ops->data_first_offset; ino = dp->d_ops->sf_get_parent_ino (sfp); i8count = ino >XFS_DIR2_MAX_SHORT_INUM ;
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 11/15 V2] xfs: convert directory vector functions to constants
Quoted 20 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Many of the vectorised function calls now take no parameters and return a constant value. There is no reason for these to be vectored functions, so convert them to constants
Binary sizes:
text data bss dec hex filename
794490 96802 1096 892388 d9de4 fs/xfs/xfs.o.orig 792986 96802 1096 890884 d9804 fs/xfs/xfs.o.p1 792350 96802 1096 890248 d9588 fs/xfs/xfs.o.p2 789293 96802 1096 887191 d8997 fs/xfs/xfs.o.p3 789005 96802 1096 886903 d8997 fs/xfs/xfs.o.p4 789061 96802 1096 886959 d88af fs/xfs/xfs.o.p5 789733 96802 1096 887631 d8b4f fs/xfs/xfs.o.p6 791421 96802 1096 889319 d91e7 fs/xfs/xfs.o.p7 791701 96802 1096 889599 d92ff fs/xfs/xfs.o.p8 791205 96802 1096 889103 d91cf fs/xfs/xfs.o.p9
Quoted 1 line
Signed-off-by Dave Chinner <[email protected]>
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 12/15 xfs: make dir2 ftype offset pointers explicit
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Rather than hiding the ftype field size accounting inside the dirent padding for the ".." and first entry offset functions for v2 directory formats, add explicit functions that calculate it correctly.
--- fs/xfs/xfs_da_format.c | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-)
fs/xfs/xfs_da_format.c +21 -2
@@ -334,6 +334,25 @@ xfs_dir2_data_first_entry_p( }static struct xfs_dir2_data_entry * +xfs_dir2_ftype_data_dotdot_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +sizeof (struct xfs_dir2_data_hdr ) + +XFS_DIR3_DATA_ENTSIZE (1 )); +} + +static struct xfs_dir2_data_entry * +xfs_dir2_ftype_data_first_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +sizeof (struct xfs_dir2_data_hdr ) + +XFS_DIR3_DATA_ENTSIZE (1 ) + +XFS_DIR3_DATA_ENTSIZE (2 )); +} + +static struct xfs_dir2_data_entry *xfs_dir3_data_dot_entry_p (struct xfs_dir2_data_hdr *hdr) {
@@ -762,8 +781,8 @@ const struct xfs_dir_ops xfs_dir2_ftype_ops = { .data_entry_offset = sizeof(struct xfs_dir2_data_hdr), .data_dot_entry_p = xfs_dir2_data_dot_entry_p, - .data_dotdot_entry_p = xfs_dir2_data_dotdot_entry_p, - .data_first_entry_p = xfs_dir2_data_first_entry_p, + .data_dotdot_entry_p = xfs_dir2_ftype_data_dotdot_entry_p, + .data_first_entry_p = xfs_dir2_ftype_data_first_entry_p, .data_entry_p = xfs_dir2_data_entry_p, .data_unused_p = xfs_dir2_data_unused_p,
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 12/15] xfs: make dir2 ftype offset pointers explicit
Quoted 27 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Rather than hiding the ftype field size accounting inside the dirent padding for the ".." and first entry offset functions for v2 directory formats, add explicit functions that calculate it correctly.
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/xfs_da_format.c | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-)fs/xfs/xfs_da_format.c +7
-0@@ -334,6 +334,25 @@ xfs_dir2_data_first_entry_p( }static struct xfs_dir2_data_entry * +xfs_dir2_ftype_data_dotdot_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +sizeof (struct xfs_dir2_data_hdr ) + +XFS_DIR3_DATA_ENTSIZE (1 )); +}
fs/xfs/xfs_da_format.c xfs_dir2_data_first_entry_p( · line 353
Quoted 10 lines
fs/xfs/xfs_da_format.c +10
-0+ +static struct xfs_dir2_data_entry * +xfs_dir2_ftype_data_first_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +sizeof (struct xfs_dir2_data_hdr ) + +XFS_DIR3_DATA_ENTSIZE (1 ) + +XFS_DIR3_DATA_ENTSIZE (2 )); +}
363 static struct xfs_dir2_data_entry *
364 xfs_dir3_data_dotdot_entry_p(
365 struct xfs_dir2_data_hdr *hdr)
366 {
367 return (struct xfs_dir2_data_entry *)
368 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr) +
369 XFS_DIR2_DATA_ENTSIZE(1));
370 }
371
372 static struct xfs_dir2_data_entry *
373 xfs_dir3_data_first_entry_p(
374 struct xfs_dir2_data_hdr *hdr)
375 {
376 return (struct xfs_dir2_data_entry *)
377 ((char *)hdr + sizeof(struct xfs_dir3_data_hdr) +
378 XFS_DIR2_DATA_ENTSIZE(1) +
379 XFS_DIR2_DATA_ENTSIZE(2));
380 }
3
We want dir3 entry size there, I think?
Quoted 23 lines
fs/xfs/xfs_da_format.c +4
-2+ +static struct xfs_dir2_data_entry *xfs_dir3_data_dot_entry_p (struct xfs_dir2_data_hdr *hdr) {@@ -762,8 +781,8 @@ const struct xfs_dir_ops xfs_dir2_ftype_ops = { .data_entry_offset = sizeof(struct xfs_dir2_data_hdr), .data_dot_entry_p = xfs_dir2_data_dot_entry_p, - .data_dotdot_entry_p = xfs_dir2_data_dotdot_entry_p, - .data_first_entry_p = xfs_dir2_data_first_entry_p, + .data_dotdot_entry_p = xfs_dir2_ftype_data_dotdot_entry_p, + .data_first_entry_p = xfs_dir2_ftype_data_first_entry_p, .data_entry_p = xfs_dir2_data_entry_p, .data_unused_p = xfs_dir2_data_unused_p,Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 12/15] xfs: make dir2 ftype offset pointers explicit
Quoted 57 lines · Ben Myers
Quoted 27 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Rather than hiding the ftype field size accounting inside the dirent padding for the ".." and first entry offset functions for v2 directory formats, add explicit functions that calculate it correctly.
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/xfs_da_format.c | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-)fs/xfs/xfs_da_format.c +7
-0@@ -334,6 +334,25 @@ xfs_dir2_data_first_entry_p( }static struct xfs_dir2_data_entry * +xfs_dir2_ftype_data_dotdot_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +sizeof (struct xfs_dir2_data_hdr ) + +XFS_DIR3_DATA_ENTSIZE (1 )); +}fs/xfs/xfs_da_format.c xfs_dir2_data_first_entry_p( · line 353
Quoted 10 lines
fs/xfs/xfs_da_format.c +10
-0+ +static struct xfs_dir2_data_entry * +xfs_dir2_ftype_data_first_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +sizeof (struct xfs_dir2_data_hdr ) + +XFS_DIR3_DATA_ENTSIZE (1 ) + +XFS_DIR3_DATA_ENTSIZE (2 )); +}363 static struct
xfs_dir2_data_entry*
364 xfs_dir3_data_dotdot_entry_p(
365 structxfs_dir2_data_hdr*hdr)
366 {
367 return (structxfs_dir2_data_entry*)
368 ((char *)hdr +sizeof(struct xfs_dir3_data_hdr)+
369XFS_DIR2_DATA_ENTSIZE(1));
370 }
371
372 static structxfs_dir2_data_entry*
373 xfs_dir3_data_first_entry_p(
374 structxfs_dir2_data_hdr*hdr)
375 {
376 return (structxfs_dir2_data_entry*)
377 ((char *)hdr +sizeof(struct xfs_dir3_data_hdr)+
378XFS_DIR2_DATA_ENTSIZE(1)+
379XFS_DIR2_DATA_ENTSIZE(2));
380 }
Quoted 3 lines
3We want dir3 entry size there, I think?
Fixed in V2 of the patch that introduced the problem.
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Ben Myers
Reviewed-byRe: [PATCH 12/15] xfs: make dir2 ftype offset pointers explicit
Quoted 60 lines · Dave Chinner
Quoted 59 lines · Ben Myers
Quoted 27 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Rather than hiding the ftype field size accounting inside the dirent padding for the ".." and first entry offset functions for v2 directory formats, add explicit functions that calculate it correctly.
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/xfs_da_format.c | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-)fs/xfs/xfs_da_format.c +7
-0@@ -334,6 +334,25 @@ xfs_dir2_data_first_entry_p( }static struct xfs_dir2_data_entry * +xfs_dir2_ftype_data_dotdot_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +sizeof (struct xfs_dir2_data_hdr ) + +XFS_DIR3_DATA_ENTSIZE (1 )); +}fs/xfs/xfs_da_format.c xfs_dir2_data_first_entry_p( · line 353
Quoted 10 lines
fs/xfs/xfs_da_format.c +10
-0+ +static struct xfs_dir2_data_entry * +xfs_dir2_ftype_data_first_entry_p ( +struct xfs_dir2_data_hdr *hdr) +{ +return (struct xfs_dir2_data_entry *) + ((char *)hdr +sizeof (struct xfs_dir2_data_hdr ) + +XFS_DIR3_DATA_ENTSIZE (1 ) + +XFS_DIR3_DATA_ENTSIZE (2 )); +}363 static struct
xfs_dir2_data_entry*
364 xfs_dir3_data_dotdot_entry_p(
365 structxfs_dir2_data_hdr*hdr)
366 {
367 return (structxfs_dir2_data_entry*)
368 ((char *)hdr +sizeof(struct xfs_dir3_data_hdr)+
369XFS_DIR2_DATA_ENTSIZE(1));
370 }
371
372 static structxfs_dir2_data_entry*
373 xfs_dir3_data_first_entry_p(
374 structxfs_dir2_data_hdr*hdr)
375 {
376 return (structxfs_dir2_data_entry*)
377 ((char *)hdr +sizeof(struct xfs_dir3_data_hdr)+
378XFS_DIR2_DATA_ENTSIZE(1)+
379XFS_DIR2_DATA_ENTSIZE(2));
380 }3
Quoted 3 lines
Quoted 1 line
We want dir3 entry size there, I think?
Fixed in V2 of the patch that introduced the problem.
Fine.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 13/15 xfs: validity check the directory block leaf entry count
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
The directory block format verifier fails to check that the leaf entry count is in a valid range, and so if it is corrupted then it can lead to derefencing a pointer outside the block buffer. While we can't exactly validate the count without first walking the directory block, we can ensure the count lands in the valid area within the directory block and hence avoid out-of-block references.
--- fs/xfs/xfs_dir2_data.c | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-)
fs/xfs/xfs_dir2_data.c +15 -4
@@ -65,7 +65,6 @@ __xfs_dir3_data_check(const struct xfs_dir_ops *ops; mp = bp->b_target->bt_mount; - hdr = bp->b_addr;/* * We can be passed a null dp here from a verifier, so we need to go the
@@ -73,12 +72,25 @@ __xfs_dir3_data_check(*/ ops =xfs_dir_get_ops (mp, dp); + hdr = bp->b_addr; + p = (char *)ops->data_entry_p (hdr); +switch (hdr->magic) {case cpu_to_be32 (XFS_DIR3_BLOCK_MAGIC ):case cpu_to_be32 (XFS_DIR2_BLOCK_MAGIC ): btp =xfs_dir2_block_tail_p (mp, hdr); lep =xfs_dir2_block_leaf_p (btp); endp = (char *)lep; + +/* +* The number of leaf entries is limited by the size of the +* block and the amount of space used by the data entries. +* We don't know how much space is used by the data entries yet, +* so just ensure that the count falls somewhere inside the +* block right now. +*/ +XFS_WANT_CORRUPTED_RETURN (be32_to_cpu (btp->count) < + ((char *)btp - p) /sizeof (struct xfs_dir2_leaf_entry ));break ;case cpu_to_be32 (XFS_DIR3_DATA_MAGIC ):case cpu_to_be32 (XFS_DIR2_DATA_MAGIC ):
@@ -88,13 +100,12 @@ __xfs_dir3_data_check(XFS_ERROR_REPORT ("Bad Magic" ,XFS_ERRLEVEL_LOW , mp);return EFSCORRUPTED ; } - bf = ops->data_bestfree_p (hdr); - p = (char *)ops->data_entry_p (hdr); - count = lastfree = freeseen =0 ;/* * Account for zero bestfree entries. */ + bf = ops->data_bestfree_p (hdr); + count = lastfree = freeseen =0 ;if (!bf[0 ].length) {XFS_WANT_CORRUPTED_RETURN (!bf[0 ].offset); freeseen |=1 <<0 ;
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 13/15] xfs: validity check the directory block leaf entry count
Quoted 10 lines · Dave Chinner
From: Dave Chinner <[email protected]>
The directory block format verifier fails to check that the leaf entry count is in a valid range, and so if it is corrupted then it can lead to derefencing a pointer outside the block buffer. While we can't exactly validate the count without first walking the directory block, we can ensure the count lands in the valid area within the directory block and hence avoid out-of-block references.
Signed-off-by Dave Chinner <[email protected]>
Looks fine.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 14/15 xfs: prevent stack overflows from page cache allocation
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Page cache allocation doesn't always go through ->begin_write and hence we don't always get the opportunity to set the allocation context to GFP_NOFS. Failing to do this means we open up the direct relcaim stack to recurse into the filesystem and consume a significant amount of stack.
On RHEL6.4 kernels we are seeing ra_submit() and generic_file_splice_read() from an nfsd context recursing into the filesystem via the inode cache shrinker and evicting inodes. This is causing truncation to be run (e.g EOF block freeing) and causing bmap btree block merges and free space btree block splits to occur. These btree manipulations are occurring with the call chain already 30 functions deep and hence there is not enough stack space to complete such operations.
To avoid these specific overruns, we need to prevent the page cache allocation from recursing via direct reclaim. We can do that because the allocation functions take the allocation context from that which is stored in the mapping for the inode. We don't set that right now, so the default is GFP_HIGHUSER_MOVABLE, which is effectively a GFP_KERNEL context. We need it to be the equivalent of GFP_NOFS, so when we initialise an inode, set the mapping gfp mask appropriately.
This makes the use of AOP_FLAG_NOFS redundant from other parts of the XFS IO path, so get rid of it.
--- fs/xfs/xfs_aops.c | 3 +-- fs/xfs/xfs_iops.c | 9 +++++++++ 2 files changed, 10 insertions(+), 2 deletions(-)
fs/xfs/xfs_aops.c +1 -2
@@ -1572,8 +1572,7 @@ xfs_vm_write_begin(ASSERT (len <=PAGE_CACHE_SIZE ); - page =grab_cache_page_write_begin (mapping, index, - flags |AOP_FLAG_NOFS ); + page =grab_cache_page_write_begin (mapping, index, flags);if (!page)return -ENOMEM ;
fs/xfs/xfs_iops.c +9 -0
@@ -1168,6 +1168,7 @@ xfs_setup_inode( struct xfs_inode *ip) {struct inode *inode = &ip->i_vnode; +gfp_t gfp_mask; inode->i_ino = ip->i_ino; inode->i_state =I_NEW ;
@@ -1230,6 +1231,14 @@ xfs_setup_inode( }/* +* Ensure all page cache allocations are done from GFP_NOFS context to +* prevent direct reclaim recursion back into the filesystem and blowing +* stacks or deadlocking. +*/ + gfp_mask =mapping_gfp_mask (inode->i_mapping); +mapping_set_gfp_mask (inode->i_mapping, (gfp_mask & ~(__GFP_FS))); + +/* * If there is no attribute fork no ACL can exist on this inode, * and it can't have any file capabilities attached to it either. */
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 14/15] xfs: prevent stack overflows from page cache allocation
Looks good, thanks.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 14/15] xfs: prevent stack overflows from page cache allocation
In reply to Dave ChinnerQuoted 25 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Page cache allocation doesn't always go through ->begin_write and hence we don't always get the opportunity to set the allocation context to
GFP_NOFS. Failing to do this means we open up the direct relcaim stack to recurse into the filesystem and consume a significant amount of stack.On RHEL6.4 kernels we are seeing
ra_submit()andgeneric_file_splice_read()from an nfsd context recursing into the filesystem via the inode cache shrinker and evicting inodes. This is causing truncation to be run (e.g EOF block freeing) and causing bmap btree block merges and free space btree block splits to occur. These btree manipulations are occurring with the call chain already 30 functions deep and hence there is not enough stack space to complete such operations.To avoid these specific overruns, we need to prevent the page cache allocation from recursing via direct reclaim. We can do that because the allocation functions take the allocation context from that which is stored in the mapping for the inode. We don't set that right now, so the default is
GFP_HIGHUSER_MOVABLE, which is effectively aGFP_KERNELcontext. We need it to be the equivalent ofGFP_NOFS, so when we initialise an inode, set the mapping gfp mask appropriately.
Quoted 4 lines
This makes the use of
AOP_FLAG_NOFSredundant from other parts of the XFS IO path, so get rid of it.Signed-off-by Dave Chinner <[email protected]>
Applied this.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 15/15 xfs: fix static and extern sparse warnings
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
The kbuild test robot indicated that there were some new sparse warnings in fs/xfs/xfs_dquot_buf.c. Actually, there were a lot more that is wasn't warning about, so fix them all up.
--- fs/xfs/xfs_alloc_btree.c | 1 + fs/xfs/xfs_attr_leaf.c | 1 + fs/xfs/xfs_attr_remote.c | 1 + fs/xfs/xfs_bit.c | 1 + fs/xfs/xfs_bmap_btree.c | 1 + fs/xfs/xfs_buf_item.c | 2 +- fs/xfs/xfs_da_format.c | 11 ++++++----- fs/xfs/xfs_dquot_buf.c | 3 ++- fs/xfs/xfs_ialloc_btree.c | 1 + fs/xfs/xfs_rtbitmap.c | 1 + fs/xfs/xfs_sb.c | 1 + fs/xfs/xfs_super.c | 2 +- 12 files changed, 18 insertions(+), 8 deletions(-)
fs/xfs/xfs_alloc_btree.c +1 -0
@@ -17,6 +17,7 @@*/ #include "xfs.h" #include "xfs_fs.h" +#include "xfs_shared.h" #include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h"
fs/xfs/xfs_attr_leaf.c +1 -0
@@ -18,6 +18,7 @@*/ #include "xfs.h" #include "xfs_fs.h" +#include "xfs_shared.h" #include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h"
fs/xfs/xfs_attr_remote.c +1 -0
@@ -18,6 +18,7 @@*/ #include "xfs.h" #include "xfs_fs.h" +#include "xfs_shared.h" #include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h"
fs/xfs/xfs_bit.c +1 -0
@@ -17,6 +17,7 @@*/ #include "xfs.h" #include "xfs_log_format.h" +#include "xfs_bit.h" /* * XFS bit manipulation routines, used in non-realtime code.
fs/xfs/xfs_bmap_btree.c +1 -0
@@ -17,6 +17,7 @@*/ #include "xfs.h" #include "xfs_fs.h" +#include "xfs_shared.h" #include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h"
fs/xfs/xfs_buf_item.c +1 -1
@@ -809,7 +809,7 @@ xfs_buf_item_init(* Mark bytes first through last inclusive as dirty in the buf * item's bitmap. */ -void +static void xfs_buf_item_log_segment( struct xfs_buf_log_item *bip, uint first,
fs/xfs/xfs_da_format.c +6 -5
@@ -18,6 +18,7 @@*/ #include "xfs.h" #include "xfs_fs.h" +#include "xfs_shared.h" #include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h"
@@ -706,7 +707,7 @@ xfs_dir3_free_hdr_to_disk( hdr3->nused =cpu_to_be32 (from->nused); } -const struct xfs_dir_ops xfs_dir2_ops = { +static const struct xfs_dir_ops xfs_dir2_ops = { .sf_entsize = xfs_dir2_sf_entsize, .sf_nextentry = xfs_dir2_sf_nextentry, .sf_get_ftype = xfs_dir2_sfe_get_ftype,
@@ -756,7 +757,7 @@ const struct xfs_dir_ops xfs_dir2_ops = { .db_to_fdindex = xfs_dir2_db_to_fdindex, }; -const struct xfs_dir_ops xfs_dir2_ftype_ops = { +static const struct xfs_dir_ops xfs_dir2_ftype_ops = { .sf_entsize = xfs_dir3_sf_entsize, .sf_nextentry = xfs_dir3_sf_nextentry, .sf_get_ftype = xfs_dir3_sfe_get_ftype,
@@ -806,7 +807,7 @@ const struct xfs_dir_ops xfs_dir2_ftype_ops = { .db_to_fdindex = xfs_dir2_db_to_fdindex, }; -const struct xfs_dir_ops xfs_dir3_ops = { +static const struct xfs_dir_ops xfs_dir3_ops = { .sf_entsize = xfs_dir3_sf_entsize, .sf_nextentry = xfs_dir3_sf_nextentry, .sf_get_ftype = xfs_dir3_sfe_get_ftype,
@@ -856,14 +857,14 @@ const struct xfs_dir_ops xfs_dir3_ops = { .db_to_fdindex = xfs_dir3_db_to_fdindex, }; -const struct xfs_dir_ops xfs_dir2_nondir_ops = { +static const struct xfs_dir_ops xfs_dir2_nondir_ops = { .node_hdr_size =sizeof (struct xfs_da_node_hdr ), .node_hdr_to_disk = xfs_da2_node_hdr_to_disk, .node_hdr_from_disk = xfs_da2_node_hdr_from_disk, .node_tree_p = xfs_da2_node_tree_p, }; -const struct xfs_dir_ops xfs_dir3_nondir_ops = { +static const struct xfs_dir_ops xfs_dir3_nondir_ops = { .node_hdr_size =sizeof (struct xfs_da3_node_hdr ), .node_hdr_to_disk = xfs_da3_node_hdr_to_disk, .node_hdr_from_disk = xfs_da3_node_hdr_from_disk,
fs/xfs/xfs_dquot_buf.c +2 -1
@@ -18,6 +18,7 @@*/ #include "xfs.h" #include "xfs_fs.h" +#include "xfs_shared.h" #include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h"
@@ -267,7 +268,7 @@ xfs_dquot_buf_read_verify(* the buffer after the update is done. This ensures that the dquot in the * buffer always has an up-to-date CRC value. */ -void +static void xfs_dquot_buf_write_verify (struct xfs_buf *bp) {
fs/xfs/xfs_ialloc_btree.c +1 -0
@@ -17,6 +17,7 @@*/ #include "xfs.h" #include "xfs_fs.h" +#include "xfs_shared.h" #include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h"
fs/xfs/xfs_rtbitmap.c +1 -0
@@ -37,6 +37,7 @@#include "xfs_buf.h" #include "xfs_icache.h" #include "xfs_dinode.h" +#include "xfs_rtalloc.h" /*
fs/xfs/xfs_sb.c +1 -0
@@ -17,6 +17,7 @@*/ #include "xfs.h" #include "xfs_fs.h" +#include "xfs_shared.h" #include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h"
fs/xfs/xfs_super.c +1 -1
@@ -1155,7 +1155,7 @@ xfs_restore_resvblks(struct xfs_mount *mp)* Note: xfs_log_quiesce() stops background log work - the callers must ensure * it is started again when appropriate. */ -void +static void xfs_quiesce_attr (struct xfs_mount *mp) {
Signature · 6 lines
1.8.4.rc3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 15/15] xfs: fix static and extern sparse warnings
Quoted 8 lines · Dave Chinner
From: Dave Chinner <[email protected]>
The kbuild test robot indicated that there were some new sparse warnings in
fs/xfs/xfs_dquot_buf.c. Actually, there were a lot more that is wasn't warning about, so fix them all up.Reported-by kbuild test robotSigned-off-by Dave Chinner <[email protected]>
Looks good.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Quoted 10 lines · Dave Chinner
This is a repost of the previous series with all the issues your review found fixed up. It also has a few new patches, the first of which is fixing the dir2/ftype offset issue you noticed.
The remaining new patches add a new validity check to the directory block checking code to avoid a reference outside the directory buffer, the patch to avoid stack overflows from the page cache which has been updated to remove the
AOP_FLAG_NOFSusage in XFS, and then a final patch to clean up a bunch of new sparse warnings introduced by the recent round of code movement.
Applied 3-13 and 15.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs