xfs: couple of patches for 3.9
cover xfs: couple of patches for 3.9
Hi folks,
These are a couple of patches I have in my queue that are should be OK for the 3.9 cycle. The first is a fixed version of the specualtive preallocation sparse file handling improvement - it now does what it claims to do. :)
The second is a re-organisation of xfs_bmap.c, I got sick of having to jump all over the file when trying to work on a small part of the code, so I rearranged the code into a more sane layout. It's a big patch, but it doesn't change any code except to remove the forward declarations of various functions. It's not a big deal if nobody wants this, but I find the re-organised layout much easier to deal with, and potentially points at ways that big file can be split up if we want to...
Cheers,
Dave.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 1/2 xfs: limit speculative prealloc size on sparse files
From: Dave Chinner <[email protected]>
Speculative preallocation based on the current file size works well for contiguous files, but is sub-optimal for sparse files where the EOF preallocation can fill holes and result in large amounts of zeros being written when it is not necessary.
The algorithm is modified to prevent EOF speculative preallocation from triggering larger allocations on IO patterns of truncate--to-zero-seek-write-seek-write-.... which results in non-sparse files for large files. This, unfortunately, is the way cp now behaves when copying sparse files and so needs to be fixed.
What this code does is that it looks at the existing extent adjacent to the current EOF and if it determines that it is a hole we disable speculative preallocation altogether. To avoid the next write from doing a large prealloc, it takes the size of subsequent preallocations from the current size of the existing EOF extent. IOWs, if you leave a hole in the file, it resets preallocation behaviour to the same as if it was a zero size file.
Example new behaviour:
$ xfs_io -f -c "pwrite 0 31m" \
-c "pwrite 33m 1m" \
-c "pwrite 128m 1m" \
-c "fiemap -v" /mnt/scratch/blah
wrote 32505856/32505856 bytes at offset 0
31 MiB, 7936 ops; 0.0000 sec (1.608 GiB/sec and 421432.7439 ops/sec)
wrote 1048576/1048576 bytes at offset 34603008
1 MiB, 256 ops; 0.0000 sec (1.462 GiB/sec and 383233.5329 ops/sec)
wrote 1048576/1048576 bytes at offset 134217728
1 MiB, 256 ops; 0.0000 sec (1.719 GiB/sec and 450704.2254 ops/sec)
/mnt/scratch/blah:
EXT: FILE-OFFSET BLOCK-RANGE TOTAL FLAGS
0: [0..65535]: 96..65631 65536 0x0
1: [65536..67583]: hole 2048
2: [67584..69631]: 67680..69727 2048 0x0
3: [69632..262143]: hole 192512
4: [262144..264191]: 262240..264287 2048 0x1--- fs/xfs/xfs_iomap.c | 77 +++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 67 insertions(+), 10 deletions(-)
fs/xfs/xfs_iomap.c +67 -10
@@ -311,6 +311,62 @@ xfs_iomap_eof_want_preallocate( }/* +* Determine the initial size of the preallocation. We are beyond the current +* EOF here, but we need to take into account whether this is a sparse write or +* an extending write when determining the preallocation size. Hence we need to +* look up the extent that ends at the current write offset and use the result +* to determine the preallocation size. +* +* If the extent is a hole, then preallocation is essentially disabled. +* Otherwise we take the size of the preceeding data extent as the basis for the +* preallocation size. If the size of the extent is greater than half the +* maximum extent length, then use the current offset as the basis. This ensures +* that for large files the preallocation size always extends to MAXEXTLEN +* rather than falling short due to things like stripe unit/width alignment of +* real extents. +*/ +STATIC int +xfs_iomap_eof_prealloc_initial_size ( +struct xfs_mount *mp, +struct xfs_inode *ip, +xfs_off_t offset, +xfs_bmbt_irec_t *imap, +int nimaps) +{ +xfs_fileoff_t start_fsb; +int imaps =1 ; +int error; + +ASSERT (nimaps >= imaps); + +/* if we are using a specific prealloc size, return now */ +if (mp->m_flags &XFS_MOUNT_DFLT_IOSIZE ) +return 0 ; + +/* +* As we write multiple pages, the offset will always align to the +* start of a page and hence point to a hole at EOF. i.e. if the size if +* 4096 bytes, we only have one block at FSB 0, but XFS_B_TO_FSB(4096) +* will return FSB 1. Hence if there are blocks in the file, we want to +* point to the block prior to the EOF block and not the hole that maps +* directly at @offset. +*/ + start_fsb =XFS_B_TO_FSB (mp, offset); +if (start_fsb) + start_fsb--; + error =xfs_bmapi_read (ip, start_fsb,1 , imap, &imaps,XFS_BMAPI_ENTIRE ); +if (error) +return 0 ; + +ASSERT (imaps ==1 ); +if (imap[0 ].br_startblock ==HOLESTARTBLOCK ) +return 0 ; +if (imap[0 ].br_blockcount <= (MAXEXTLEN >>1 )) +return imap[0 ].br_blockcount; +return XFS_B_TO_FSB (mp, offset); +} + +/* * If we don't have a user specified preallocation size, dynamically increase * the preallocation size as the size of the file grows. Cap the maximum size * at a single extent or less if the filesystem is near full. The closer the
@@ -319,20 +375,19 @@ xfs_iomap_eof_want_preallocate( STATIC xfs_fsblock_txfs_iomap_prealloc_size (struct xfs_mount *mp, -struct xfs_inode *ip) +struct xfs_inode *ip, +xfs_off_t offset, +struct xfs_bmbt_irec *imap, +int nimaps) {xfs_fsblock_t alloc_blocks =0 ; -if (!(mp->m_flags &XFS_MOUNT_DFLT_IOSIZE )) { + alloc_blocks =xfs_iomap_eof_prealloc_initial_size (mp, ip, offset, + imap, nimaps); +if (alloc_blocks >0 ) {int shift =0 ;int64_t freesp; -/* -* rounddown_pow_of_two() returns an undefined result -* if we pass in alloc_blocks = 0. Hence the "+ 1" to -* ensure we always pass in a non-zero value. -*/ - alloc_blocks =XFS_B_TO_FSB (mp,XFS_ISIZE (ip)) +1 ; alloc_blocks =XFS_FILEOFF_MIN (MAXEXTLEN ,rounddown_pow_of_two (alloc_blocks));
@@ -399,7 +454,6 @@ xfs_iomap_write_delay( extsz =xfs_get_extsz_hint (ip); offset_fsb =XFS_B_TO_FSBT (mp, offset); - error =xfs_iomap_eof_want_preallocate (mp, ip, offset, count, imap,XFS_WRITE_IMAPS , &prealloc);if (error)
@@ -407,7 +461,10 @@ xfs_iomap_write_delay( retry:if (prealloc) { -xfs_fsblock_t alloc_blocks =xfs_iomap_prealloc_size (mp, ip); +xfs_fsblock_t alloc_blocks; + + alloc_blocks =xfs_iomap_prealloc_size (mp, ip, offset, imap, +XFS_WRITE_IMAPS ); aligned_offset =XFS_WRITEIO_ALIGN (mp, (offset + count -1 )); ioalign =XFS_B_TO_FSBT (mp, aligned_offset);
Signature · 6 lines
1.7.10 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 1/2] xfs: limit speculative prealloc size on sparse files
Quoted 41 lines · Dave Chinner
From: Dave Chinner<[email protected]>
Speculative preallocation based on the current file size works well for contiguous files, but is sub-optimal for sparse files where the EOF preallocation can fill holes and result in large amounts of zeros being written when it is not necessary.
The algorithm is modified to prevent EOF speculative preallocation from triggering larger allocations on IO patterns of truncate--to-zero-seek-write-seek-write-.... which results in non-sparse files for large files. This, unfortunately, is the way cp now behaves when copying sparse files and so needs to be fixed.
What this code does is that it looks at the existing extent adjacent to the current EOF and if it determines that it is a hole we disable speculative preallocation altogether. To avoid the next write from doing a large prealloc, it takes the size of subsequent preallocations from the current size of the existing EOF extent. IOWs, if you leave a hole in the file, it resets preallocation behaviour to the same as if it was a zero size file.
Example new behaviour:
$ xfs_io -f -c "pwrite 0 31m" \ -c "pwrite 33m 1m" \ -c "pwrite 128m 1m" \ -c "fiemap -v" /mnt/scratch/blah wrote 32505856/32505856 bytes at offset 0 31 MiB, 7936 ops; 0.0000 sec (1.608 GiB/sec and 421432.7439 ops/sec) wrote 1048576/1048576 bytes at offset 34603008 1 MiB, 256 ops; 0.0000 sec (1.462 GiB/sec and 383233.5329 ops/sec) wrote 1048576/1048576 bytes at offset 134217728 1 MiB, 256 ops; 0.0000 sec (1.719 GiB/sec and 450704.2254 ops/sec) /mnt/scratch/blah: EXT: FILE-OFFSET BLOCK-RANGE TOTAL FLAGS 0: [0..65535]: 96..65631 65536 0x0 1: [65536..67583]: hole 2048 2: [67584..69631]: 67680..69727 2048 0x0 3: [69632..262143]: hole 192512 4: [262144..264191]: 262240..264287 2048 0x1
Quoted 2 lines
Signed-off-by Dave Chinner<[email protected]>---
Works great. The above xfs_io example makes a good start of a test.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 1/2] xfs: limit speculative prealloc size on sparse files
In reply to Dave ChinnerQuoted 79 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Speculative preallocation based on the current file size works well for contiguous files, but is sub-optimal for sparse files where the EOF preallocation can fill holes and result in large amounts of zeros being written when it is not necessary.
The algorithm is modified to prevent EOF speculative preallocation from triggering larger allocations on IO patterns of truncate--to-zero-seek-write-seek-write-.... which results in non-sparse files for large files. This, unfortunately, is the way cp now behaves when copying sparse files and so needs to be fixed.
What this code does is that it looks at the existing extent adjacent to the current EOF and if it determines that it is a hole we disable speculative preallocation altogether. To avoid the next write from doing a large prealloc, it takes the size of subsequent preallocations from the current size of the existing EOF extent. IOWs, if you leave a hole in the file, it resets preallocation behaviour to the same as if it was a zero size file.
Example new behaviour:
$ xfs_io -f -c "pwrite 0 31m" \ -c "pwrite 33m 1m" \ -c "pwrite 128m 1m" \ -c "fiemap -v" /mnt/scratch/blah wrote 32505856/32505856 bytes at offset 0 31 MiB, 7936 ops; 0.0000 sec (1.608 GiB/sec and 421432.7439 ops/sec) wrote 1048576/1048576 bytes at offset 34603008 1 MiB, 256 ops; 0.0000 sec (1.462 GiB/sec and 383233.5329 ops/sec) wrote 1048576/1048576 bytes at offset 134217728 1 MiB, 256 ops; 0.0000 sec (1.719 GiB/sec and 450704.2254 ops/sec) /mnt/scratch/blah: EXT: FILE-OFFSET BLOCK-RANGE TOTAL FLAGS 0: [0..65535]: 96..65631 65536 0x0 1: [65536..67583]: hole 2048 2: [67584..69631]: 67680..69727 2048 0x0 3: [69632..262143]: hole 192512 4: [262144..264191]: 262240..264287 2048 0x1Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/xfs_iomap.c | 77 +++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 67 insertions(+), 10 deletions(-)fs/xfs/xfs_iomap.c +25
-0@@ -311,6 +311,62 @@ xfs_iomap_eof_want_preallocate( }/* +* Determine the initial size of the preallocation. We are beyond the current +* EOF here, but we need to take into account whether this is a sparse write or +* an extending write when determining the preallocation size. Hence we need to +* look up the extent that ends at the current write offset and use the result +* to determine the preallocation size. +* +* If the extent is a hole, then preallocation is essentially disabled. +* Otherwise we take the size of the preceeding data extent as the basis for the +* preallocation size. If the size of the extent is greater than half the +* maximum extent length, then use the current offset as the basis. This ensures +* that for large files the preallocation size always extends to MAXEXTLEN +* rather than falling short due to things like stripe unit/width alignment of +* real extents. +*/ +STATIC int +xfs_iomap_eof_prealloc_initial_size ( +struct xfs_mount *mp, +struct xfs_inode *ip, +xfs_off_t offset, +xfs_bmbt_irec_t *imap, +int nimaps) +{ +xfs_fileoff_t start_fsb; +int imaps =1 ; +int error;
fs/xfs/xfs_iomap.c xfs_iomap_eof_want_preallocate( · line 348
Quoted 10 lines
fs/xfs/xfs_iomap.c +10
-0+ +ASSERT (nimaps >= imaps); + +/* if we are using a specific prealloc size, return now */ +if (mp->m_flags &XFS_MOUNT_DFLT_IOSIZE ) +return 0 ; + +/* +* As we write multiple pages, the offset will always align to the +* start of a page and hence point to a hole at EOF. i.e. if the size if
Minor typo: "... if the size is"
... otherwise this looks good and works as expected for me:
Brian
Quoted 63 lines
fs/xfs/xfs_iomap.c +28
-9+* 4096 bytes, we only have one block at FSB 0, but XFS_B_TO_FSB(4096) +* will return FSB 1. Hence if there are blocks in the file, we want to +* point to the block prior to the EOF block and not the hole that maps +* directly at @offset. +*/ + start_fsb =XFS_B_TO_FSB (mp, offset); +if (start_fsb) + start_fsb--; + error =xfs_bmapi_read (ip, start_fsb,1 , imap, &imaps,XFS_BMAPI_ENTIRE ); +if (error) +return 0 ; + +ASSERT (imaps ==1 ); +if (imap[0 ].br_startblock ==HOLESTARTBLOCK ) +return 0 ; +if (imap[0 ].br_blockcount <= (MAXEXTLEN >>1 )) +return imap[0 ].br_blockcount; +return XFS_B_TO_FSB (mp, offset); +} + +/* * If we don't have a user specified preallocation size, dynamically increase * the preallocation size as the size of the file grows. Cap the maximum size * at a single extent or less if the filesystem is near full. The closer the @@ -319,20 +375,19 @@ xfs_iomap_eof_want_preallocate( STATIC xfs_fsblock_txfs_iomap_prealloc_size (struct xfs_mount *mp, -struct xfs_inode *ip) +struct xfs_inode *ip, +xfs_off_t offset, +struct xfs_bmbt_irec *imap, +int nimaps) {xfs_fsblock_t alloc_blocks =0 ; -if (!(mp->m_flags &XFS_MOUNT_DFLT_IOSIZE )) { + alloc_blocks =xfs_iomap_eof_prealloc_initial_size (mp, ip, offset, + imap, nimaps); +if (alloc_blocks >0 ) {int shift =0 ;int64_t freesp; -/* -* rounddown_pow_of_two() returns an undefined result -* if we pass in alloc_blocks = 0. Hence the "+ 1" to -* ensure we always pass in a non-zero value. -*/ - alloc_blocks =XFS_B_TO_FSB (mp,XFS_ISIZE (ip)) +1 ; alloc_blocks =XFS_FILEOFF_MIN (MAXEXTLEN ,rounddown_pow_of_two (alloc_blocks));@@ -399,7 +454,6 @@ xfs_iomap_write_delay( extsz =xfs_get_extsz_hint (ip); offset_fsb =XFS_B_TO_FSBT (mp, offset); - error =xfs_iomap_eof_want_preallocate (mp, ip, offset, count, imap,XFS_WRITE_IMAPS , &prealloc);if (error)@@ -407,7 +461,10 @@ xfs_iomap_write_delay(
fs/xfs/xfs_iomap.c xfs_iomap_write_delay( · line 470
Quoted 10 lines
fs/xfs/xfs_iomap.c +4
-1retry:if (prealloc) { -xfs_fsblock_t alloc_blocks =xfs_iomap_prealloc_size (mp, ip); +xfs_fsblock_t alloc_blocks; + + alloc_blocks =xfs_iomap_prealloc_size (mp, ip, offset, imap, +XFS_WRITE_IMAPS ); aligned_offset =XFS_WRITEIO_ALIGN (mp, (offset + count -1 )); ioalign =XFS_B_TO_FSBT (mp, aligned_offset);
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Ben Myers
AppliedRe: [PATCH 1/2] xfs: limit speculative prealloc size on sparse files
In reply to Dave ChinnerQuoted 41 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Speculative preallocation based on the current file size works well for contiguous files, but is sub-optimal for sparse files where the EOF preallocation can fill holes and result in large amounts of zeros being written when it is not necessary.
The algorithm is modified to prevent EOF speculative preallocation from triggering larger allocations on IO patterns of truncate--to-zero-seek-write-seek-write-.... which results in non-sparse files for large files. This, unfortunately, is the way cp now behaves when copying sparse files and so needs to be fixed.
What this code does is that it looks at the existing extent adjacent to the current EOF and if it determines that it is a hole we disable speculative preallocation altogether. To avoid the next write from doing a large prealloc, it takes the size of subsequent preallocations from the current size of the existing EOF extent. IOWs, if you leave a hole in the file, it resets preallocation behaviour to the same as if it was a zero size file.
Example new behaviour:
$ xfs_io -f -c "pwrite 0 31m" \ -c "pwrite 33m 1m" \ -c "pwrite 128m 1m" \ -c "fiemap -v" /mnt/scratch/blah wrote 32505856/32505856 bytes at offset 0 31 MiB, 7936 ops; 0.0000 sec (1.608 GiB/sec and 421432.7439 ops/sec) wrote 1048576/1048576 bytes at offset 34603008 1 MiB, 256 ops; 0.0000 sec (1.462 GiB/sec and 383233.5329 ops/sec) wrote 1048576/1048576 bytes at offset 134217728 1 MiB, 256 ops; 0.0000 sec (1.719 GiB/sec and 450704.2254 ops/sec) /mnt/scratch/blah: EXT: FILE-OFFSET BLOCK-RANGE TOTAL FLAGS 0: [0..65535]: 96..65631 65536 0x0 1: [65536..67583]: hole 2048 2: [67584..69631]: 67680..69727 2048 0x0 3: [69632..262143]: hole 192512 4: [262144..264191]: 262240..264287 2048 0x1
Quoted 1 line
Signed-off-by Dave Chinner <[email protected]>
Applied.
Regards,
Ben
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 2/2 xfs: rearrange some code in xfs_bmap for better locality
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
xfs_bmap.c is a big file, and some of the related code is spread all throughout the file requiring function prototypes for static function and jumping all through the file to follow a single call path. Rearrange the code so that:
a) related functionality is grouped together; and
b) functions are grouped in call dependency order
While the diffstat is large, there are no code changes in the patch; it is just moving the functionality around and removing the function prototypes at the top of the file. The resulting layout of the code is as follows (top of file to bottom):
- miscellaneous helper functions
- extent tree block counting routines
- debug/sanity checking code
- bmap free list manipulation functions
- inode fork format manipulation functions
- internal/external extent tree seach functions
- extent tree manipulation functions used during allocation
- functions used during extent read/allocate/removal operations (i.e. xfs_bmapi_write, xfs_bmapi_read, xfs_bunmapi and xfs_getbmap)
This means that following logic paths through the bmapi code is much simpler - most of the code relevant to a specific operation is now clustered together rather than spread all over the file....
--- fs/xfs/xfs_bmap.c |10659 ++++++++++++++++++++++++++--------------------------- 1 file changed, 5261 insertions(+), 5398 deletions(-)
fs/xfs/xfs_bmap.c +5261 -5398
@@ -52,175 +52,72 @@kmem_zone_t *xfs_bmap_free_item_zone;/* -* Prototypes for internal bmap routines. +* Miscellaneous helper functions */ -#ifdef DEBUG -STATIC void -xfs_bmap_check_leaf_extents ( -struct xfs_btree_cur *cur, -struct xfs_inode *ip, -int whichfork); -#else -#define xfs_bmap_check_leaf_extents (cur, ip, whichfork) do { } while (0) -#endif - - -/* -* Called from xfs_bmap_add_attrfork to handle extents format files. -*/ -STATIC int /* error */ -xfs_bmap_add_attrfork_extents ( -xfs_trans_t *tp,/* transaction pointer */ -xfs_inode_t *ip,/* incore inode pointer */ -xfs_fsblock_t *firstblock,/* first block allocated */ -xfs_bmap_free_t *flist,/* blocks to free at commit */ -int *flags);/* inode logging flags */ - -/* -* Called from xfs_bmap_add_attrfork to handle local format files. -*/ -STATIC int /* error */ -xfs_bmap_add_attrfork_local ( -xfs_trans_t *tp,/* transaction pointer */ -xfs_inode_t *ip,/* incore inode pointer */ -xfs_fsblock_t *firstblock,/* first block allocated */ -xfs_bmap_free_t *flist,/* blocks to free at commit */ -int *flags);/* inode logging flags */ - -/* -* xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file. -* It figures out where to ask the underlying allocator to put the new extent. -*/ -STATIC int /* error */ -xfs_bmap_alloc ( -xfs_bmalloca_t *ap);/* bmap alloc argument struct */ - -/* -* Transform a btree format file with only one leaf node, where the -* extents list will fit in the inode, into an extents format file. -* Since the file extents are already in-core, all we have to do is -* give up the space for the btree root and pitch the leaf block. -*/ -STATIC int /* error */ -xfs_bmap_btree_to_extents ( -xfs_trans_t *tp,/* transaction pointer */ -xfs_inode_t *ip,/* incore inode pointer */ -xfs_btree_cur_t *cur,/* btree cursor */ -int *logflagsp,/* inode logging flags */ -int whichfork);/* data or attr fork */ - -/* -* Remove the entry "free" from the free item list. Prev points to the -* previous entry, unless "free" is the head of the list. -*/ -STATIC void -xfs_bmap_del_free ( -xfs_bmap_free_t *flist,/* free item list header */ -xfs_bmap_free_item_t *prev,/* previous item on list, if any */ -xfs_bmap_free_item_t *free);/* list item to be freed */ - -/* -* Convert an extents-format file into a btree-format file. -* The new file will have a root block (in the inode) and a single child block. -*/ -STATIC int /* error */ -xfs_bmap_extents_to_btree ( -xfs_trans_t *tp,/* transaction pointer */ -xfs_inode_t *ip,/* incore inode pointer */ -xfs_fsblock_t *firstblock,/* first-block-allocated */ -xfs_bmap_free_t *flist,/* blocks freed in xaction */ -xfs_btree_cur_t **curp,/* cursor returned to caller */ -int wasdel,/* converting a delayed alloc */ -int *logflagsp,/* inode logging flags */ -int whichfork);/* data or attr fork */ - -/* -* Convert a local file to an extents file. -* This code is sort of bogus, since the file data needs to get -* logged so it won't be lost. The bmap-level manipulations are ok, though. -*/ -STATIC int /* error */ -xfs_bmap_local_to_extents ( -xfs_trans_t *tp,/* transaction pointer */ -xfs_inode_t *ip,/* incore inode pointer */ -xfs_fsblock_t *firstblock,/* first block allocated in xaction */ -xfs_extlen_t total,/* total blocks needed by transaction */ -int *logflagsp,/* inode logging flags */ -int whichfork,/* data or attr fork */ -void (*init_fn)(struct xfs_buf *bp, -struct xfs_inode *ip, -struct xfs_ifork *ifp)); - -/* -* Search the extents list for the inode, for the extent containing bno. -* If bno lies in a hole, point to the next entry. If bno lies past eof, -* *eofp will be set, and *prevp will contain the last entry (null if none). -* Else, *lastxp will be set to the index of the found -* entry; *gotp will contain the entry. -*/ -STATIC xfs_bmbt_rec_host_t * /* pointer to found extent entry */ -xfs_bmap_search_extents ( -xfs_inode_t *ip,/* incore inode pointer */ -xfs_fileoff_t bno,/* block number searched for */ -int whichfork,/* data or attr fork */ -int *eofp,/* out: end of file found */ -xfs_extnum_t *lastxp,/* out: last extent index */ -xfs_bmbt_irec_t *gotp,/* out: extent entry found */ -xfs_bmbt_irec_t *prevp);/* out: previous extent entry found */ - -/* -* Compute the worst-case number of indirect blocks that will be used -* for ip's delayed extent of length "len". -*/ -STATIC xfs_filblks_t -xfs_bmap_worst_indlen ( -xfs_inode_t *ip,/* incore inode pointer */ -xfs_filblks_t len);/* delayed extent length */ - -#ifdef DEBUG /* -* Perform various validation checks on the values being returned -* from xfs_bmapi(). +* Compute and fill in the value of the maximum depth of a bmap btree +* in this filesystem. Done once, during mount. */ -STATIC void -xfs_bmap_validate_ret ( -xfs_fileoff_t bno, -xfs_filblks_t len, -int flags, -xfs_bmbt_irec_t *mval, -int nmap, -int ret_nmap); -#else -#define xfs_bmap_validate_ret (bno,len,flags,mval,onmap,nmap) -#endif /* DEBUG */ - -STATIC int -xfs_bmap_count_tree ( -xfs_mount_t *mp, -xfs_trans_t *tp, -xfs_ifork_t *ifp, -xfs_fsblock_t blockno, -int levelin, -int *count); - -STATIC void -xfs_bmap_count_leaves ( -xfs_ifork_t *ifp, -xfs_extnum_t idx, -int numrecs, -int *count); +void +xfs_bmap_compute_maxlevels ( +xfs_mount_t *mp,/* file system mount structure */ +int whichfork)/* data or attr fork */ +{ +int level;/* btree level */ +uint maxblocks;/* max blocks at this level */ +uint maxleafents;/* max leaf entries possible */ +int maxrootrecs;/* max records in root block */ +int minleafrecs;/* min records in leaf block */ +int minnoderecs;/* min records in node block */ +int sz;/* root block size */ -STATIC void -xfs_bmap_disk_count_leaves ( -struct xfs_mount *mp, -struct xfs_btree_block *block, -int numrecs, -int *count); +/* +* The maximum number of extents in a file, hence the maximum +* number of leaf entries, is controlled by the type of di_nextents +* (a signed 32-bit number, xfs_extnum_t), or by di_anextents +* (a signed 16-bit number, xfs_aextnum_t). +* +* Note that we can no longer assume that if we are in ATTR1 that +* the fork offset of all the inodes will be +* (xfs_default_attroffset(ip) >> 3) because we could have mounted +* with ATTR2 and then mounted back with ATTR1, keeping the +* di_forkoff's fixed but probably at various positions. Therefore, +* for both ATTR1 and ATTR2 we have to assume the worst case scenario +* of a minimum size available. +*/ +if (whichfork ==XFS_DATA_FORK ) { + maxleafents =MAXEXTNUM ; + sz =XFS_BMDR_SPACE_CALC (MINDBTPTRS ); + }else { + maxleafents =MAXAEXTNUM ; + sz =XFS_BMDR_SPACE_CALC (MINABTPTRS ); + } + maxrootrecs =xfs_bmdr_maxrecs (mp, sz,0 ); + minleafrecs = mp->m_bmap_dmnr[0 ]; + minnoderecs = mp->m_bmap_dmnr[1 ]; + maxblocks = (maxleafents + minleafrecs -1 ) / minleafrecs; +for (level =1 ; maxblocks >1 ; level++) { +if (maxblocks <= maxrootrecs) + maxblocks =1 ; +else + maxblocks = (maxblocks + minnoderecs -1 ) / minnoderecs; + } + mp->m_bm_maxlevels[whichfork] = level; +}/* -* Bmap internal routines. +* Convert the given file system block to a disk block. We have to treat it +* differently based on whether the file is a real time file or not, because the +* bmap code does. */ +xfs_daddr_t +xfs_fsb_to_db (struct xfs_inode *ip,xfs_fsblock_t fsb) +{ +return (XFS_IS_REALTIME_INODE (ip) ? \ + (xfs_daddr_t )XFS_FSB_TO_BB ((ip)->i_mount, (fsb)) : \ +XFS_FSB_TO_DADDR ((ip)->i_mount, (fsb))); +} STATIC int /* error */ xfs_bmbt_lookup_eq(
@@ -290,5935 +187,5914 @@ xfs_bmbt_update( }/* -* Called from xfs_bmap_add_attrfork to handle btree format files. +* Compute the worst-case number of indirect blocks that will be used +* for ip's delayed extent of length "len". */ -STATIC int /* error */ -xfs_bmap_add_attrfork_btree ( -xfs_trans_t *tp,/* transaction pointer */ -xfs_inode_t *ip,/* incore inode pointer */ -xfs_fsblock_t *firstblock,/* first block allocated */ -xfs_bmap_free_t *flist,/* blocks to free at commit */ -int *flags)/* inode logging flags */ +STATIC xfs_filblks_t +xfs_bmap_worst_indlen ( +xfs_inode_t *ip,/* incore inode pointer */ +xfs_filblks_t len)/* delayed extent length */ { -xfs_btree_cur_t *cur;/* btree cursor */ -int error;/* error return value */ -xfs_mount_t *mp;/* file system mount struct */ -int stat;/* newroot status */ +int level;/* btree level number */ +int maxrecs;/* maximum record count at this level */ +xfs_mount_t *mp;/* mount structure */ +xfs_filblks_t rval;/* return value */ mp = ip->i_mount; -if (ip->i_df.if_broot_bytes <=XFS_IFORK_DSIZE (ip)) - *flags |=XFS_ILOG_DBROOT ; -else { - cur =xfs_bmbt_init_cursor (mp, tp, ip,XFS_DATA_FORK ); - cur->bc_private.b.flist = flist; - cur->bc_private.b.firstblock = *firstblock; -if ((error =xfs_bmbt_lookup_ge (cur,0 ,0 ,0 , &stat))) - goto error0; -/* must be at least one entry */ -XFS_WANT_CORRUPTED_GOTO (stat ==1 , error0); -if ((error =xfs_btree_new_iroot (cur, flags, &stat))) - goto error0; -if (stat ==0 ) { -xfs_btree_del_cursor (cur,XFS_BTREE_NOERROR ); -return XFS_ERROR (ENOSPC ); - } - *firstblock = cur->bc_private.b.firstblock; - cur->bc_private.b.allocated =0 ; -xfs_btree_del_cursor (cur,XFS_BTREE_NOERROR ); + maxrecs = mp->m_bmap_dmxr[0 ]; +for (level =0 , rval =0 ; + level <XFS_BM_MAXLEVELS (mp,XFS_DATA_FORK ); + level++) { + len += maxrecs -1 ; +do_div (len, maxrecs); + rval += len; +if (len ==1 ) +return rval +XFS_BM_MAXLEVELS (mp,XFS_DATA_FORK ) - + level -1 ; +if (level ==0 ) + maxrecs = mp->m_bmap_dmxr[1 ]; } -return 0 ; -error0: -xfs_btree_del_cursor (cur,XFS_BTREE_ERROR ); -return error; +return rval; }/* -* Called from xfs_bmap_add_attrfork to handle extents format files. +* Calculate the default attribute fork offset for newly created inodes. */ -STATIC int /* error */ -xfs_bmap_add_attrfork_extents ( -xfs_trans_t *tp,/* transaction pointer */ -xfs_inode_t *ip,/* incore inode pointer */ -xfs_fsblock_t *firstblock,/* first block allocated */ -xfs_bmap_free_t *flist,/* blocks to free at commit */ -int *flags)/* inode logging flags */ +uint +xfs_default_attroffset ( +struct xfs_inode *ip) { -xfs_btree_cur_t *cur;/* bmap btree cursor */ -int error;/* error return value */ +struct xfs_mount *mp = ip->i_mount; +uint offset; -if (ip->i_d.di_nextents *sizeof (xfs_bmbt_rec_t) <=XFS_IFORK_DSIZE (ip)) -return 0 ; - cur =NULL ; - error =xfs_bmap_extents_to_btree (tp, ip, firstblock, flist, &cur,0 , - flags,XFS_DATA_FORK ); -if (cur) { - cur->bc_private.b.allocated =0 ; -xfs_btree_del_cursor (cur, - error ?XFS_BTREE_ERROR :XFS_BTREE_NOERROR ); +if (mp->m_sb.sb_inodesize ==256 ) { + offset =XFS_LITINO (mp) - +XFS_BMDR_SPACE_CALC (MINABTPTRS ); + }else { + offset =XFS_BMDR_SPACE_CALC (6 *MINABTPTRS ); } -return error; + +ASSERT (offset <XFS_LITINO (mp)); +return offset; }/* -* Block initialisation functions for local to extent format conversion. -* As these get more complex, they will be moved to the relevant files, -* but for now they are too simple to worry about. +* Helper routine to reset inode di_forkoff field when switching +* attribute fork from local to extent format - we reset it where +* possible to make space available for inline data fork extents. */ STATIC void -xfs_bmap_local_to_extents_init_fn ( -struct xfs_buf *bp, -struct xfs_inode *ip, -struct xfs_ifork *ifp) +xfs_bmap_forkoff_reset ( +xfs_mount_t *mp, +xfs_inode_t *ip, +int whichfork) { - bp->b_ops = &xfs_bmbt_buf_ops; -memcpy (bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes); +if (whichfork ==XFS_ATTR_FORK && + ip->i_d.di_format !=XFS_DINODE_FMT_DEV && + ip->i_d.di_format !=XFS_DINODE_FMT_UUID && + ip->i_d.di_format !=XFS_DINODE_FMT_BTREE ) { +uint dfl_forkoff =xfs_default_attroffset (ip) >>3 ; + +if (dfl_forkoff > ip->i_d.di_forkoff) + ip->i_d.di_forkoff = dfl_forkoff; + } } +/* +* Extent tree block counting routines. +*/ + +/* +* Count leaf blocks given a range of extent records. +*/ STATIC void -xfs_symlink_local_to_remote ( -struct xfs_buf *bp, -struct xfs_inode *ip, -struct xfs_ifork *ifp) +xfs_bmap_count_leaves ( +xfs_ifork_t *ifp, +xfs_extnum_t idx, +int numrecs, +int *count) { -/* remote symlink blocks are not verifiable until CRCs come along */ - bp->b_ops =NULL ; -memcpy (bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes); +int b; + +for (b =0 ; b < numrecs; b++) { +xfs_bmbt_rec_host_t *frp =xfs_iext_get_ext (ifp, idx + b); + *count +=xfs_bmbt_get_blockcount (frp); + } }/* -* Called from xfs_bmap_add_attrfork to handle local format files. Each -* different data fork content type needs a different callout to do the -* conversion. Some are basic and only require special block initialisation -* callouts for the data formating, others (directories) are so specialised they -* handle everything themselves. -* -* XXX (dgc): investigate whether directory conversion can use the generic -* formatting callout. It should be possible - it's just a very complex -* formatter. it would also require passing the transaction through to the init -* function. +* Count leaf blocks given a range of extent records originally +* in btree format. */ -STATIC int /* error */ -xfs_bmap_add_attrfork_local ( -xfs_trans_t *tp,/* transaction pointer */ -xfs_inode_t *ip,/* incore inode pointer */ -xfs_fsblock_t *firstblock,/* first block allocated */ -xfs_bmap_free_t *flist,/* blocks to free at commit */ -int *flags)/* inode logging flags */ +STATIC void +xfs_bmap_disk_count_leaves ( +struct xfs_mount *mp, +struct xfs_btree_block *block, +int numrecs, +int *count) { -xfs_da_args_t dargs;/* args for dir/attr code */ - -if (ip->i_df.if_bytes <=XFS_IFORK_DSIZE (ip)) -return 0 ; +int b; +xfs_bmbt_rec_t *frp; -if (S_ISDIR (ip->i_d.di_mode)) { -memset (&dargs,0 ,sizeof (dargs)); - dargs.dp = ip; - dargs.firstblock = firstblock; - dargs.flist = flist; - dargs.total = ip->i_mount->m_dirblkfsbs; - dargs.whichfork =XFS_DATA_FORK ; - dargs.trans = tp; -return xfs_dir2_sf_to_block (&dargs); +for (b =1 ; b <= numrecs; b++) { + frp =XFS_BMBT_REC_ADDR (mp, block, b); + *count +=xfs_bmbt_disk_get_blockcount (frp); } - -if (S_ISLNK (ip->i_d.di_mode)) -return xfs_bmap_local_to_extents (tp, ip, firstblock,1 , - flags,XFS_DATA_FORK , - xfs_symlink_local_to_remote); - -return xfs_bmap_local_to_extents (tp, ip, firstblock,1 , flags, -XFS_DATA_FORK , - xfs_bmap_local_to_extents_init_fn); }/* -* Convert a delayed allocation to a real allocation. +* Recursively walks each level of a btree +* to count total fsblocks is use. */ -STATIC int /* error */ -xfs_bmap_add_extent_delay_real ( -struct xfs_bmalloca *bma) +STATIC int /* error */ +xfs_bmap_count_tree ( +xfs_mount_t *mp,/* file system mount point */ +xfs_trans_t *tp,/* transaction pointer */ +xfs_ifork_t *ifp,/* inode fork pointer */ +xfs_fsblock_t blockno,/* file system block number */ +int levelin,/* level in btree */ +int *count)/* Count of blocks */ { -struct xfs_bmbt_irec *new = &bma->got; -int diff;/* temp value */ -xfs_bmbt_rec_host_t *ep;/* extent entry for idx */ -int error;/* error return value */ -int i;/* temp state */ -xfs_ifork_t *ifp;/* inode fork pointer */ -xfs_fileoff_t new_endoff;/* end offset of new entry */ -xfs_bmbt_irec_t r[3 ];/* neighbor extent entries */ -/* left is 0, right is 1, prev is 2 */ -int rval=0 ;/* return value (logging flags) */ -int state =0 ;/* state bits, accessed thru macros */ -xfs_filblks_t da_new;/* new count del alloc blocks used */ -xfs_filblks_t da_old;/* old count del alloc blocks used */ -xfs_filblks_t temp=0 ;/* value for da_new calculations */ -xfs_filblks_t temp2=0 ;/* value for da_new calculations */ -int tmp_rval;/* partial logging flags */ +int error; +xfs_buf_t *bp, *nbp; +int level = levelin; +__be64 *pp; +xfs_fsblock_t bno = blockno; +xfs_fsblock_t nextbno; +struct xfs_btree_block *block, *nextblock; +int numrecs; - ifp =XFS_IFORK_PTR (bma->ip,XFS_DATA_FORK ); + error =xfs_btree_read_bufl (mp, tp, bno,0 , &bp,XFS_BMAP_BTREE_REF , + &xfs_bmbt_buf_ops); +if (error) +return error; + *count +=1 ; + block =XFS_BUF_TO_BLOCK (bp); -ASSERT (bma->idx >=0 ); -ASSERT (bma->idx <= ifp->if_bytes /sizeof (struct xfs_bmbt_rec )); -ASSERT (!isnullstartblock (new->br_startblock)); -ASSERT (!bma->cur || - (bma->cur->bc_private.b.flags &XFS_BTCUR_BPRV_WASDEL )); +if (--level) { +/* Not at node above leaves, count this level of nodes */ + nextbno =be64_to_cpu (block->bb_u.l.bb_rightsib); +while (nextbno !=NULLFSBLOCK ) { + error =xfs_btree_read_bufl (mp, tp, nextbno,0 , &nbp, +XFS_BMAP_BTREE_REF , + &xfs_bmbt_buf_ops); +if (error) +return error; + *count +=1 ; + nextblock =XFS_BUF_TO_BLOCK (nbp); + nextbno =be64_to_cpu (nextblock->bb_u.l.bb_rightsib); +xfs_trans_brelse (tp, nbp); + } -XFS_STATS_INC (xs_add_exlist); +/* Dive to the next level */ + pp =XFS_BMBT_PTR_ADDR (mp, block,1 , mp->m_bmap_dmxr[1 ]); + bno =be64_to_cpu (*pp); +if (unlikely ((error = +xfs_bmap_count_tree (mp, tp, ifp, bno, level, count)) <0 )) { +xfs_trans_brelse (tp, bp); +XFS_ERROR_REPORT ("xfs_bmap_count_tree(1)" , +XFS_ERRLEVEL_LOW , mp); +return XFS_ERROR (EFSCORRUPTED ); + } +xfs_trans_brelse (tp, bp); + }else { +/* count all level 1 nodes and their leaves */ +for (;;) { + nextbno =be64_to_cpu (block->bb_u.l.bb_rightsib); + numrecs =be16_to_cpu (block->bb_numrecs); +xfs_bmap_disk_count_leaves (mp, block, numrecs, count); +xfs_trans_brelse (tp, bp); +if (nextbno ==NULLFSBLOCK ) +break ; + bno = nextbno; + error =xfs_btree_read_bufl (mp, tp, bno,0 , &bp, +XFS_BMAP_BTREE_REF , + &xfs_bmbt_buf_ops); +if (error) +return error; + *count +=1 ; + block =XFS_BUF_TO_BLOCK (bp); + } + } +return 0 ; +} -#define LEFT r[0] -#define RIGHT r[1] -#define PREV r[2] +/* +* Count fsblocks of the given fork. +*/ +int /* error */ +xfs_bmap_count_blocks ( +xfs_trans_t *tp,/* transaction pointer */ +xfs_inode_t *ip,/* incore inode */ +int whichfork,/* data or attr fork */ +int *count)/* out: count of blocks */ +{ +struct xfs_btree_block *block;/* current btree block */ +xfs_fsblock_t bno;/* block # of "block" */ +xfs_ifork_t *ifp;/* fork structure */ +int level;/* btree level, for checking */ +xfs_mount_t *mp;/* file system mount structure */ +__be64 *pp;/* pointer to block address */ + + bno =NULLFSBLOCK ; + mp = ip->i_mount; + ifp =XFS_IFORK_PTR (ip, whichfork); +if (XFS_IFORK_FORMAT (ip, whichfork) ==XFS_DINODE_FMT_EXTENTS ) { +xfs_bmap_count_leaves (ifp,0 , + ifp->if_bytes / (uint )sizeof (xfs_bmbt_rec_t), + count); +return 0 ; + }/* -* Set up a bunch of variables to make the tests simpler. +* Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. */ - ep =xfs_iext_get_ext (ifp, bma->idx); -xfs_bmbt_get_all (ep, &PREV ); - new_endoff = new->br_startoff + new->br_blockcount; -ASSERT (PREV .br_startoff <= new->br_startoff); -ASSERT (PREV .br_startoff +PREV .br_blockcount >= new_endoff); + block = ifp->if_broot; + level =be16_to_cpu (block->bb_level); +ASSERT (level >0 ); + pp =XFS_BMAP_BROOT_PTR_ADDR (mp, block,1 , ifp->if_broot_bytes); + bno =be64_to_cpu (*pp); +ASSERT (bno !=NULLDFSBNO ); +ASSERT (XFS_FSB_TO_AGNO (mp, bno) < mp->m_sb.sb_agcount); +ASSERT (XFS_FSB_TO_AGBNO (mp, bno) < mp->m_sb.sb_agblocks); - da_old =startblockval (PREV .br_startblock); - da_new =0 ; +if (unlikely (xfs_bmap_count_tree (mp, tp, ifp, bno, level, count) <0 )) { +XFS_ERROR_REPORT ("xfs_bmap_count_blocks(2)" ,XFS_ERRLEVEL_LOW , + mp); +return XFS_ERROR (EFSCORRUPTED ); + } -/* -* Set flags determining what part of the previous delayed allocation -* extent is being replaced by a real allocation. -*/ -if (PREV .br_startoff == new->br_startoff) - state |=BMAP_LEFT_FILLING ; -if (PREV .br_startoff +PREV .br_blockcount == new_endoff) - state |=BMAP_RIGHT_FILLING ; +return 0 ; +} -/* -* Check and set flags if this segment has a left neighbor. -* Don't set contiguous if the combined extent would be too large. -*/ -if (bma->idx >0 ) { - state |=BMAP_LEFT_VALID ; -xfs_bmbt_get_all (xfs_iext_get_ext (ifp, bma->idx -1 ), &LEFT ); +/* +* Debug/sanity checking code +*/ -if (isnullstartblock (LEFT .br_startblock)) - state |=BMAP_LEFT_DELAY ; - } +STATIC int +xfs_bmap_sanity_check ( +struct xfs_mount *mp, +struct xfs_buf *bp, +int level) +{ +struct xfs_btree_block *block =XFS_BUF_TO_BLOCK (bp); -if ((state &BMAP_LEFT_VALID ) && !(state &BMAP_LEFT_DELAY ) && -LEFT .br_startoff +LEFT .br_blockcount == new->br_startoff && -LEFT .br_startblock +LEFT .br_blockcount == new->br_startblock && -LEFT .br_state == new->br_state && -LEFT .br_blockcount + new->br_blockcount <=MAXEXTLEN ) - state |=BMAP_LEFT_CONTIG ; +if (block->bb_magic !=cpu_to_be32 (XFS_BMAP_MAGIC ) || +be16_to_cpu (block->bb_level) != level || +be16_to_cpu (block->bb_numrecs) ==0 || +be16_to_cpu (block->bb_numrecs) > mp->m_bmap_dmxr[level !=0 ]) +return 0 ; +return 1 ; +} -/* -* Check and set flags if this segment has a right neighbor. -* Don't set contiguous if the combined extent would be too large. -* Also check for all-three-contiguous being too large. -*/ -if (bma->idx < bma->ip->i_df.if_bytes / (uint )sizeof (xfs_bmbt_rec_t) -1 ) { - state |=BMAP_RIGHT_VALID ; -xfs_bmbt_get_all (xfs_iext_get_ext (ifp, bma->idx +1 ), &RIGHT ); +#ifdef DEBUG +STATIC struct xfs_buf * +xfs_bmap_get_bp ( +struct xfs_btree_cur *cur, +xfs_fsblock_t bno) +{ +struct xfs_log_item_desc *lidp; +int i; -if (isnullstartblock (RIGHT .br_startblock)) - state |=BMAP_RIGHT_DELAY ; +if (!cur) +return NULL ; + +for (i =0 ; i <XFS_BTREE_MAXLEVELS ; i++) { +if (!cur->bc_bufs[i]) +break ; +if (XFS_BUF_ADDR (cur->bc_bufs[i]) == bno) +return cur->bc_bufs[i]; } -if ((state &BMAP_RIGHT_VALID ) && !(state &BMAP_RIGHT_DELAY ) && - new_endoff ==RIGHT .br_startoff && - new->br_startblock + new->br_blockcount ==RIGHT .br_startblock && - new->br_state ==RIGHT .br_state && - new->br_blockcount +RIGHT .br_blockcount <=MAXEXTLEN && - ((state & (BMAP_LEFT_CONTIG |BMAP_LEFT_FILLING | -BMAP_RIGHT_FILLING )) != - (BMAP_LEFT_CONTIG |BMAP_LEFT_FILLING | -BMAP_RIGHT_FILLING ) || -LEFT .br_blockcount + new->br_blockcount +RIGHT .br_blockcount - <=MAXEXTLEN )) - state |=BMAP_RIGHT_CONTIG ; +/* Chase down all the log items to see if the bp is there */ +list_for_each_entry (lidp, &cur->bc_tp->t_items, lid_trans) { +struct xfs_buf_log_item *bip; + bip = (struct xfs_buf_log_item *)lidp->lid_item; +if (bip->bli_item.li_type ==XFS_LI_BUF && +XFS_BUF_ADDR (bip->bli_buf) == bno) +return bip->bli_buf; + } - error =0 ; -/* -* Switch out based on the FILLING and CONTIG state bits. -*/ -switch (state & (BMAP_LEFT_FILLING |BMAP_LEFT_CONTIG | -BMAP_RIGHT_FILLING |BMAP_RIGHT_CONTIG )) { -case BMAP_LEFT_FILLING |BMAP_LEFT_CONTIG | -BMAP_RIGHT_FILLING |BMAP_RIGHT_CONTIG : -/* -* Filling in all of a previously delayed allocation extent. -* The left and right neighbors are both contiguous with new. -*/ - bma->idx--; -trace_xfs_bmap_pre_update (bma->ip, bma->idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (xfs_iext_get_ext (ifp, bma->idx), -LEFT .br_blockcount +PREV .br_blockcount + -RIGHT .br_blockcount); -trace_xfs_bmap_post_update (bma->ip, bma->idx, state, _THIS_IP_); +return NULL ; +} -xfs_iext_remove (bma->ip, bma->idx +1 ,2 , state); - bma->ip->i_d.di_nextents--; -if (bma->cur ==NULL ) - rval =XFS_ILOG_CORE |XFS_ILOG_DEXT ; -else { - rval =XFS_ILOG_CORE ; - error =xfs_bmbt_lookup_eq (bma->cur,RIGHT .br_startoff, -RIGHT .br_startblock, -RIGHT .br_blockcount, &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - error =xfs_btree_delete (bma->cur, &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - error =xfs_btree_decrement (bma->cur,0 , &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - error =xfs_bmbt_update (bma->cur,LEFT .br_startoff, -LEFT .br_startblock, -LEFT .br_blockcount + -PREV .br_blockcount + -RIGHT .br_blockcount,LEFT .br_state); -if (error) - goto done; - } -break ; +STATIC void +xfs_check_block ( +struct xfs_btree_block *block, +xfs_mount_t *mp, +int root, +short sz) +{ +int i, j, dmxr; +__be64 *pp, *thispa;/* pointer to block address */ +xfs_bmbt_key_t *prevp, *keyp; -case BMAP_LEFT_FILLING |BMAP_RIGHT_FILLING |BMAP_LEFT_CONTIG : -/* -* Filling in all of a previously delayed allocation extent. -* The left neighbor is contiguous, the right is not. -*/ - bma->idx--; +ASSERT (be16_to_cpu (block->bb_level) >0 ); -trace_xfs_bmap_pre_update (bma->ip, bma->idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (xfs_iext_get_ext (ifp, bma->idx), -LEFT .br_blockcount +PREV .br_blockcount); -trace_xfs_bmap_post_update (bma->ip, bma->idx, state, _THIS_IP_); + prevp =NULL ; +for ( i =1 ; i <=xfs_btree_get_numrecs (block); i++) { + dmxr = mp->m_bmap_dmxr[0 ]; + keyp =XFS_BMBT_KEY_ADDR (mp, block, i); -xfs_iext_remove (bma->ip, bma->idx +1 ,1 , state); -if (bma->cur ==NULL ) - rval =XFS_ILOG_DEXT ; -else { - rval =0 ; - error =xfs_bmbt_lookup_eq (bma->cur,LEFT .br_startoff, -LEFT .br_startblock,LEFT .br_blockcount, - &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - error =xfs_bmbt_update (bma->cur,LEFT .br_startoff, -LEFT .br_startblock, -LEFT .br_blockcount + -PREV .br_blockcount,LEFT .br_state); -if (error) - goto done; +if (prevp) { +ASSERT (be64_to_cpu (prevp->br_startoff) < +be64_to_cpu (keyp->br_startoff)); } -break ; + prevp = keyp; -case BMAP_LEFT_FILLING |BMAP_RIGHT_FILLING |BMAP_RIGHT_CONTIG :/* -* Filling in all of a previously delayed allocation extent. -* The right neighbor is contiguous, the left is not. +* Compare the block numbers to see if there are dups. */ -trace_xfs_bmap_pre_update (bma->ip, bma->idx, state, _THIS_IP_); -xfs_bmbt_set_startblock (ep, new->br_startblock); -xfs_bmbt_set_blockcount (ep, -PREV .br_blockcount +RIGHT .br_blockcount); -trace_xfs_bmap_post_update (bma->ip, bma->idx, state, _THIS_IP_); +if (root) + pp =XFS_BMAP_BROOT_PTR_ADDR (mp, block, i, sz); +else + pp =XFS_BMBT_PTR_ADDR (mp, block, i, dmxr); -xfs_iext_remove (bma->ip, bma->idx +1 ,1 , state); -if (bma->cur ==NULL ) - rval =XFS_ILOG_DEXT ; -else { - rval =0 ; - error =xfs_bmbt_lookup_eq (bma->cur,RIGHT .br_startoff, -RIGHT .br_startblock, -RIGHT .br_blockcount, &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - error =xfs_bmbt_update (bma->cur,PREV .br_startoff, - new->br_startblock, -PREV .br_blockcount + -RIGHT .br_blockcount,PREV .br_state); -if (error) - goto done; +for (j = i+1 ; j <=be16_to_cpu (block->bb_numrecs); j++) { +if (root) + thispa =XFS_BMAP_BROOT_PTR_ADDR (mp, block, j, sz); +else + thispa =XFS_BMBT_PTR_ADDR (mp, block, j, dmxr); +if (*thispa == *pp) { +xfs_warn (mp,"%s: thispa(%d) == pp(%d) %Ld" , + __func__, j, i, + (unsigned long long )be64_to_cpu (*thispa)); +panic ("%s: ptrs are equal in node\n" , + __func__); + } } -break ; + } +} -case BMAP_LEFT_FILLING |BMAP_RIGHT_FILLING : -/* -* Filling in all of a previously delayed allocation extent. -* Neither the left nor right neighbors are contiguous with -* the new one. -*/ -trace_xfs_bmap_pre_update (bma->ip, bma->idx, state, _THIS_IP_); -xfs_bmbt_set_startblock (ep, new->br_startblock); -trace_xfs_bmap_post_update (bma->ip, bma->idx, state, _THIS_IP_); +/* +* Check that the extents for the inode ip are in the right order in all +* btree leaves. +*/ - bma->ip->i_d.di_nextents++; -if (bma->cur ==NULL ) - rval =XFS_ILOG_CORE |XFS_ILOG_DEXT ; -else { - rval =XFS_ILOG_CORE ; - error =xfs_bmbt_lookup_eq (bma->cur, new->br_startoff, - new->br_startblock, new->br_blockcount, - &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==0 , done); - bma->cur->bc_rec.b.br_state =XFS_EXT_NORM ; - error =xfs_btree_insert (bma->cur, &i); +STATIC void +xfs_bmap_check_leaf_extents ( +xfs_btree_cur_t *cur,/* btree cursor or null */ +xfs_inode_t *ip,/* incore inode pointer */ +int whichfork)/* data or attr fork */ +{ +struct xfs_btree_block *block;/* current btree block */ +xfs_fsblock_t bno;/* block # of "block" */ +xfs_buf_t *bp;/* buffer for "block" */ +int error;/* error return value */ +xfs_extnum_t i=0 , j;/* index into the extents list */ +xfs_ifork_t *ifp;/* fork structure */ +int level;/* btree level, for checking */ +xfs_mount_t *mp;/* file system mount structure */ +__be64 *pp;/* pointer to block address */ +xfs_bmbt_rec_t *ep;/* pointer to current extent */ +xfs_bmbt_rec_t last = {0 ,0 };/* last extent in prev block */ +xfs_bmbt_rec_t *nextp;/* pointer to next extent */ +int bp_release =0 ; + +if (XFS_IFORK_FORMAT (ip, whichfork) !=XFS_DINODE_FMT_BTREE ) { +return ; + } + + bno =NULLFSBLOCK ; + mp = ip->i_mount; + ifp =XFS_IFORK_PTR (ip, whichfork); + block = ifp->if_broot; +/* +* Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. +*/ + level =be16_to_cpu (block->bb_level); +ASSERT (level >0 ); +xfs_check_block (block, mp,1 , ifp->if_broot_bytes); + pp =XFS_BMAP_BROOT_PTR_ADDR (mp, block,1 , ifp->if_broot_bytes); + bno =be64_to_cpu (*pp); + +ASSERT (bno !=NULLDFSBNO ); +ASSERT (XFS_FSB_TO_AGNO (mp, bno) < mp->m_sb.sb_agcount); +ASSERT (XFS_FSB_TO_AGBNO (mp, bno) < mp->m_sb.sb_agblocks); + +/* +* Go down the tree until leaf level is reached, following the first +* pointer (leftmost) at each level. +*/ +while (level-- >0 ) { +/* See if buf is in cur first */ + bp_release =0 ; + bp =xfs_bmap_get_bp (cur,XFS_FSB_TO_DADDR (mp, bno)); +if (!bp) { + bp_release =1 ; + error =xfs_btree_read_bufl (mp,NULL , bno,0 , &bp, +XFS_BMAP_BTREE_REF , + &xfs_bmbt_buf_ops);if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); + goto error_norelse; } -break ; + block =XFS_BUF_TO_BLOCK (bp); +XFS_WANT_CORRUPTED_GOTO ( +xfs_bmap_sanity_check (mp, bp, level), + error0); +if (level ==0 ) +break ; -case BMAP_LEFT_FILLING |BMAP_LEFT_CONTIG :/* -* Filling in the first part of a previous delayed allocation. -* The left neighbor is contiguous. +* Check this block for basic sanity (increasing keys and +* no duplicate blocks). */ -trace_xfs_bmap_pre_update (bma->ip, bma->idx -1 , state, _THIS_IP_); -xfs_bmbt_set_blockcount (xfs_iext_get_ext (ifp, bma->idx -1 ), -LEFT .br_blockcount + new->br_blockcount); -xfs_bmbt_set_startoff (ep, -PREV .br_startoff + new->br_blockcount); -trace_xfs_bmap_post_update (bma->ip, bma->idx -1 , state, _THIS_IP_); - temp =PREV .br_blockcount - new->br_blockcount; -trace_xfs_bmap_pre_update (bma->ip, bma->idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (ep, temp); -if (bma->cur ==NULL ) - rval =XFS_ILOG_DEXT ; -else { - rval =0 ; - error =xfs_bmbt_lookup_eq (bma->cur,LEFT .br_startoff, -LEFT .br_startblock,LEFT .br_blockcount, - &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - error =xfs_bmbt_update (bma->cur,LEFT .br_startoff, -LEFT .br_startblock, -LEFT .br_blockcount + - new->br_blockcount, -LEFT .br_state); -if (error) - goto done; +xfs_check_block (block, mp,0 ,0 ); + pp =XFS_BMBT_PTR_ADDR (mp, block,1 , mp->m_bmap_dmxr[1 ]); + bno =be64_to_cpu (*pp); +XFS_WANT_CORRUPTED_GOTO (XFS_FSB_SANITY_CHECK (mp, bno), error0); +if (bp_release) { + bp_release =0 ; +xfs_trans_brelse (NULL , bp); } - da_new =XFS_FILBLKS_MIN (xfs_bmap_worst_indlen (bma->ip, temp), -startblockval (PREV .br_startblock)); -xfs_bmbt_set_startblock (ep,nullstartblock (da_new)); -trace_xfs_bmap_post_update (bma->ip, bma->idx, state, _THIS_IP_); + } - bma->idx--; -break ; +/* +* Here with bp and block set to the leftmost leaf node in the tree. +*/ + i =0 ; + +/* +* Loop over all leaf nodes checking that all extents are in the right order. +*/ +for (;;) { +xfs_fsblock_t nextbno; +xfs_extnum_t num_recs; + + + num_recs =xfs_btree_get_numrecs (block); -case BMAP_LEFT_FILLING :/* -* Filling in the first part of a previous delayed allocation. -* The left neighbor is not contiguous. +* Read-ahead the next leaf block, if any. */ -trace_xfs_bmap_pre_update (bma->ip, bma->idx, state, _THIS_IP_); -xfs_bmbt_set_startoff (ep, new_endoff); - temp =PREV .br_blockcount - new->br_blockcount; -xfs_bmbt_set_blockcount (ep, temp); -xfs_iext_insert (bma->ip, bma->idx,1 , new, state); - bma->ip->i_d.di_nextents++; -if (bma->cur ==NULL ) - rval =XFS_ILOG_CORE |XFS_ILOG_DEXT ; -else { - rval =XFS_ILOG_CORE ; - error =xfs_bmbt_lookup_eq (bma->cur, new->br_startoff, - new->br_startblock, new->br_blockcount, - &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==0 , done); - bma->cur->bc_rec.b.br_state =XFS_EXT_NORM ; - error =xfs_btree_insert (bma->cur, &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - } -if (xfs_bmap_needs_btree (bma->ip,XFS_DATA_FORK )) { - error =xfs_bmap_extents_to_btree (bma->tp, bma->ip, - bma->firstblock, bma->flist, - &bma->cur,1 , &tmp_rval,XFS_DATA_FORK ); - rval |= tmp_rval; -if (error) - goto done; - } - da_new =XFS_FILBLKS_MIN (xfs_bmap_worst_indlen (bma->ip, temp), -startblockval (PREV .br_startblock) - - (bma->cur ? bma->cur->bc_private.b.allocated :0 )); - ep =xfs_iext_get_ext (ifp, bma->idx +1 ); -xfs_bmbt_set_startblock (ep,nullstartblock (da_new)); -trace_xfs_bmap_post_update (bma->ip, bma->idx +1 , state, _THIS_IP_); -break ; + nextbno =be64_to_cpu (block->bb_u.l.bb_rightsib); -case BMAP_RIGHT_FILLING |BMAP_RIGHT_CONTIG :/* -* Filling in the last part of a previous delayed allocation. -* The right neighbor is contiguous with the new allocation. +* Check all the extents to make sure they are OK. +* If we had a previous block, the last entry should +* conform with the first entry in this one. */ - temp =PREV .br_blockcount - new->br_blockcount; -trace_xfs_bmap_pre_update (bma->ip, bma->idx +1 , state, _THIS_IP_); -xfs_bmbt_set_blockcount (ep, temp); -xfs_bmbt_set_allf (xfs_iext_get_ext (ifp, bma->idx +1 ), - new->br_startoff, new->br_startblock, - new->br_blockcount +RIGHT .br_blockcount, -RIGHT .br_state); -trace_xfs_bmap_post_update (bma->ip, bma->idx +1 , state, _THIS_IP_); -if (bma->cur ==NULL ) - rval =XFS_ILOG_DEXT ; -else { - rval =0 ; - error =xfs_bmbt_lookup_eq (bma->cur,RIGHT .br_startoff, -RIGHT .br_startblock, -RIGHT .br_blockcount, &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - error =xfs_bmbt_update (bma->cur, new->br_startoff, - new->br_startblock, - new->br_blockcount + -RIGHT .br_blockcount, -RIGHT .br_state); -if (error) - goto done; - } - - da_new =XFS_FILBLKS_MIN (xfs_bmap_worst_indlen (bma->ip, temp), -startblockval (PREV .br_startblock)); -trace_xfs_bmap_pre_update (bma->ip, bma->idx, state, _THIS_IP_); -xfs_bmbt_set_startblock (ep,nullstartblock (da_new)); -trace_xfs_bmap_post_update (bma->ip, bma->idx, state, _THIS_IP_); - bma->idx++; -break ; + ep =XFS_BMBT_REC_ADDR (mp, block,1 ); +if (i) { +ASSERT (xfs_bmbt_disk_get_startoff (&last) + +xfs_bmbt_disk_get_blockcount (&last) <= +xfs_bmbt_disk_get_startoff (ep)); + } +for (j =1 ; j < num_recs; j++) { + nextp =XFS_BMBT_REC_ADDR (mp, block, j +1 ); +ASSERT (xfs_bmbt_disk_get_startoff (ep) + +xfs_bmbt_disk_get_blockcount (ep) <= +xfs_bmbt_disk_get_startoff (nextp)); + ep = nextp; + } -case BMAP_RIGHT_FILLING : + last = *ep; + i += num_recs; +if (bp_release) { + bp_release =0 ; +xfs_trans_brelse (NULL , bp); + } + bno = nextbno;/* -* Filling in the last part of a previous delayed allocation. -* The right neighbor is not contiguous. +* If we've reached the end, stop. */ - temp =PREV .br_blockcount - new->br_blockcount; -trace_xfs_bmap_pre_update (bma->ip, bma->idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (ep, temp); -xfs_iext_insert (bma->ip, bma->idx +1 ,1 , new, state); - bma->ip->i_d.di_nextents++; -if (bma->cur ==NULL ) - rval =XFS_ILOG_CORE |XFS_ILOG_DEXT ; -else { - rval =XFS_ILOG_CORE ; - error =xfs_bmbt_lookup_eq (bma->cur, new->br_startoff, - new->br_startblock, new->br_blockcount, - &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==0 , done); - bma->cur->bc_rec.b.br_state =XFS_EXT_NORM ; - error =xfs_btree_insert (bma->cur, &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - } - -if (xfs_bmap_needs_btree (bma->ip,XFS_DATA_FORK )) { - error =xfs_bmap_extents_to_btree (bma->tp, bma->ip, - bma->firstblock, bma->flist, &bma->cur,1 , - &tmp_rval,XFS_DATA_FORK ); - rval |= tmp_rval; -if (error) - goto done; - } - da_new =XFS_FILBLKS_MIN (xfs_bmap_worst_indlen (bma->ip, temp), -startblockval (PREV .br_startblock) - - (bma->cur ? bma->cur->bc_private.b.allocated :0 )); - ep =xfs_iext_get_ext (ifp, bma->idx); -xfs_bmbt_set_startblock (ep,nullstartblock (da_new)); -trace_xfs_bmap_post_update (bma->ip, bma->idx, state, _THIS_IP_); - - bma->idx++; -break ; - -case 0 : -/* -* Filling in the middle part of a previous delayed allocation. -* Contiguity is impossible here. -* This case is avoided almost all the time. -* -* We start with a delayed allocation: -* -* +ddddddddddddddddddddddddddddddddddddddddddddddddddddddd+ -* PREV @ idx -* -* and we are allocating: -* +rrrrrrrrrrrrrrrrr+ -* new -* -* and we set it up for insertion as: -* +ddddddddddddddddddd+rrrrrrrrrrrrrrrrr+ddddddddddddddddd+ -* new -* PREV @ idx LEFT RIGHT -* inserted at idx + 1 -*/ - temp = new->br_startoff -PREV .br_startoff; - temp2 =PREV .br_startoff +PREV .br_blockcount - new_endoff; -trace_xfs_bmap_pre_update (bma->ip, bma->idx,0 , _THIS_IP_); -xfs_bmbt_set_blockcount (ep, temp);/* truncate PREV */ -LEFT = *new; -RIGHT .br_state =PREV .br_state; -RIGHT .br_startblock =nullstartblock ( - (int )xfs_bmap_worst_indlen (bma->ip, temp2)); -RIGHT .br_startoff = new_endoff; -RIGHT .br_blockcount = temp2; -/* insert LEFT (r[0]) and RIGHT (r[1]) at the same time */ -xfs_iext_insert (bma->ip, bma->idx +1 ,2 , &LEFT , state); - bma->ip->i_d.di_nextents++; -if (bma->cur ==NULL ) - rval =XFS_ILOG_CORE |XFS_ILOG_DEXT ; -else { - rval =XFS_ILOG_CORE ; - error =xfs_bmbt_lookup_eq (bma->cur, new->br_startoff, - new->br_startblock, new->br_blockcount, - &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==0 , done); - bma->cur->bc_rec.b.br_state =XFS_EXT_NORM ; - error =xfs_btree_insert (bma->cur, &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - } +if (bno ==NULLFSBLOCK ) +break ; -if (xfs_bmap_needs_btree (bma->ip,XFS_DATA_FORK )) { - error =xfs_bmap_extents_to_btree (bma->tp, bma->ip, - bma->firstblock, bma->flist, &bma->cur, -1 , &tmp_rval,XFS_DATA_FORK ); - rval |= tmp_rval; -if (error) - goto done; - } - temp =xfs_bmap_worst_indlen (bma->ip, temp); - temp2 =xfs_bmap_worst_indlen (bma->ip, temp2); - diff = (int )(temp + temp2 -startblockval (PREV .br_startblock) - - (bma->cur ? bma->cur->bc_private.b.allocated :0 )); -if (diff >0 ) { - error =xfs_icsb_modify_counters (bma->ip->i_mount, -XFS_SBS_FDBLOCKS , - -((int64_t )diff),0 ); -ASSERT (!error); + bp_release =0 ; + bp =xfs_bmap_get_bp (cur,XFS_FSB_TO_DADDR (mp, bno)); +if (!bp) { + bp_release =1 ; + error =xfs_btree_read_bufl (mp,NULL , bno,0 , &bp, +XFS_BMAP_BTREE_REF , + &xfs_bmbt_buf_ops);if (error) - goto done; + goto error_norelse; } - - ep =xfs_iext_get_ext (ifp, bma->idx); -xfs_bmbt_set_startblock (ep,nullstartblock ((int )temp)); -trace_xfs_bmap_post_update (bma->ip, bma->idx, state, _THIS_IP_); -trace_xfs_bmap_pre_update (bma->ip, bma->idx +2 , state, _THIS_IP_); -xfs_bmbt_set_startblock (xfs_iext_get_ext (ifp, bma->idx +2 ), -nullstartblock ((int )temp2)); -trace_xfs_bmap_post_update (bma->ip, bma->idx +2 , state, _THIS_IP_); - - bma->idx++; - da_new = temp + temp2; -break ; - -case BMAP_LEFT_FILLING |BMAP_LEFT_CONTIG |BMAP_RIGHT_CONTIG : -case BMAP_RIGHT_FILLING |BMAP_LEFT_CONTIG |BMAP_RIGHT_CONTIG : -case BMAP_LEFT_FILLING |BMAP_RIGHT_CONTIG : -case BMAP_RIGHT_FILLING |BMAP_LEFT_CONTIG : -case BMAP_LEFT_CONTIG |BMAP_RIGHT_CONTIG : -case BMAP_LEFT_CONTIG : -case BMAP_RIGHT_CONTIG : -/* -* These cases are all impossible. -*/ -ASSERT (0 ); - } - -/* convert to a btree if necessary */ -if (xfs_bmap_needs_btree (bma->ip,XFS_DATA_FORK )) { -int tmp_logflags;/* partial log flag return val */ - -ASSERT (bma->cur ==NULL ); - error =xfs_bmap_extents_to_btree (bma->tp, bma->ip, - bma->firstblock, bma->flist, &bma->cur, - da_old >0 , &tmp_logflags,XFS_DATA_FORK ); - bma->logflags |= tmp_logflags; -if (error) - goto done; + block =XFS_BUF_TO_BLOCK (bp); } - -/* adjust for changes in reserved delayed indirect blocks */ -if (da_old || da_new) { - temp = da_new; -if (bma->cur) - temp += bma->cur->bc_private.b.allocated; -ASSERT (temp <= da_old); -if (temp < da_old) -xfs_icsb_modify_counters (bma->ip->i_mount, -XFS_SBS_FDBLOCKS , - (int64_t )(da_old - temp),0 ); +if (bp_release) { + bp_release =0 ; +xfs_trans_brelse (NULL , bp); } +return ; -/* clear out the allocated field, done with it now in any case. */ -if (bma->cur) - bma->cur->bc_private.b.allocated =0 ; - -xfs_bmap_check_leaf_extents (bma->cur, bma->ip,XFS_DATA_FORK ); -done: - bma->logflags |= rval; -return error; -#undef LEFT -#undef RIGHT -#undef PREV +error0: +xfs_warn (mp,"%s: at error0" , __func__); +if (bp_release) +xfs_trans_brelse (NULL , bp); +error_norelse: +xfs_warn (mp,"%s: BAD after btree leaves for %d extents" , + __func__, i); +panic ("%s: CORRUPTED BTREE OR SOMETHING" , __func__); +return ; }/* -* Convert an unwritten allocation to a real allocation or vice versa. +* Add bmap trace insert entries for all the contents of the extent records. */ -STATIC int /* error */ -xfs_bmap_add_extent_unwritten_real ( -struct xfs_trans *tp, -xfs_inode_t *ip,/* incore inode pointer */ -xfs_extnum_t *idx,/* extent number to update/insert */ -xfs_btree_cur_t **curp,/* if *curp is null, not a btree */ -xfs_bmbt_irec_t *new,/* new data to add to file extents */ -xfs_fsblock_t *first,/* pointer to firstblock variable */ -xfs_bmap_free_t *flist,/* list of extents to be freed */ -int *logflagsp)/* inode logging flags */ +void +xfs_bmap_trace_exlist ( +xfs_inode_t *ip,/* incore inode pointer */ +xfs_extnum_t cnt,/* count of entries in the list */ +int whichfork,/* data or attr fork */ +unsigned long caller_ip) { -xfs_btree_cur_t *cur;/* btree cursor */ -xfs_bmbt_rec_host_t *ep;/* extent entry for idx */ -int error;/* error return value */ -int i;/* temp state */ -xfs_ifork_t *ifp;/* inode fork pointer */ -xfs_fileoff_t new_endoff;/* end offset of new entry */ -xfs_exntst_t newext;/* new extent state */ -xfs_exntst_t oldext;/* old extent state */ -xfs_bmbt_irec_t r[3 ];/* neighbor extent entries */ -/* left is 0, right is 1, prev is 2 */ -int rval=0 ;/* return value (logging flags) */ -int state =0 ;/* state bits, accessed thru macros */ - - *logflagsp =0 ; +xfs_extnum_t idx;/* extent record index */ +xfs_ifork_t *ifp;/* inode fork pointer */ +int state =0 ; - cur = *curp; - ifp =XFS_IFORK_PTR (ip,XFS_DATA_FORK ); +if (whichfork ==XFS_ATTR_FORK ) + state |=BMAP_ATTRFORK ; -ASSERT (*idx >=0 ); -ASSERT (*idx <= ifp->if_bytes /sizeof (struct xfs_bmbt_rec )); -ASSERT (!isnullstartblock (new->br_startblock)); + ifp =XFS_IFORK_PTR (ip, whichfork); +ASSERT (cnt == (ifp->if_bytes / (uint )sizeof (xfs_bmbt_rec_t))); +for (idx =0 ; idx < cnt; idx++) +trace_xfs_extlist (ip, idx, whichfork, caller_ip); +} -XFS_STATS_INC (xs_add_exlist); +/* +* Validate that the bmbt_irecs being returned from bmapi are valid +* given the callers original parameters. Specifically check the +* ranges of the returned irecs to ensure that they only extent beyond +* the given parameters if the XFS_BMAPI_ENTIRE flag was set. +*/ +STATIC void +xfs_bmap_validate_ret ( +xfs_fileoff_t bno, +xfs_filblks_t len, +int flags, +xfs_bmbt_irec_t *mval, +int nmap, +int ret_nmap) +{ +int i;/* index to map values */ -#define LEFT r[0] -#define RIGHT r[1] -#define PREV r[2] +ASSERT (ret_nmap <= nmap); -/* -* Set up a bunch of variables to make the tests simpler. -*/ - error =0 ; - ep =xfs_iext_get_ext (ifp, *idx); -xfs_bmbt_get_all (ep, &PREV ); - newext = new->br_state; - oldext = (newext ==XFS_EXT_UNWRITTEN ) ? -XFS_EXT_NORM :XFS_EXT_UNWRITTEN ; -ASSERT (PREV .br_state == oldext); - new_endoff = new->br_startoff + new->br_blockcount; -ASSERT (PREV .br_startoff <= new->br_startoff); -ASSERT (PREV .br_startoff +PREV .br_blockcount >= new_endoff); +for (i =0 ; i < ret_nmap; i++) { +ASSERT (mval[i].br_blockcount >0 ); +if (!(flags &XFS_BMAPI_ENTIRE )) { +ASSERT (mval[i].br_startoff >= bno); +ASSERT (mval[i].br_blockcount <= len); +ASSERT (mval[i].br_startoff + mval[i].br_blockcount <= + bno + len); + }else { +ASSERT (mval[i].br_startoff < bno + len); +ASSERT (mval[i].br_startoff + mval[i].br_blockcount > + bno); + } +ASSERT (i ==0 || + mval[i -1 ].br_startoff + mval[i -1 ].br_blockcount == + mval[i].br_startoff); +ASSERT (mval[i].br_startblock !=DELAYSTARTBLOCK && + mval[i].br_startblock !=HOLESTARTBLOCK ); +ASSERT (mval[i].br_state ==XFS_EXT_NORM || + mval[i].br_state ==XFS_EXT_UNWRITTEN ); + } +} -/* -* Set flags determining what part of the previous oldext allocation -* extent is being replaced by a newext allocation. -*/ -if (PREV .br_startoff == new->br_startoff) - state |=BMAP_LEFT_FILLING ; -if (PREV .br_startoff +PREV .br_blockcount == new_endoff) - state |=BMAP_RIGHT_FILLING ; +#else +#define xfs_bmap_check_leaf_extents (cur, ip, whichfork) do { } while (0) +#define xfs_bmap_validate_ret (bno,len,flags,mval,onmap,nmap) +#endif /* DEBUG */ -/* -* Check and set flags if this segment has a left neighbor. -* Don't set contiguous if the combined extent would be too large. -*/ -if (*idx >0 ) { - state |=BMAP_LEFT_VALID ; -xfs_bmbt_get_all (xfs_iext_get_ext (ifp, *idx -1 ), &LEFT ); +/* +* bmap free list manipulation functions +*/ -if (isnullstartblock (LEFT .br_startblock)) - state |=BMAP_LEFT_DELAY ; +/* +* Add the extent to the list of extents to be free at transaction end. +* The list is maintained sorted (by block number). +*/ +void +xfs_bmap_add_free ( +xfs_fsblock_t bno,/* fs block number of extent */ +xfs_filblks_t len,/* length of extent */ +xfs_bmap_free_t *flist,/* list of extents */ +xfs_mount_t *mp)/* mount point structure */ +{ +xfs_bmap_free_item_t *cur;/* current (next) element */ +xfs_bmap_free_item_t *new;/* new element */ +xfs_bmap_free_item_t *prev;/* previous element */ +#ifdef DEBUG +xfs_agnumber_t agno; +xfs_agblock_t agbno; + +ASSERT (bno !=NULLFSBLOCK ); +ASSERT (len >0 ); +ASSERT (len <=MAXEXTLEN ); +ASSERT (!isnullstartblock (bno)); + agno =XFS_FSB_TO_AGNO (mp, bno); + agbno =XFS_FSB_TO_AGBNO (mp, bno); +ASSERT (agno < mp->m_sb.sb_agcount); +ASSERT (agbno < mp->m_sb.sb_agblocks); +ASSERT (len < mp->m_sb.sb_agblocks); +ASSERT (agbno + len <= mp->m_sb.sb_agblocks); +#endif +ASSERT (xfs_bmap_free_item_zone !=NULL ); + new =kmem_zone_alloc (xfs_bmap_free_item_zone,KM_SLEEP ); + new->xbfi_startblock = bno; + new->xbfi_blockcount = (xfs_extlen_t )len; +for (prev =NULL , cur = flist->xbf_first; + cur !=NULL ; + prev = cur, cur = cur->xbfi_next) { +if (cur->xbfi_startblock >= bno) +break ; } +if (prev) + prev->xbfi_next = new; +else + flist->xbf_first = new; + new->xbfi_next = cur; + flist->xbf_count++; +} -if ((state &BMAP_LEFT_VALID ) && !(state &BMAP_LEFT_DELAY ) && -LEFT .br_startoff +LEFT .br_blockcount == new->br_startoff && -LEFT .br_startblock +LEFT .br_blockcount == new->br_startblock && -LEFT .br_state == newext && -LEFT .br_blockcount + new->br_blockcount <=MAXEXTLEN ) - state |=BMAP_LEFT_CONTIG ; +/* +* Remove the entry "free" from the free item list. Prev points to the +* previous entry, unless "free" is the head of the list. +*/ +STATIC void +xfs_bmap_del_free ( +xfs_bmap_free_t *flist,/* free item list header */ +xfs_bmap_free_item_t *prev,/* previous item on list, if any */ +xfs_bmap_free_item_t *free)/* list item to be freed */ +{ +if (prev) + prev->xbfi_next = free->xbfi_next; +else + flist->xbf_first = free->xbfi_next; + flist->xbf_count--; +kmem_zone_free (xfs_bmap_free_item_zone, free); +} + + +/* +* Routine to be called at transaction's end by xfs_bmapi, xfs_bunmapi +* caller. Frees all the extents that need freeing, which must be done +* last due to locking considerations. We never free any extents in +* the first transaction. +* +* Return 1 if the given transaction was committed and a new one +* started, and 0 otherwise in the committed parameter. +*/ +int /* error */ +xfs_bmap_finish ( +xfs_trans_t **tp,/* transaction pointer addr */ +xfs_bmap_free_t *flist,/* i/o: list extents to free */ +int *committed)/* xact committed or not */ +{ +xfs_efd_log_item_t *efd;/* extent free data */ +xfs_efi_log_item_t *efi;/* extent free intention */ +int error;/* error return value */ +xfs_bmap_free_item_t *free;/* free extent item */ +unsigned int logres;/* new log reservation */ +unsigned int logcount;/* new log count */ +xfs_mount_t *mp;/* filesystem mount structure */ +xfs_bmap_free_item_t *next;/* next item on free list */ +xfs_trans_t *ntp;/* new transaction pointer */ +ASSERT ((*tp)->t_flags &XFS_TRANS_PERM_LOG_RES ); +if (flist->xbf_count ==0 ) { + *committed =0 ; +return 0 ; + } + ntp = *tp; + efi =xfs_trans_get_efi (ntp, flist->xbf_count); +for (free = flist->xbf_first; free; free = free->xbfi_next) +xfs_trans_log_efi_extent (ntp, efi, free->xbfi_startblock, + free->xbfi_blockcount); + logres = ntp->t_log_res; + logcount = ntp->t_log_count; + ntp =xfs_trans_dup (*tp); + error =xfs_trans_commit (*tp,0 ); + *tp = ntp; + *committed =1 ;/* -* Check and set flags if this segment has a right neighbor. -* Don't set contiguous if the combined extent would be too large. -* Also check for all-three-contiguous being too large. +* We have a new transaction, so we should return committed=1, +* even though we're returning an error. */ -if (*idx < ip->i_df.if_bytes / (uint )sizeof (xfs_bmbt_rec_t) -1 ) { - state |=BMAP_RIGHT_VALID ; -xfs_bmbt_get_all (xfs_iext_get_ext (ifp, *idx +1 ), &RIGHT ); -if (isnullstartblock (RIGHT .br_startblock)) - state |=BMAP_RIGHT_DELAY ; - } - -if ((state &BMAP_RIGHT_VALID ) && !(state &BMAP_RIGHT_DELAY ) && - new_endoff ==RIGHT .br_startoff && - new->br_startblock + new->br_blockcount ==RIGHT .br_startblock && - newext ==RIGHT .br_state && - new->br_blockcount +RIGHT .br_blockcount <=MAXEXTLEN && - ((state & (BMAP_LEFT_CONTIG |BMAP_LEFT_FILLING | -BMAP_RIGHT_FILLING )) != - (BMAP_LEFT_CONTIG |BMAP_LEFT_FILLING | -BMAP_RIGHT_FILLING ) || -LEFT .br_blockcount + new->br_blockcount +RIGHT .br_blockcount - <=MAXEXTLEN )) - state |=BMAP_RIGHT_CONTIG ; +if (error) +return error;/* -* Switch out based on the FILLING and CONTIG state bits. +* transaction commit worked ok so we can drop the extra ticket +* reference that we gained in xfs_trans_dup() */ -switch (state & (BMAP_LEFT_FILLING |BMAP_LEFT_CONTIG | -BMAP_RIGHT_FILLING |BMAP_RIGHT_CONTIG )) { -case BMAP_LEFT_FILLING |BMAP_LEFT_CONTIG | -BMAP_RIGHT_FILLING |BMAP_RIGHT_CONTIG : -/* -* Setting all of a previous oldext extent to newext. -* The left and right neighbors are both contiguous with new. -*/ - --*idx; +xfs_log_ticket_put (ntp->t_ticket); -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (xfs_iext_get_ext (ifp, *idx), -LEFT .br_blockcount +PREV .br_blockcount + -RIGHT .br_blockcount); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); +if ((error =xfs_trans_reserve (ntp,0 , logres,0 ,XFS_TRANS_PERM_LOG_RES , + logcount))) +return error; + efd =xfs_trans_get_efd (ntp, efi, flist->xbf_count); +for (free = flist->xbf_first; free !=NULL ; free = next) { + next = free->xbfi_next; +if ((error =xfs_free_extent (ntp, free->xbfi_startblock, + free->xbfi_blockcount))) { +/* +* The bmap free list will be cleaned up at a +* higher level. The EFI will be canceled when +* this transaction is aborted. +* Need to force shutdown here to make sure it +* happens, since this transaction may not be +* dirty yet. +*/ + mp = ntp->t_mountp; +if (!XFS_FORCED_SHUTDOWN (mp)) +xfs_force_shutdown (mp, + (error ==EFSCORRUPTED ) ? +SHUTDOWN_CORRUPT_INCORE : +SHUTDOWN_META_IO_ERROR ); +return error; + } +xfs_trans_log_efd_extent (ntp, efd, free->xbfi_startblock, + free->xbfi_blockcount); +xfs_bmap_del_free (flist,NULL , free); + } +return 0 ; +} -xfs_iext_remove (ip, *idx +1 ,2 , state); - ip->i_d.di_nextents -=2 ; -if (cur ==NULL ) - rval =XFS_ILOG_CORE |XFS_ILOG_DEXT ; -else { - rval =XFS_ILOG_CORE ; -if ((error =xfs_bmbt_lookup_eq (cur,RIGHT .br_startoff, -RIGHT .br_startblock, -RIGHT .br_blockcount, &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_btree_delete (cur, &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_btree_decrement (cur,0 , &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_btree_delete (cur, &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_btree_decrement (cur,0 , &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_bmbt_update (cur,LEFT .br_startoff, -LEFT .br_startblock, -LEFT .br_blockcount +PREV .br_blockcount + -RIGHT .br_blockcount,LEFT .br_state))) - goto done; - } -break ; - -case BMAP_LEFT_FILLING |BMAP_RIGHT_FILLING |BMAP_LEFT_CONTIG : -/* -* Setting all of a previous oldext extent to newext. -* The left neighbor is contiguous, the right is not. -*/ - --*idx; +/* +* Free up any items left in the list. +*/ +void +xfs_bmap_cancel ( +xfs_bmap_free_t *flist)/* list of bmap_free_items */ +{ +xfs_bmap_free_item_t *free;/* free list item */ +xfs_bmap_free_item_t *next; -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (xfs_iext_get_ext (ifp, *idx), -LEFT .br_blockcount +PREV .br_blockcount); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); +if (flist->xbf_count ==0 ) +return ; +ASSERT (flist->xbf_first !=NULL ); +for (free = flist->xbf_first; free; free = next) { + next = free->xbfi_next; +xfs_bmap_del_free (flist,NULL , free); + } +ASSERT (flist->xbf_count ==0 ); +} -xfs_iext_remove (ip, *idx +1 ,1 , state); - ip->i_d.di_nextents--; -if (cur ==NULL ) - rval =XFS_ILOG_CORE |XFS_ILOG_DEXT ; -else { - rval =XFS_ILOG_CORE ; -if ((error =xfs_bmbt_lookup_eq (cur,PREV .br_startoff, -PREV .br_startblock,PREV .br_blockcount, - &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_btree_delete (cur, &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_btree_decrement (cur,0 , &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_bmbt_update (cur,LEFT .br_startoff, -LEFT .br_startblock, -LEFT .br_blockcount +PREV .br_blockcount, -LEFT .br_state))) - goto done; - } -break ; +/* +* Inode fork format manipulation functions +*/ -case BMAP_LEFT_FILLING |BMAP_RIGHT_FILLING |BMAP_RIGHT_CONTIG : -/* -* Setting all of a previous oldext extent to newext. -* The right neighbor is contiguous, the left is not. -*/ -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (ep, -PREV .br_blockcount +RIGHT .br_blockcount); -xfs_bmbt_set_state (ep, newext); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); -xfs_iext_remove (ip, *idx +1 ,1 , state); - ip->i_d.di_nextents--; -if (cur ==NULL ) - rval =XFS_ILOG_CORE |XFS_ILOG_DEXT ; -else { - rval =XFS_ILOG_CORE ; -if ((error =xfs_bmbt_lookup_eq (cur,RIGHT .br_startoff, -RIGHT .br_startblock, -RIGHT .br_blockcount, &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_btree_delete (cur, &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_btree_decrement (cur,0 , &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_bmbt_update (cur, new->br_startoff, - new->br_startblock, - new->br_blockcount +RIGHT .br_blockcount, - newext))) - goto done; - } -break ; +/* +* Transform a btree format file with only one leaf node, where the +* extents list will fit in the inode, into an extents format file. +* Since the file extents are already in-core, all we have to do is +* give up the space for the btree root and pitch the leaf block. +*/ +STATIC int /* error */ +xfs_bmap_btree_to_extents ( +xfs_trans_t *tp,/* transaction pointer */ +xfs_inode_t *ip,/* incore inode pointer */ +xfs_btree_cur_t *cur,/* btree cursor */ +int *logflagsp,/* inode logging flags */ +int whichfork)/* data or attr fork */ +{ +/* REFERENCED */ +struct xfs_btree_block *cblock;/* child btree block */ +xfs_fsblock_t cbno;/* child block number */ +xfs_buf_t *cbp;/* child block's buffer */ +int error;/* error return value */ +xfs_ifork_t *ifp;/* inode fork data */ +xfs_mount_t *mp;/* mount point structure */ +__be64 *pp;/* ptr to block address */ +struct xfs_btree_block *rblock;/* root btree block */ -case BMAP_LEFT_FILLING |BMAP_RIGHT_FILLING : -/* -* Setting all of a previous oldext extent to newext. -* Neither the left nor right neighbors are contiguous with -* the new one. -*/ -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -xfs_bmbt_set_state (ep, newext); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); + mp = ip->i_mount; + ifp =XFS_IFORK_PTR (ip, whichfork); +ASSERT (ifp->if_flags &XFS_IFEXTENTS ); +ASSERT (XFS_IFORK_FORMAT (ip, whichfork) ==XFS_DINODE_FMT_BTREE ); + rblock = ifp->if_broot; +ASSERT (be16_to_cpu (rblock->bb_level) ==1 ); +ASSERT (be16_to_cpu (rblock->bb_numrecs) ==1 ); +ASSERT (xfs_bmbt_maxrecs (mp, ifp->if_broot_bytes,0 ) ==1 ); + pp =XFS_BMAP_BROOT_PTR_ADDR (mp, rblock,1 , ifp->if_broot_bytes); + cbno =be64_to_cpu (*pp); + *logflagsp =0 ; +#ifdef DEBUG +if ((error =xfs_btree_check_lptr (cur, cbno,1 ))) +return error; +#endif + error =xfs_btree_read_bufl (mp, tp, cbno,0 , &cbp,XFS_BMAP_BTREE_REF , + &xfs_bmbt_buf_ops); +if (error) +return error; + cblock =XFS_BUF_TO_BLOCK (cbp); +if ((error =xfs_btree_check_block (cur, cblock,0 , cbp))) +return error; +xfs_bmap_add_free (cbno,1 , cur->bc_private.b.flist, mp); + ip->i_d.di_nblocks--; +xfs_trans_mod_dquot_byino (tp, ip,XFS_TRANS_DQ_BCOUNT ,-1L ); +xfs_trans_binval (tp, cbp); +if (cur->bc_bufs[0 ] == cbp) + cur->bc_bufs[0 ] =NULL ; +xfs_iroot_realloc (ip,-1 , whichfork); +ASSERT (ifp->if_broot ==NULL ); +ASSERT ((ifp->if_flags &XFS_IFBROOT ) ==0 ); +XFS_IFORK_FMT_SET (ip, whichfork,XFS_DINODE_FMT_EXTENTS ); + *logflagsp =XFS_ILOG_CORE |xfs_ilog_fext (whichfork); +return 0 ; +} -if (cur ==NULL ) - rval =XFS_ILOG_DEXT ; -else { - rval =0 ; -if ((error =xfs_bmbt_lookup_eq (cur, new->br_startoff, - new->br_startblock, new->br_blockcount, - &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_bmbt_update (cur, new->br_startoff, - new->br_startblock, new->br_blockcount, - newext))) - goto done; - } -break ; +/* +* Convert an extents-format file into a btree-format file. +* The new file will have a root block (in the inode) and a single child block. +*/ +STATIC int /* error */ +xfs_bmap_extents_to_btree ( +xfs_trans_t *tp,/* transaction pointer */ +xfs_inode_t *ip,/* incore inode pointer */ +xfs_fsblock_t *firstblock,/* first-block-allocated */ +xfs_bmap_free_t *flist,/* blocks freed in xaction */ +xfs_btree_cur_t **curp,/* cursor returned to caller */ +int wasdel,/* converting a delayed alloc */ +int *logflagsp,/* inode logging flags */ +int whichfork)/* data or attr fork */ +{ +struct xfs_btree_block *ablock;/* allocated (child) bt block */ +xfs_buf_t *abp;/* buffer for ablock */ +xfs_alloc_arg_t args;/* allocation arguments */ +xfs_bmbt_rec_t *arp;/* child record pointer */ +struct xfs_btree_block *block;/* btree root block */ +xfs_btree_cur_t *cur;/* bmap btree cursor */ +xfs_bmbt_rec_host_t *ep;/* extent record pointer */ +int error;/* error return value */ +xfs_extnum_t i, cnt;/* extent record index */ +xfs_ifork_t *ifp;/* inode fork pointer */ +xfs_bmbt_key_t *kp;/* root block key pointer */ +xfs_mount_t *mp;/* mount structure */ +xfs_extnum_t nextents;/* number of file extents */ +xfs_bmbt_ptr_t *pp;/* root block address pointer */ -case BMAP_LEFT_FILLING |BMAP_LEFT_CONTIG : -/* -* Setting the first part of a previous oldext extent to newext. -* The left neighbor is contiguous. -*/ -trace_xfs_bmap_pre_update (ip, *idx -1 , state, _THIS_IP_); -xfs_bmbt_set_blockcount (xfs_iext_get_ext (ifp, *idx -1 ), -LEFT .br_blockcount + new->br_blockcount); -xfs_bmbt_set_startoff (ep, -PREV .br_startoff + new->br_blockcount); -trace_xfs_bmap_post_update (ip, *idx -1 , state, _THIS_IP_); + ifp =XFS_IFORK_PTR (ip, whichfork); +ASSERT (XFS_IFORK_FORMAT (ip, whichfork) ==XFS_DINODE_FMT_EXTENTS ); -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -xfs_bmbt_set_startblock (ep, - new->br_startblock + new->br_blockcount); -xfs_bmbt_set_blockcount (ep, -PREV .br_blockcount - new->br_blockcount); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); +/* +* Make space in the inode incore. +*/ +xfs_iroot_realloc (ip,1 , whichfork); + ifp->if_flags |=XFS_IFBROOT ; - --*idx; +/* +* Fill in the root. +*/ + block = ifp->if_broot; + block->bb_magic =cpu_to_be32 (XFS_BMAP_MAGIC ); + block->bb_level =cpu_to_be16 (1 ); + block->bb_numrecs =cpu_to_be16 (1 ); + block->bb_u.l.bb_leftsib =cpu_to_be64 (NULLDFSBNO ); + block->bb_u.l.bb_rightsib =cpu_to_be64 (NULLDFSBNO ); -if (cur ==NULL ) - rval =XFS_ILOG_DEXT ; -else { - rval =0 ; -if ((error =xfs_bmbt_lookup_eq (cur,PREV .br_startoff, -PREV .br_startblock,PREV .br_blockcount, - &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_bmbt_update (cur, -PREV .br_startoff + new->br_blockcount, -PREV .br_startblock + new->br_blockcount, -PREV .br_blockcount - new->br_blockcount, - oldext))) - goto done; -if ((error =xfs_btree_decrement (cur,0 , &i))) - goto done; - error =xfs_bmbt_update (cur,LEFT .br_startoff, -LEFT .br_startblock, -LEFT .br_blockcount + new->br_blockcount, -LEFT .br_state); -if (error) - goto done; - } -break ; - -case BMAP_LEFT_FILLING : -/* -* Setting the first part of a previous oldext extent to newext. -* The left neighbor is not contiguous. -*/ -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -ASSERT (ep &&xfs_bmbt_get_state (ep) == oldext); -xfs_bmbt_set_startoff (ep, new_endoff); -xfs_bmbt_set_blockcount (ep, -PREV .br_blockcount - new->br_blockcount); -xfs_bmbt_set_startblock (ep, - new->br_startblock + new->br_blockcount); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); - -xfs_iext_insert (ip, *idx,1 , new, state); - ip->i_d.di_nextents++; -if (cur ==NULL ) - rval =XFS_ILOG_CORE |XFS_ILOG_DEXT ; -else { - rval =XFS_ILOG_CORE ; -if ((error =xfs_bmbt_lookup_eq (cur,PREV .br_startoff, -PREV .br_startblock,PREV .br_blockcount, - &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_bmbt_update (cur, -PREV .br_startoff + new->br_blockcount, -PREV .br_startblock + new->br_blockcount, -PREV .br_blockcount - new->br_blockcount, - oldext))) - goto done; - cur->bc_rec.b = *new; -if ((error =xfs_btree_insert (cur, &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); +/* +* Need a cursor. Can't allocate until bb_level is filled in. +*/ + mp = ip->i_mount; + cur =xfs_bmbt_init_cursor (mp, tp, ip, whichfork); + cur->bc_private.b.firstblock = *firstblock; + cur->bc_private.b.flist = flist; + cur->bc_private.b.flags = wasdel ?XFS_BTCUR_BPRV_WASDEL :0 ; +/* +* Convert to a btree with two levels, one record in root. +*/ +XFS_IFORK_FMT_SET (ip, whichfork,XFS_DINODE_FMT_BTREE ); +memset (&args,0 ,sizeof (args)); + args.tp = tp; + args.mp = mp; + args.firstblock = *firstblock; +if (*firstblock ==NULLFSBLOCK ) { + args.type =XFS_ALLOCTYPE_START_BNO ; + args.fsbno =XFS_INO_TO_FSB (mp, ip->i_ino); + }else if (flist->xbf_low) { + args.type =XFS_ALLOCTYPE_START_BNO ; + args.fsbno = *firstblock; + }else { + args.type =XFS_ALLOCTYPE_NEAR_BNO ; + args.fsbno = *firstblock; + } + args.minlen = args.maxlen = args.prod =1 ; + args.wasdel = wasdel; + *logflagsp =0 ; +if ((error =xfs_alloc_vextent (&args))) { +xfs_iroot_realloc (ip,-1 , whichfork); +xfs_btree_del_cursor (cur,XFS_BTREE_ERROR ); +return error; + } +/* +* Allocation can't fail, the space was reserved. +*/ +ASSERT (args.fsbno !=NULLFSBLOCK ); +ASSERT (*firstblock ==NULLFSBLOCK || + args.agno ==XFS_FSB_TO_AGNO (mp, *firstblock) || + (flist->xbf_low && + args.agno >XFS_FSB_TO_AGNO (mp, *firstblock))); + *firstblock = cur->bc_private.b.firstblock = args.fsbno; + cur->bc_private.b.allocated++; + ip->i_d.di_nblocks++; +xfs_trans_mod_dquot_byino (tp, ip,XFS_TRANS_DQ_BCOUNT ,1L ); + abp =xfs_btree_get_bufl (mp, tp, args.fsbno,0 ); +/* +* Fill in the child block. +*/ + abp->b_ops = &xfs_bmbt_buf_ops; + ablock =XFS_BUF_TO_BLOCK (abp); + ablock->bb_magic =cpu_to_be32 (XFS_BMAP_MAGIC ); + ablock->bb_level =0 ; + ablock->bb_u.l.bb_leftsib =cpu_to_be64 (NULLDFSBNO ); + ablock->bb_u.l.bb_rightsib =cpu_to_be64 (NULLDFSBNO ); + arp =XFS_BMBT_REC_ADDR (mp, ablock,1 ); + nextents = ifp->if_bytes / (uint )sizeof (xfs_bmbt_rec_t); +for (cnt = i =0 ; i < nextents; i++) { + ep =xfs_iext_get_ext (ifp, i); +if (!isnullstartblock (xfs_bmbt_get_startblock (ep))) { + arp->l0 =cpu_to_be64 (ep->l0); + arp->l1 =cpu_to_be64 (ep->l1); + arp++; cnt++; } -break ; + } +ASSERT (cnt ==XFS_IFORK_NEXTENTS (ip, whichfork)); +xfs_btree_set_numrecs (ablock, cnt); -case BMAP_RIGHT_FILLING |BMAP_RIGHT_CONTIG : -/* -* Setting the last part of a previous oldext extent to newext. -* The right neighbor is contiguous with the new allocation. -*/ -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (ep, -PREV .br_blockcount - new->br_blockcount); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); +/* +* Fill in the root key and pointer. +*/ + kp =XFS_BMBT_KEY_ADDR (mp, block,1 ); + arp =XFS_BMBT_REC_ADDR (mp, ablock,1 ); + kp->br_startoff =cpu_to_be64 (xfs_bmbt_disk_get_startoff (arp)); + pp =XFS_BMBT_PTR_ADDR (mp, block,1 ,xfs_bmbt_get_maxrecs (cur, +be16_to_cpu (block->bb_level))); + *pp =cpu_to_be64 (args.fsbno); - ++*idx; +/* +* Do all this logging at the end so that +* the root is at the right level. +*/ +xfs_btree_log_block (cur, abp,XFS_BB_ALL_BITS ); +xfs_btree_log_recs (cur, abp,1 ,be16_to_cpu (ablock->bb_numrecs)); +ASSERT (*curp ==NULL ); + *curp = cur; + *logflagsp =XFS_ILOG_CORE |xfs_ilog_fbroot (whichfork); +return 0 ; +} -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -xfs_bmbt_set_allf (xfs_iext_get_ext (ifp, *idx), - new->br_startoff, new->br_startblock, - new->br_blockcount +RIGHT .br_blockcount, newext); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); +/* +* Convert a local file to an extents file. +* This code is out of bounds for data forks of regular files, +* since the file data needs to get logged so things will stay consistent. +* (The bmap-level manipulations are ok, though). +*/ +STATIC int /* error */ +xfs_bmap_local_to_extents ( +xfs_trans_t *tp,/* transaction pointer */ +xfs_inode_t *ip,/* incore inode pointer */ +xfs_fsblock_t *firstblock,/* first block allocated in xaction */ +xfs_extlen_t total,/* total blocks needed by transaction */ +int *logflagsp,/* inode logging flags */ +int whichfork, +void (*init_fn)(struct xfs_buf *bp, +struct xfs_inode *ip, +struct xfs_ifork *ifp)) +{ +int error;/* error return value */ +int flags;/* logging flags returned */ +xfs_ifork_t *ifp;/* inode fork pointer */ -if (cur ==NULL ) - rval =XFS_ILOG_DEXT ; -else { - rval =0 ; -if ((error =xfs_bmbt_lookup_eq (cur,PREV .br_startoff, -PREV .br_startblock, -PREV .br_blockcount, &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_bmbt_update (cur,PREV .br_startoff, -PREV .br_startblock, -PREV .br_blockcount - new->br_blockcount, - oldext))) - goto done; -if ((error =xfs_btree_increment (cur,0 , &i))) - goto done; -if ((error =xfs_bmbt_update (cur, new->br_startoff, - new->br_startblock, - new->br_blockcount +RIGHT .br_blockcount, - newext))) - goto done; - } -break ; +/* +* We don't want to deal with the case of keeping inode data inline yet. +* So sending the data fork of a regular inode is invalid. +*/ +ASSERT (!(S_ISREG (ip->i_d.di_mode) && whichfork ==XFS_DATA_FORK )); + ifp =XFS_IFORK_PTR (ip, whichfork); +ASSERT (XFS_IFORK_FORMAT (ip, whichfork) ==XFS_DINODE_FMT_LOCAL ); + flags =0 ; + error =0 ; +if (ifp->if_bytes) { +xfs_alloc_arg_t args;/* allocation arguments */ +xfs_buf_t *bp;/* buffer for extent block */ +xfs_bmbt_rec_host_t *ep;/* extent record pointer */ -case BMAP_RIGHT_FILLING : +ASSERT ((ifp->if_flags & + (XFS_IFINLINE |XFS_IFEXTENTS |XFS_IFEXTIREC )) ==XFS_IFINLINE ); +memset (&args,0 ,sizeof (args)); + args.tp = tp; + args.mp = ip->i_mount; + args.firstblock = *firstblock;/* -* Setting the last part of a previous oldext extent to newext. -* The right neighbor is not contiguous. +* Allocate a block. We know we need only one, since the +* file currently fits in an inode. */ -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (ep, -PREV .br_blockcount - new->br_blockcount); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); +if (*firstblock ==NULLFSBLOCK ) { + args.fsbno =XFS_INO_TO_FSB (args.mp, ip->i_ino); + args.type =XFS_ALLOCTYPE_START_BNO ; + }else { + args.fsbno = *firstblock; + args.type =XFS_ALLOCTYPE_NEAR_BNO ; + } + args.total = total; + args.minlen = args.maxlen = args.prod =1 ; + error =xfs_alloc_vextent (&args); +if (error) + goto done; - ++*idx; -xfs_iext_insert (ip, *idx,1 , new, state); +/* Can't fail, the space was reserved. */ +ASSERT (args.fsbno !=NULLFSBLOCK ); +ASSERT (args.len ==1 ); + *firstblock = args.fsbno; + bp =xfs_btree_get_bufl (args.mp, tp, args.fsbno,0 ); - ip->i_d.di_nextents++; -if (cur ==NULL ) - rval =XFS_ILOG_CORE |XFS_ILOG_DEXT ; -else { - rval =XFS_ILOG_CORE ; -if ((error =xfs_bmbt_lookup_eq (cur,PREV .br_startoff, -PREV .br_startblock,PREV .br_blockcount, - &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -if ((error =xfs_bmbt_update (cur,PREV .br_startoff, -PREV .br_startblock, -PREV .br_blockcount - new->br_blockcount, - oldext))) - goto done; -if ((error =xfs_bmbt_lookup_eq (cur, new->br_startoff, - new->br_startblock, new->br_blockcount, - &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==0 , done); - cur->bc_rec.b.br_state =XFS_EXT_NORM ; -if ((error =xfs_btree_insert (cur, &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - } -break ; - -case 0 : -/* -* Setting the middle part of a previous oldext extent to -* newext. Contiguity is impossible here. -* One extent becomes three extents. -*/ -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (ep, - new->br_startoff -PREV .br_startoff); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); +/* initialise the block and copy the data */ +init_fn (bp, ip, ifp); - r[0 ] = *new; - r[1 ].br_startoff = new_endoff; - r[1 ].br_blockcount = -PREV .br_startoff +PREV .br_blockcount - new_endoff; - r[1 ].br_startblock = new->br_startblock + new->br_blockcount; - r[1 ].br_state = oldext; +/* account for the change in fork size and log everything */ +xfs_trans_log_buf (tp, bp,0 , ifp->if_bytes -1 ); +xfs_bmap_forkoff_reset (args.mp, ip, whichfork); +xfs_idata_realloc (ip, -ifp->if_bytes, whichfork); +xfs_iext_add (ifp,0 ,1 ); + ep =xfs_iext_get_ext (ifp,0 ); +xfs_bmbt_set_allf (ep,0 , args.fsbno,1 ,XFS_EXT_NORM ); +trace_xfs_bmap_post_update (ip,0 , + whichfork ==XFS_ATTR_FORK ?BMAP_ATTRFORK :0 , + _THIS_IP_); +XFS_IFORK_NEXT_SET (ip, whichfork,1 ); + ip->i_d.di_nblocks =1 ; +xfs_trans_mod_dquot_byino (tp, ip, +XFS_TRANS_DQ_BCOUNT ,1L ); + flags |=xfs_ilog_fext (whichfork); + }else { +ASSERT (XFS_IFORK_NEXTENTS (ip, whichfork) ==0 ); +xfs_bmap_forkoff_reset (ip->i_mount, ip, whichfork); + } + ifp->if_flags &= ~XFS_IFINLINE ; + ifp->if_flags |=XFS_IFEXTENTS ; +XFS_IFORK_FMT_SET (ip, whichfork,XFS_DINODE_FMT_EXTENTS ); + flags |=XFS_ILOG_CORE ; +done: + *logflagsp = flags; +return error; +} - ++*idx; -xfs_iext_insert (ip, *idx,2 , &r[0 ], state); +/* +* Called from xfs_bmap_add_attrfork to handle btree format files. +*/ +STATIC int /* error */ +xfs_bmap_add_attrfork_btree ( +xfs_trans_t *tp,/* transaction pointer */ +xfs_inode_t *ip,/* incore inode pointer */ +xfs_fsblock_t *firstblock,/* first block allocated */ +xfs_bmap_free_t *flist,/* blocks to free at commit */ +int *flags)/* inode logging flags */ +{ +xfs_btree_cur_t *cur;/* btree cursor */ +int error;/* error return value */ +xfs_mount_t *mp;/* file system mount struct */ +int stat;/* newroot status */ - ip->i_d.di_nextents +=2 ; -if (cur ==NULL ) - rval =XFS_ILOG_CORE |XFS_ILOG_DEXT ; -else { - rval =XFS_ILOG_CORE ; -if ((error =xfs_bmbt_lookup_eq (cur,PREV .br_startoff, -PREV .br_startblock,PREV .br_blockcount, - &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -/* new right extent - oldext */ -if ((error =xfs_bmbt_update (cur, r[1 ].br_startoff, - r[1 ].br_startblock, r[1 ].br_blockcount, - r[1 ].br_state))) - goto done; -/* new left extent - oldext */ - cur->bc_rec.b =PREV ; - cur->bc_rec.b.br_blockcount = - new->br_startoff -PREV .br_startoff; -if ((error =xfs_btree_insert (cur, &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); -/* -* Reset the cursor to the position of the new extent -* we are about to insert as we can't trust it after -* the previous insert. -*/ -if ((error =xfs_bmbt_lookup_eq (cur, new->br_startoff, - new->br_startblock, new->br_blockcount, - &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==0 , done); -/* new middle extent - newext */ - cur->bc_rec.b.br_state = new->br_state; -if ((error =xfs_btree_insert (cur, &i))) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); + mp = ip->i_mount; +if (ip->i_df.if_broot_bytes <=XFS_IFORK_DSIZE (ip)) + *flags |=XFS_ILOG_DBROOT ; +else { + cur =xfs_bmbt_init_cursor (mp, tp, ip,XFS_DATA_FORK ); + cur->bc_private.b.flist = flist; + cur->bc_private.b.firstblock = *firstblock; +if ((error =xfs_bmbt_lookup_ge (cur,0 ,0 ,0 , &stat))) + goto error0; +/* must be at least one entry */ +XFS_WANT_CORRUPTED_GOTO (stat ==1 , error0); +if ((error =xfs_btree_new_iroot (cur, flags, &stat))) + goto error0; +if (stat ==0 ) { +xfs_btree_del_cursor (cur,XFS_BTREE_NOERROR ); +return XFS_ERROR (ENOSPC ); } -break ; - -case BMAP_LEFT_FILLING |BMAP_LEFT_CONTIG |BMAP_RIGHT_CONTIG : -case BMAP_RIGHT_FILLING |BMAP_LEFT_CONTIG |BMAP_RIGHT_CONTIG : -case BMAP_LEFT_FILLING |BMAP_RIGHT_CONTIG : -case BMAP_RIGHT_FILLING |BMAP_LEFT_CONTIG : -case BMAP_LEFT_CONTIG |BMAP_RIGHT_CONTIG : -case BMAP_LEFT_CONTIG : -case BMAP_RIGHT_CONTIG : -/* -* These cases are all impossible. -*/ -ASSERT (0 ); + *firstblock = cur->bc_private.b.firstblock; + cur->bc_private.b.allocated =0 ; +xfs_btree_del_cursor (cur,XFS_BTREE_NOERROR ); } +return 0 ; +error0: +xfs_btree_del_cursor (cur,XFS_BTREE_ERROR ); +return error; +} -/* convert to a btree if necessary */ -if (xfs_bmap_needs_btree (ip,XFS_DATA_FORK )) { -int tmp_logflags;/* partial log flag return val */ - -ASSERT (cur ==NULL ); - error =xfs_bmap_extents_to_btree (tp, ip, first, flist, &cur, -0 , &tmp_logflags,XFS_DATA_FORK ); - *logflagsp |= tmp_logflags; -if (error) - goto done; - } +/* +* Called from xfs_bmap_add_attrfork to handle extents format files. +*/ +STATIC int /* error */ +xfs_bmap_add_attrfork_extents ( +xfs_trans_t *tp,/* transaction pointer */ +xfs_inode_t *ip,/* incore inode pointer */ +xfs_fsblock_t *firstblock,/* first block allocated */ +xfs_bmap_free_t *flist,/* blocks to free at commit */ +int *flags)/* inode logging flags */ +{ +xfs_btree_cur_t *cur;/* bmap btree cursor */ +int error;/* error return value */ -/* clear out the allocated field, done with it now in any case. */ +if (ip->i_d.di_nextents *sizeof (xfs_bmbt_rec_t) <=XFS_IFORK_DSIZE (ip)) +return 0 ; + cur =NULL ; + error =xfs_bmap_extents_to_btree (tp, ip, firstblock, flist, &cur,0 , + flags,XFS_DATA_FORK );if (cur) { cur->bc_private.b.allocated =0 ; - *curp = cur; +xfs_btree_del_cursor (cur, + error ?XFS_BTREE_ERROR :XFS_BTREE_NOERROR ); } - -xfs_bmap_check_leaf_extents (*curp, ip,XFS_DATA_FORK ); -done: - *logflagsp |= rval;return error; -#undef LEFT -#undef RIGHT -#undef PREV }/* -* Convert a hole to a delayed allocation. +* Block initialisation functions for local to extent format conversion. +* As these get more complex, they will be moved to the relevant files, +* but for now they are too simple to worry about. */ STATIC void -xfs_bmap_add_extent_hole_delay ( -xfs_inode_t *ip,/* incore inode pointer */ -xfs_extnum_t *idx,/* extent number to update/insert */ -xfs_bmbt_irec_t *new)/* new data to add to file extents */ +xfs_bmap_local_to_extents_init_fn ( +struct xfs_buf *bp, +struct xfs_inode *ip, +struct xfs_ifork *ifp) { -xfs_ifork_t *ifp;/* inode fork pointer */ -xfs_bmbt_irec_t left;/* left neighbor extent entry */ -xfs_filblks_t newlen=0 ;/* new indirect size */ -xfs_filblks_t oldlen=0 ;/* old indirect size */ -xfs_bmbt_irec_t right;/* right neighbor extent entry */ -int state;/* state bits, accessed thru macros */ -xfs_filblks_t temp=0 ;/* temp for indirect calculations */ + bp->b_ops = &xfs_bmbt_buf_ops; +memcpy (bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes); +} - ifp =XFS_IFORK_PTR (ip,XFS_DATA_FORK ); - state =0 ; -ASSERT (isnullstartblock (new->br_startblock)); +STATIC void +xfs_symlink_local_to_remote ( +struct xfs_buf *bp, +struct xfs_inode *ip, +struct xfs_ifork *ifp) +{ +/* remote symlink blocks are not verifiable until CRCs come along */ + bp->b_ops =NULL ; +memcpy (bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes); +} -/* -* Check and set flags if this segment has a left neighbor -*/ -if (*idx >0 ) { - state |=BMAP_LEFT_VALID ; -xfs_bmbt_get_all (xfs_iext_get_ext (ifp, *idx -1 ), &left); +/* +* Called from xfs_bmap_add_attrfork to handle local format files. Each +* different data fork content type needs a different callout to do the +* conversion. Some are basic and only require special block initialisation +* callouts for the data formating, others (directories) are so specialised they +* handle everything themselves. +* +* XXX (dgc): investigate whether directory conversion can use the generic +* formatting callout. It should be possible - it's just a very complex +* formatter. it would also require passing the transaction through to the init +* function. +*/ +STATIC int /* error */ +xfs_bmap_add_attrfork_local ( +xfs_trans_t *tp,/* transaction pointer */ +xfs_inode_t *ip,/* incore inode pointer */ +xfs_fsblock_t *firstblock,/* first block allocated */ +xfs_bmap_free_t *flist,/* blocks to free at commit */ +int *flags)/* inode logging flags */ +{ +xfs_da_args_t dargs;/* args for dir/attr code */ -if (isnullstartblock (left.br_startblock)) - state |=BMAP_LEFT_DELAY ; - } - -/* -* Check and set flags if the current (right) segment exists. -* If it doesn't exist, we're converting the hole at end-of-file. -*/ -if (*idx < ip->i_df.if_bytes / (uint )sizeof (xfs_bmbt_rec_t)) { - state |=BMAP_RIGHT_VALID ; -xfs_bmbt_get_all (xfs_iext_get_ext (ifp, *idx), &right); +if (ip->i_df.if_bytes <=XFS_IFORK_DSIZE (ip)) +return 0 ; -if (isnullstartblock (right.br_startblock)) - state |=BMAP_RIGHT_DELAY ; +if (S_ISDIR (ip->i_d.di_mode)) { +memset (&dargs,0 ,sizeof (dargs)); + dargs.dp = ip; + dargs.firstblock = firstblock; + dargs.flist = flist; + dargs.total = ip->i_mount->m_dirblkfsbs; + dargs.whichfork =XFS_DATA_FORK ; + dargs.trans = tp; +return xfs_dir2_sf_to_block (&dargs); } -/* -* Set contiguity flags on the left and right neighbors. -* Don't let extents get too large, even if the pieces are contiguous. -*/ -if ((state &BMAP_LEFT_VALID ) && (state &BMAP_LEFT_DELAY ) && - left.br_startoff + left.br_blockcount == new->br_startoff && - left.br_blockcount + new->br_blockcount <=MAXEXTLEN ) - state |=BMAP_LEFT_CONTIG ; - -if ((state &BMAP_RIGHT_VALID ) && (state &BMAP_RIGHT_DELAY ) && - new->br_startoff + new->br_blockcount == right.br_startoff && - new->br_blockcount + right.br_blockcount <=MAXEXTLEN && - (!(state &BMAP_LEFT_CONTIG ) || - (left.br_blockcount + new->br_blockcount + - right.br_blockcount <=MAXEXTLEN ))) - state |=BMAP_RIGHT_CONTIG ; +if (S_ISLNK (ip->i_d.di_mode)) +return xfs_bmap_local_to_extents (tp, ip, firstblock,1 , + flags,XFS_DATA_FORK , + xfs_symlink_local_to_remote); -/* -* Switch out based on the contiguity flags. -*/ -switch (state & (BMAP_LEFT_CONTIG |BMAP_RIGHT_CONTIG )) { -case BMAP_LEFT_CONTIG |BMAP_RIGHT_CONTIG : -/* -* New allocation is contiguous with delayed allocations -* on the left and on the right. -* Merge all three into a single extent record. -*/ - --*idx; - temp = left.br_blockcount + new->br_blockcount + - right.br_blockcount; +return xfs_bmap_local_to_extents (tp, ip, firstblock,1 , flags, +XFS_DATA_FORK , + xfs_bmap_local_to_extents_init_fn); +} -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (xfs_iext_get_ext (ifp, *idx), temp); - oldlen =startblockval (left.br_startblock) + -startblockval (new->br_startblock) + -startblockval (right.br_startblock); - newlen =xfs_bmap_worst_indlen (ip, temp); -xfs_bmbt_set_startblock (xfs_iext_get_ext (ifp, *idx), -nullstartblock ((int )newlen)); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); +/* +* Convert inode from non-attributed to attributed. +* Must not be in a transaction, ip must not be locked. +*/ +int /* error code */ +xfs_bmap_add_attrfork ( +xfs_inode_t *ip,/* incore inode pointer */ +int size,/* space new attribute needs */ +int rsvd)/* xact may use reserved blks */ +{ +xfs_fsblock_t firstblock;/* 1st block/ag allocated */ +xfs_bmap_free_t flist;/* freed extent records */ +xfs_mount_t *mp;/* mount structure */ +xfs_trans_t *tp;/* transaction pointer */ +int blks;/* space reservation */ +int version =1 ;/* superblock attr version */ +int committed;/* xaction was committed */ +int logflags;/* logging flags */ +int error;/* error return value */ -xfs_iext_remove (ip, *idx +1 ,1 , state); -break ; +ASSERT (XFS_IFORK_Q (ip) ==0 ); -case BMAP_LEFT_CONTIG : + mp = ip->i_mount; +ASSERT (!XFS_NOT_DQATTACHED (mp, ip)); + tp =xfs_trans_alloc (mp,XFS_TRANS_ADDAFORK ); + blks =XFS_ADDAFORK_SPACE_RES (mp); +if (rsvd) + tp->t_flags |=XFS_TRANS_RESERVE ; +if ((error =xfs_trans_reserve (tp, blks,XFS_ADDAFORK_LOG_RES (mp),0 , +XFS_TRANS_PERM_LOG_RES ,XFS_ADDAFORK_LOG_COUNT ))) + goto error0; +xfs_ilock (ip,XFS_ILOCK_EXCL ); + error =xfs_trans_reserve_quota_nblks (tp, ip, blks,0 , rsvd ? +XFS_QMOPT_RES_REGBLKS |XFS_QMOPT_FORCE_RES : +XFS_QMOPT_RES_REGBLKS ); +if (error) { +xfs_iunlock (ip,XFS_ILOCK_EXCL ); +xfs_trans_cancel (tp,XFS_TRANS_RELEASE_LOG_RES ); +return error; + } +if (XFS_IFORK_Q (ip)) + goto error1; +if (ip->i_d.di_aformat !=XFS_DINODE_FMT_EXTENTS ) {/* -* New allocation is contiguous with a delayed allocation -* on the left. -* Merge the new allocation with the left neighbor. +* For inodes coming from pre-6.2 filesystems. */ - --*idx; - temp = left.br_blockcount + new->br_blockcount; +ASSERT (ip->i_d.di_aformat ==0 ); + ip->i_d.di_aformat =XFS_DINODE_FMT_EXTENTS ; + } +ASSERT (ip->i_d.di_anextents ==0 ); -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (xfs_iext_get_ext (ifp, *idx), temp); - oldlen =startblockval (left.br_startblock) + -startblockval (new->br_startblock); - newlen =xfs_bmap_worst_indlen (ip, temp); -xfs_bmbt_set_startblock (xfs_iext_get_ext (ifp, *idx), -nullstartblock ((int )newlen)); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); -break ; +xfs_trans_ijoin (tp, ip,XFS_ILOCK_EXCL ); +xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); -case BMAP_RIGHT_CONTIG : -/* -* New allocation is contiguous with a delayed allocation -* on the right. -* Merge the new allocation with the right neighbor. -*/ -trace_xfs_bmap_pre_update (ip, *idx, state, _THIS_IP_); - temp = new->br_blockcount + right.br_blockcount; - oldlen =startblockval (new->br_startblock) + -startblockval (right.br_startblock); - newlen =xfs_bmap_worst_indlen (ip, temp); -xfs_bmbt_set_allf (xfs_iext_get_ext (ifp, *idx), - new->br_startoff, -nullstartblock ((int )newlen), temp, right.br_state); -trace_xfs_bmap_post_update (ip, *idx, state, _THIS_IP_); +switch (ip->i_d.di_format) { +case XFS_DINODE_FMT_DEV : + ip->i_d.di_forkoff =roundup (sizeof (xfs_dev_t),8 ) >>3 ; +break ; +case XFS_DINODE_FMT_UUID : + ip->i_d.di_forkoff =roundup (sizeof (uuid_t),8 ) >>3 ; +break ; +case XFS_DINODE_FMT_LOCAL : +case XFS_DINODE_FMT_EXTENTS : +case XFS_DINODE_FMT_BTREE : + ip->i_d.di_forkoff =xfs_attr_shortform_bytesfit (ip, size); +if (!ip->i_d.di_forkoff) + ip->i_d.di_forkoff =xfs_default_attroffset (ip) >>3 ; +else if (mp->m_flags &XFS_MOUNT_ATTR2 ) + version =2 ;break ; +default : +ASSERT (0 ); + error =XFS_ERROR (EINVAL ); + goto error1; + } -case 0 : -/* -* New allocation is not contiguous with another -* delayed allocation. -* Insert a new entry. -*/ - oldlen = newlen =0 ; -xfs_iext_insert (ip, *idx,1 , new, state); +ASSERT (ip->i_afp ==NULL ); + ip->i_afp =kmem_zone_zalloc (xfs_ifork_zone,KM_SLEEP ); + ip->i_afp->if_flags =XFS_IFEXTENTS ; + logflags =0 ; +xfs_bmap_init (&flist, &firstblock); +switch (ip->i_d.di_format) { +case XFS_DINODE_FMT_LOCAL : + error =xfs_bmap_add_attrfork_local (tp, ip, &firstblock, &flist, + &logflags); +break ; +case XFS_DINODE_FMT_EXTENTS : + error =xfs_bmap_add_attrfork_extents (tp, ip, &firstblock, + &flist, &logflags); +break ; +case XFS_DINODE_FMT_BTREE : + error =xfs_bmap_add_attrfork_btree (tp, ip, &firstblock, &flist, + &logflags); +break ; +default : + error =0 ;break ; } -if (oldlen != newlen) { -ASSERT (oldlen > newlen); -xfs_icsb_modify_counters (ip->i_mount,XFS_SBS_FDBLOCKS , - (int64_t )(oldlen - newlen),0 ); -/* -* Nothing to do for disk quota accounting here. -*/ +if (logflags) +xfs_trans_log_inode (tp, ip, logflags); +if (error) + goto error2; +if (!xfs_sb_version_hasattr (&mp->m_sb) || + (!xfs_sb_version_hasattr2 (&mp->m_sb) && version ==2 )) { +__int64_t sbfields =0 ; + +spin_lock (&mp->m_sb_lock); +if (!xfs_sb_version_hasattr (&mp->m_sb)) { +xfs_sb_version_addattr (&mp->m_sb); + sbfields |=XFS_SB_VERSIONNUM ; + } +if (!xfs_sb_version_hasattr2 (&mp->m_sb) && version ==2 ) { +xfs_sb_version_addattr2 (&mp->m_sb); + sbfields |= (XFS_SB_VERSIONNUM |XFS_SB_FEATURES2 ); + } +if (sbfields) { +spin_unlock (&mp->m_sb_lock); +xfs_mod_sb (tp, sbfields); + }else +spin_unlock (&mp->m_sb_lock); } + + error =xfs_bmap_finish (&tp, &flist, &committed); +if (error) + goto error2; +return xfs_trans_commit (tp,XFS_TRANS_RELEASE_LOG_RES ); +error2: +xfs_bmap_cancel (&flist); +error1: +xfs_iunlock (ip,XFS_ILOCK_EXCL ); +error0: +xfs_trans_cancel (tp,XFS_TRANS_RELEASE_LOG_RES |XFS_TRANS_ABORT ); +return error; }/* -* Convert a hole to a real allocation. +* Internal and external extent tree search functions. */ -STATIC int /* error */ -xfs_bmap_add_extent_hole_real ( -struct xfs_bmalloca *bma, -int whichfork) -{ -struct xfs_bmbt_irec *new = &bma->got; -int error;/* error return value */ -int i;/* temp state */ -xfs_ifork_t *ifp;/* inode fork pointer */ -xfs_bmbt_irec_t left;/* left neighbor extent entry */ -xfs_bmbt_irec_t right;/* right neighbor extent entry */ -int rval=0 ;/* return value (logging flags) */ -int state;/* state bits, accessed thru macros */ - - ifp =XFS_IFORK_PTR (bma->ip, whichfork); -ASSERT (bma->idx >=0 ); -ASSERT (bma->idx <= ifp->if_bytes /sizeof (struct xfs_bmbt_rec )); -ASSERT (!isnullstartblock (new->br_startblock)); -ASSERT (!bma->cur || - !(bma->cur->bc_private.b.flags &XFS_BTCUR_BPRV_WASDEL )); - -XFS_STATS_INC (xs_add_exlist); - - state =0 ; -if (whichfork ==XFS_ATTR_FORK ) - state |=BMAP_ATTRFORK ; +/* +* Read in the extents to if_extents. +* All inode fields are set up by caller, we just traverse the btree +* and copy the records in. If the file system cannot contain unwritten +* extents, the records are checked for no "state" flags. +*/ +int /* error */ +xfs_bmap_read_extents ( +xfs_trans_t *tp,/* transaction pointer */ +xfs_inode_t *ip,/* incore inode */ +int whichfork)/* data or attr fork */ +{ +struct xfs_btree_block *block;/* current btree block */ +xfs_fsblock_t bno;/* block # of "block" */ +xfs_buf_t *bp;/* buffer for "block" */ +int error;/* error return value */ +xfs_exntfmt_t exntf;/* XFS_EXTFMT_NOSTATE, if checking */ +xfs_extnum_t i, j;/* index into the extents list */ +xfs_ifork_t *ifp;/* fork structure */ +int level;/* btree level, for checking */ +xfs_mount_t *mp;/* file system mount structure */ +__be64 *pp;/* pointer to block address */ +/* REFERENCED */ +xfs_extnum_t room;/* number of entries there's room for */ + bno =NULLFSBLOCK ; + mp = ip->i_mount; + ifp =XFS_IFORK_PTR (ip, whichfork); + exntf = (whichfork !=XFS_DATA_FORK ) ?XFS_EXTFMT_NOSTATE : +XFS_EXTFMT_INODE (ip); + block = ifp->if_broot;/* -* Check and set flags if this segment has a left neighbor. +* Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. */ -if (bma->idx >0 ) { - state |=BMAP_LEFT_VALID ; -xfs_bmbt_get_all (xfs_iext_get_ext (ifp, bma->idx -1 ), &left); -if (isnullstartblock (left.br_startblock)) - state |=BMAP_LEFT_DELAY ; - } - + level =be16_to_cpu (block->bb_level); +ASSERT (level >0 ); + pp =XFS_BMAP_BROOT_PTR_ADDR (mp, block,1 , ifp->if_broot_bytes); + bno =be64_to_cpu (*pp); +ASSERT (bno !=NULLDFSBNO ); +ASSERT (XFS_FSB_TO_AGNO (mp, bno) < mp->m_sb.sb_agcount); +ASSERT (XFS_FSB_TO_AGBNO (mp, bno) < mp->m_sb.sb_agblocks);/* -* Check and set flags if this segment has a current value. -* Not true if we're inserting into the "hole" at eof. +* Go down the tree until leaf level is reached, following the first +* pointer (leftmost) at each level. */ -if (bma->idx < ifp->if_bytes / (uint )sizeof (xfs_bmbt_rec_t)) { - state |=BMAP_RIGHT_VALID ; -xfs_bmbt_get_all (xfs_iext_get_ext (ifp, bma->idx), &right); -if (isnullstartblock (right.br_startblock)) - state |=BMAP_RIGHT_DELAY ; +while (level-- >0 ) { + error =xfs_btree_read_bufl (mp, tp, bno,0 , &bp, +XFS_BMAP_BTREE_REF , &xfs_bmbt_buf_ops); +if (error) +return error; + block =XFS_BUF_TO_BLOCK (bp); +XFS_WANT_CORRUPTED_GOTO ( +xfs_bmap_sanity_check (mp, bp, level), + error0); +if (level ==0 ) +break ; + pp =XFS_BMBT_PTR_ADDR (mp, block,1 , mp->m_bmap_dmxr[1 ]); + bno =be64_to_cpu (*pp); +XFS_WANT_CORRUPTED_GOTO (XFS_FSB_SANITY_CHECK (mp, bno), error0); +xfs_trans_brelse (tp, bp); } -/* -* We're inserting a real allocation between "left" and "right". -* Set the contiguity flags. Don't let extents get too large. +* Here with bp and block set to the leftmost leaf node in the tree. */ -if ((state &BMAP_LEFT_VALID ) && !(state &BMAP_LEFT_DELAY ) && - left.br_startoff + left.br_blockcount == new->br_startoff && - left.br_startblock + left.br_blockcount == new->br_startblock && - left.br_state == new->br_state && - left.br_blockcount + new->br_blockcount <=MAXEXTLEN ) - state |=BMAP_LEFT_CONTIG ; - -if ((state &BMAP_RIGHT_VALID ) && !(state &BMAP_RIGHT_DELAY ) && - new->br_startoff + new->br_blockcount == right.br_startoff && - new->br_startblock + new->br_blockcount == right.br_startblock && - new->br_state == right.br_state && - new->br_blockcount + right.br_blockcount <=MAXEXTLEN && - (!(state &BMAP_LEFT_CONTIG ) || - left.br_blockcount + new->br_blockcount + - right.br_blockcount <=MAXEXTLEN )) - state |=BMAP_RIGHT_CONTIG ; - - error =0 ; + room = ifp->if_bytes / (uint )sizeof (xfs_bmbt_rec_t); + i =0 ;/* -* Select which case we're in here, and implement it. +* Loop over all leaf nodes. Copy information to the extent records. */ -switch (state & (BMAP_LEFT_CONTIG |BMAP_RIGHT_CONTIG )) { -case BMAP_LEFT_CONTIG |BMAP_RIGHT_CONTIG : -/* -* New allocation is contiguous with real allocations on the -* left and on the right. -* Merge all three into a single extent record. -*/ - --bma->idx; -trace_xfs_bmap_pre_update (bma->ip, bma->idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (xfs_iext_get_ext (ifp, bma->idx), - left.br_blockcount + new->br_blockcount + - right.br_blockcount); -trace_xfs_bmap_post_update (bma->ip, bma->idx, state, _THIS_IP_); - -xfs_iext_remove (bma->ip, bma->idx +1 ,1 , state); +for (;;) { +xfs_bmbt_rec_t *frp; +xfs_fsblock_t nextbno; +xfs_extnum_t num_recs; +xfs_extnum_t start; -XFS_IFORK_NEXT_SET (bma->ip, whichfork, -XFS_IFORK_NEXTENTS (bma->ip, whichfork) -1 ); -if (bma->cur ==NULL ) { - rval =XFS_ILOG_CORE |xfs_ilog_fext (whichfork); - }else { - rval =XFS_ILOG_CORE ; - error =xfs_bmbt_lookup_eq (bma->cur, right.br_startoff, - right.br_startblock, right.br_blockcount, - &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - error =xfs_btree_delete (bma->cur, &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - error =xfs_btree_decrement (bma->cur,0 , &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - error =xfs_bmbt_update (bma->cur, left.br_startoff, - left.br_startblock, - left.br_blockcount + - new->br_blockcount + - right.br_blockcount, - left.br_state); -if (error) - goto done; + num_recs =xfs_btree_get_numrecs (block); +if (unlikely (i + num_recs > room)) { +ASSERT (i + num_recs <= room); +xfs_warn (ip->i_mount, +"corrupt dinode %Lu, (btree extents)." , + (unsigned long long ) ip->i_ino); +XFS_CORRUPTION_ERROR ("xfs_bmap_read_extents(1)" , +XFS_ERRLEVEL_LOW , ip->i_mount, block); + goto error0; } -break ; - -case BMAP_LEFT_CONTIG : +XFS_WANT_CORRUPTED_GOTO ( +xfs_bmap_sanity_check (mp, bp,0 ), + error0);/* -* New allocation is contiguous with a real allocation -* on the left. -* Merge the new allocation with the left neighbor. +* Read-ahead the next leaf block, if any. */ - --bma->idx; -trace_xfs_bmap_pre_update (bma->ip, bma->idx, state, _THIS_IP_); -xfs_bmbt_set_blockcount (xfs_iext_get_ext (ifp, bma->idx), - left.br_blockcount + new->br_blockcount); -trace_xfs_bmap_post_update (bma->ip, bma->idx, state, _THIS_IP_); - -if (bma->cur ==NULL ) { - rval =xfs_ilog_fext (whichfork); - }else { - rval =0 ; - error =xfs_bmbt_lookup_eq (bma->cur, left.br_startoff, - left.br_startblock, left.br_blockcount, - &i); -if (error) - goto done; -XFS_WANT_CORRUPTED_GOTO (i ==1 , done); - error =xfs_bmbt_update (bma->cur, left.br_startoff, - left.br_startblock, - left.br_blockcount + - new->br_blockcount, - left.br_state); -if (error) - goto done; - } -break ; - -case BMAP_RIGHT_CONTIG : + nextbno =be64_to_cpu (block->bb_u.l.bb_rightsib); +if (nextbno !=NULLFSBLOCK ) +xfs_btree_reada_bufl (mp, nextbno,1 , + &xfs_bmbt_buf_ops);/* -* New allocation is contiguous with a real allocation -* on the right. -* Merge the new allocation with the right neighbor. +* Copy records into the extent records.
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Signature · 6 lines
1.7.10 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Part of the diff is not shown here. View the raw message.
Re: [PATCH 2/2] xfs: rearrange some code in xfs_bmap for better locality
Quoted 26 lines · Dave Chinner
From: Dave Chinner<[email protected]>
xfs_bmap.cis a big file, and some of the related code is spread all throughout the file requiring function prototypes for static function and jumping all through the file to follow a single call path. Rearrange the code so that:a) related functionality is grouped together; and
b) functions are grouped in call dependency orderWhile the diffstat is large, there are no code changes in the patch; it is just moving the functionality around and removing the function prototypes at the top of the file. The resulting layout of the code is as follows (top of file to bottom):
- miscellaneous helper functions
- extent tree block counting routines
- debug/sanity checking code
- bmap free list manipulation functions
- inode fork format manipulation functions
- internal/external extent tree seach functions
- extent tree manipulation functions used during allocation
- functions used during extent read/allocate/removal operations (i.e.xfs_bmapi_write,xfs_bmapi_read,xfs_bunmapiandxfs_getbmap)
Quoted 8 lines
This means that following logic paths through the bmapi code is much simpler - most of the code relevant to a specific operation is now clustered together rather than spread all over the file....
Signed-off-by Dave Chinner<[email protected]>--- fs/xfs/xfs_bmap.c |10659 ++++++++++++++++++++++++++--------------------------- 1 file changed, 5261 insertions(+), 5398 deletions(-)
The organization looks good to me. If the file is getting that many
changes, isn't it time to fix all those spaces in the file? (looks like there are over 2500 unnecessary spaces in place of tabs).
--Mark.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 2/2] xfs: rearrange some code in xfs_bmap for better locality
Quoted 31 lines · Mark Tinguely
Quoted 30 lines · Dave Chinner
From: Dave Chinner<[email protected]>
xfs_bmap.cis a big file, and some of the related code is spread all throughout the file requiring function prototypes for static function and jumping all through the file to follow a single call path. Rearrange the code so that:a) related functionality is grouped together; and
b) functions are grouped in call dependency orderWhile the diffstat is large, there are no code changes in the patch; it is just moving the functionality around and removing the function prototypes at the top of the file. The resulting layout of the code is as follows (top of file to bottom):
- miscellaneous helper functions
- extent tree block counting routines
- debug/sanity checking code
- bmap free list manipulation functions
- inode fork format manipulation functions
- internal/external extent tree seach functions
- extent tree manipulation functions used during allocation
- functions used during extent read/allocate/removal operations (i.e.xfs_bmapi_write,xfs_bmapi_read,xfs_bunmapiandxfs_getbmap)This means that following logic paths through the bmapi code is much simpler - most of the code relevant to a specific operation is now clustered together rather than spread all over the file....
Quoted 8 lines
Quoted 4 lines
Signed-off-by Dave Chinner<[email protected]>--- fs/xfs/xfs_bmap.c |10659 ++++++++++++++++++++++++++--------------------------- 1 file changed, 5261 insertions(+), 5398 deletions(-)The organization looks good to me. If the file is getting that many changes, isn't it time to fix all those spaces in the file? (looks like there are over 2500 unnecessary spaces in place of tabs).
My "misplaced whitepsace" syntax highlighting doesn't trip on any, so I didn't notice it. i.e the whitespace is entirely spaces or entirely tabs and not tabs/spaces in combination.
A quick search shows that they are mostly in the variable declaration comment formatting - I tend simply to remove those comments as I modify the surrounding code because, IMO, they are almost entirely redundant as we have well named structures and variables.
So, yeah, maybe a followup patch that kills the comments and fixes the whitespace damage is in order.
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs