2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2005-11-02 03:58:39 +00:00
|
|
|
* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
|
2010-06-23 08:11:15 +00:00
|
|
|
* Copyright (C) 2010 Red Hat, Inc.
|
2005-11-02 03:58:39 +00:00
|
|
|
* All Rights Reserved.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2005-11-02 03:58:39 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
2005-04-16 22:20:36 +00:00
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
2005-11-02 03:58:39 +00:00
|
|
|
* This program is distributed in the hope that it would be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2005-11-02 03:58:39 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
2005-11-02 03:38:42 +00:00
|
|
|
#include "xfs_fs.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_types.h"
|
2005-11-02 03:38:42 +00:00
|
|
|
#include "xfs_bit.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_log.h"
|
2005-11-02 03:38:42 +00:00
|
|
|
#include "xfs_inum.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_trans.h"
|
|
|
|
#include "xfs_sb.h"
|
|
|
|
#include "xfs_ag.h"
|
|
|
|
#include "xfs_mount.h"
|
|
|
|
#include "xfs_error.h"
|
2005-11-02 03:38:42 +00:00
|
|
|
#include "xfs_da_btree.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_bmap_btree.h"
|
2005-11-02 03:38:42 +00:00
|
|
|
#include "xfs_alloc_btree.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_ialloc_btree.h"
|
|
|
|
#include "xfs_dinode.h"
|
|
|
|
#include "xfs_inode.h"
|
2005-11-02 03:38:42 +00:00
|
|
|
#include "xfs_btree.h"
|
|
|
|
#include "xfs_ialloc.h"
|
|
|
|
#include "xfs_alloc.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_bmap.h"
|
|
|
|
#include "xfs_quota.h"
|
2005-11-02 03:38:42 +00:00
|
|
|
#include "xfs_trans_priv.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_trans_space.h"
|
2008-08-13 06:05:49 +00:00
|
|
|
#include "xfs_inode_item.h"
|
xfs: Improve scalability of busy extent tracking
When we free a metadata extent, we record it in the per-AG busy
extent array so that it is not re-used before the freeing
transaction hits the disk. This array is fixed size, so when it
overflows we make further allocation transactions synchronous
because we cannot track more freed extents until those transactions
hit the disk and are completed. Under heavy mixed allocation and
freeing workloads with large log buffers, we can overflow this array
quite easily.
Further, the array is sparsely populated, which means that inserts
need to search for a free slot, and array searches often have to
search many more slots that are actually used to check all the
busy extents. Quite inefficient, really.
To enable this aspect of extent freeing to scale better, we need
a structure that can grow dynamically. While in other areas of
XFS we have used radix trees, the extents being freed are at random
locations on disk so are better suited to being indexed by an rbtree.
So, use a per-AG rbtree indexed by block number to track busy
extents. This incures a memory allocation when marking an extent
busy, but should not occur too often in low memory situations. This
should scale to an arbitrary number of extents so should not be a
limitation for features such as in-memory aggregation of
transactions.
However, there are still situations where we can't avoid allocating
busy extents (such as allocation from the AGFL). To minimise the
overhead of such occurences, we need to avoid doing a synchronous
log force while holding the AGF locked to ensure that the previous
transactions are safely on disk before we use the extent. We can do
this by marking the transaction doing the allocation as synchronous
rather issuing a log force.
Because of the locking involved and the ordering of transactions,
the synchronous transaction provides the same guarantees as a
synchronous log force because it ensures that all the prior
transactions are already on disk when the synchronous transaction
hits the disk. i.e. it preserves the free->allocate order of the
extent correctly in recovery.
By doing this, we avoid holding the AGF locked while log writes are
in progress, hence reducing the length of time the lock is held and
therefore we increase the rate at which we can allocate and free
from the allocation group, thereby increasing overall throughput.
The only problem with this approach is that when a metadata buffer is
marked stale (e.g. a directory block is removed), then buffer remains
pinned and locked until the log goes to disk. The issue here is that
if that stale buffer is reallocated in a subsequent transaction, the
attempt to lock that buffer in the transaction will hang waiting
the log to go to disk to unlock and unpin the buffer. Hence if
someone tries to lock a pinned, stale, locked buffer we need to
push on the log to get it unlocked ASAP. Effectively we are trading
off a guaranteed log force for a much less common trigger for log
force to occur.
Ideally we should not reallocate busy extents. That is a much more
complex fix to the problem as it involves direct intervention in the
allocation btree searches in many places. This is left to a future
set of modifications.
Finally, now that we track busy extents in allocated memory, we
don't need the descriptors in the transaction structure to point to
them. We can replace the complex busy chunk infrastructure with a
simple linked list of busy extents. This allows us to remove a large
chunk of code, making the overall change a net reduction in code
size.
Signed-off-by: Dave Chinner <david@fromorbit.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 02:07:08 +00:00
|
|
|
#include "xfs_trace.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-03-14 02:32:41 +00:00
|
|
|
kmem_zone_t *xfs_trans_zone;
|
2010-06-23 08:11:15 +00:00
|
|
|
kmem_zone_t *xfs_log_item_desc_zone;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
|
2006-03-14 02:32:41 +00:00
|
|
|
/*
|
2010-05-04 13:53:48 +00:00
|
|
|
* Various log reservation values.
|
|
|
|
*
|
|
|
|
* These are based on the size of the file system block because that is what
|
|
|
|
* most transactions manipulate. Each adds in an additional 128 bytes per
|
|
|
|
* item logged to try to account for the overhead of the transaction mechanism.
|
|
|
|
*
|
|
|
|
* Note: Most of the reservations underestimate the number of allocation
|
|
|
|
* groups into which they could free extents in the xfs_bmap_finish() call.
|
|
|
|
* This is because the number in the worst case is quite high and quite
|
|
|
|
* unusual. In order to fix this we need to change xfs_bmap_finish() to free
|
|
|
|
* extents in only a single AG at a time. This will require changes to the
|
|
|
|
* EFI code as well, however, so that the EFI for the extents not freed is
|
|
|
|
* logged again in each transaction. See SGI PV #261917.
|
|
|
|
*
|
|
|
|
* Reservation functions here avoid a huge stack in xfs_trans_init due to
|
|
|
|
* register overflow from temporaries in the calculations.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In a write transaction we can allocate a maximum of 2
|
|
|
|
* extents. This gives:
|
|
|
|
* the inode getting the new extents: inode size
|
|
|
|
* the inode's bmap btree: max depth * block size
|
|
|
|
* the agfs of the ags from which the extents are allocated: 2 * sector
|
|
|
|
* the superblock free block counter: sector size
|
|
|
|
* the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
|
|
|
|
* And the bmap_finish transaction can free bmap blocks in a join:
|
|
|
|
* the agfs of the ags containing the blocks: 2 * sector size
|
|
|
|
* the agfls of the ags containing the blocks: 2 * sector size
|
|
|
|
* the super block free block counter: sector size
|
|
|
|
* the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
|
2006-03-14 02:32:41 +00:00
|
|
|
*/
|
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_write_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
MAX((mp->m_sb.sb_inodesize +
|
|
|
|
XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) +
|
|
|
|
2 * mp->m_sb.sb_sectsize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 2) +
|
|
|
|
128 * (4 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) +
|
|
|
|
XFS_ALLOCFREE_LOG_COUNT(mp, 2))),
|
|
|
|
(2 * mp->m_sb.sb_sectsize +
|
|
|
|
2 * mp->m_sb.sb_sectsize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 2) +
|
|
|
|
128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* In truncating a file we free up to two extents at once. We can modify:
|
|
|
|
* the inode being truncated: inode size
|
|
|
|
* the inode's bmap btree: (max depth + 1) * block size
|
|
|
|
* And the bmap_finish transaction can free the blocks and bmap blocks:
|
|
|
|
* the agf for each of the ags: 4 * sector size
|
|
|
|
* the agfl for each of the ags: 4 * sector size
|
|
|
|
* the super block to reflect the freed blocks: sector size
|
|
|
|
* worst case split in allocation btrees per extent assuming 4 extents:
|
|
|
|
* 4 exts * 2 trees * (2 * max depth - 1) * block size
|
|
|
|
* the inode btree: max depth * blocksize
|
|
|
|
* the allocation btrees: 2 trees * (max depth - 1) * block size
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_itruncate_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
MAX((mp->m_sb.sb_inodesize +
|
|
|
|
XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 1) +
|
|
|
|
128 * (2 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK))),
|
|
|
|
(4 * mp->m_sb.sb_sectsize +
|
|
|
|
4 * mp->m_sb.sb_sectsize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 4) +
|
|
|
|
128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4)) +
|
|
|
|
128 * 5 +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 1) +
|
|
|
|
128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +
|
|
|
|
XFS_ALLOCFREE_LOG_COUNT(mp, 1))));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* In renaming a files we can modify:
|
|
|
|
* the four inodes involved: 4 * inode size
|
|
|
|
* the two directory btrees: 2 * (max depth + v2) * dir block size
|
|
|
|
* the two directory bmap btrees: 2 * max depth * block size
|
|
|
|
* And the bmap_finish transaction can free dir and bmap blocks (two sets
|
|
|
|
* of bmap blocks) giving:
|
|
|
|
* the agf for the ags in which the blocks live: 3 * sector size
|
|
|
|
* the agfl for the ags in which the blocks live: 3 * sector size
|
|
|
|
* the superblock for the free block count: sector size
|
|
|
|
* the allocation btrees: 3 exts * 2 trees * (2 * max depth - 1) * block size
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_rename_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
MAX((4 * mp->m_sb.sb_inodesize +
|
|
|
|
2 * XFS_DIROP_LOG_RES(mp) +
|
|
|
|
128 * (4 + 2 * XFS_DIROP_LOG_COUNT(mp))),
|
|
|
|
(3 * mp->m_sb.sb_sectsize +
|
|
|
|
3 * mp->m_sb.sb_sectsize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 3) +
|
|
|
|
128 * (7 + XFS_ALLOCFREE_LOG_COUNT(mp, 3))));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* For creating a link to an inode:
|
|
|
|
* the parent directory inode: inode size
|
|
|
|
* the linked inode: inode size
|
|
|
|
* the directory btree could split: (max depth + v2) * dir block size
|
|
|
|
* the directory bmap btree could join or split: (max depth + v2) * blocksize
|
|
|
|
* And the bmap_finish transaction can free some bmap blocks giving:
|
|
|
|
* the agf for the ag in which the blocks live: sector size
|
|
|
|
* the agfl for the ag in which the blocks live: sector size
|
|
|
|
* the superblock for the free block count: sector size
|
|
|
|
* the allocation btrees: 2 trees * (2 * max depth - 1) * block size
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_link_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
MAX((mp->m_sb.sb_inodesize +
|
|
|
|
mp->m_sb.sb_inodesize +
|
|
|
|
XFS_DIROP_LOG_RES(mp) +
|
|
|
|
128 * (2 + XFS_DIROP_LOG_COUNT(mp))),
|
|
|
|
(mp->m_sb.sb_sectsize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 1) +
|
|
|
|
128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1))));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* For removing a directory entry we can modify:
|
|
|
|
* the parent directory inode: inode size
|
|
|
|
* the removed inode: inode size
|
|
|
|
* the directory btree could join: (max depth + v2) * dir block size
|
|
|
|
* the directory bmap btree could join or split: (max depth + v2) * blocksize
|
|
|
|
* And the bmap_finish transaction can free the dir and bmap blocks giving:
|
|
|
|
* the agf for the ag in which the blocks live: 2 * sector size
|
|
|
|
* the agfl for the ag in which the blocks live: 2 * sector size
|
|
|
|
* the superblock for the free block count: sector size
|
|
|
|
* the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_remove_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
MAX((mp->m_sb.sb_inodesize +
|
|
|
|
mp->m_sb.sb_inodesize +
|
|
|
|
XFS_DIROP_LOG_RES(mp) +
|
|
|
|
128 * (2 + XFS_DIROP_LOG_COUNT(mp))),
|
|
|
|
(2 * mp->m_sb.sb_sectsize +
|
|
|
|
2 * mp->m_sb.sb_sectsize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 2) +
|
|
|
|
128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* For symlink we can modify:
|
|
|
|
* the parent directory inode: inode size
|
|
|
|
* the new inode: inode size
|
|
|
|
* the inode btree entry: 1 block
|
|
|
|
* the directory btree: (max depth + v2) * dir block size
|
|
|
|
* the directory inode's bmap btree: (max depth + v2) * block size
|
|
|
|
* the blocks for the symlink: 1 kB
|
|
|
|
* Or in the first xact we allocate some inodes giving:
|
|
|
|
* the agi and agf of the ag getting the new inodes: 2 * sectorsize
|
|
|
|
* the inode blocks allocated: XFS_IALLOC_BLOCKS * blocksize
|
|
|
|
* the inode btree: max depth * blocksize
|
|
|
|
* the allocation btrees: 2 trees * (2 * max depth - 1) * block size
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_symlink_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
MAX((mp->m_sb.sb_inodesize +
|
|
|
|
mp->m_sb.sb_inodesize +
|
|
|
|
XFS_FSB_TO_B(mp, 1) +
|
|
|
|
XFS_DIROP_LOG_RES(mp) +
|
|
|
|
1024 +
|
|
|
|
128 * (4 + XFS_DIROP_LOG_COUNT(mp))),
|
|
|
|
(2 * mp->m_sb.sb_sectsize +
|
|
|
|
XFS_FSB_TO_B(mp, XFS_IALLOC_BLOCKS(mp)) +
|
|
|
|
XFS_FSB_TO_B(mp, mp->m_in_maxlevels) +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 1) +
|
|
|
|
128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +
|
|
|
|
XFS_ALLOCFREE_LOG_COUNT(mp, 1))));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* For create we can modify:
|
|
|
|
* the parent directory inode: inode size
|
|
|
|
* the new inode: inode size
|
|
|
|
* the inode btree entry: block size
|
|
|
|
* the superblock for the nlink flag: sector size
|
|
|
|
* the directory btree: (max depth + v2) * dir block size
|
|
|
|
* the directory inode's bmap btree: (max depth + v2) * block size
|
|
|
|
* Or in the first xact we allocate some inodes giving:
|
|
|
|
* the agi and agf of the ag getting the new inodes: 2 * sectorsize
|
|
|
|
* the superblock for the nlink flag: sector size
|
|
|
|
* the inode blocks allocated: XFS_IALLOC_BLOCKS * blocksize
|
|
|
|
* the inode btree: max depth * blocksize
|
|
|
|
* the allocation btrees: 2 trees * (max depth - 1) * block size
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_create_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
MAX((mp->m_sb.sb_inodesize +
|
|
|
|
mp->m_sb.sb_inodesize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
XFS_FSB_TO_B(mp, 1) +
|
|
|
|
XFS_DIROP_LOG_RES(mp) +
|
|
|
|
128 * (3 + XFS_DIROP_LOG_COUNT(mp))),
|
|
|
|
(3 * mp->m_sb.sb_sectsize +
|
|
|
|
XFS_FSB_TO_B(mp, XFS_IALLOC_BLOCKS(mp)) +
|
|
|
|
XFS_FSB_TO_B(mp, mp->m_in_maxlevels) +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 1) +
|
|
|
|
128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +
|
|
|
|
XFS_ALLOCFREE_LOG_COUNT(mp, 1))));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Making a new directory is the same as creating a new file.
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_mkdir_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return xfs_calc_create_reservation(mp);
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* In freeing an inode we can modify:
|
|
|
|
* the inode being freed: inode size
|
|
|
|
* the super block free inode counter: sector size
|
|
|
|
* the agi hash list and counters: sector size
|
|
|
|
* the inode btree entry: block size
|
|
|
|
* the on disk inode before ours in the agi hash list: inode cluster size
|
|
|
|
* the inode btree: max depth * blocksize
|
|
|
|
* the allocation btrees: 2 trees * (max depth - 1) * block size
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_ifree_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
mp->m_sb.sb_inodesize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
XFS_FSB_TO_B(mp, 1) +
|
|
|
|
MAX((__uint16_t)XFS_FSB_TO_B(mp, 1),
|
|
|
|
XFS_INODE_CLUSTER_SIZE(mp)) +
|
|
|
|
128 * 5 +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 1) +
|
|
|
|
128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +
|
|
|
|
XFS_ALLOCFREE_LOG_COUNT(mp, 1));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* When only changing the inode we log the inode and possibly the superblock
|
|
|
|
* We also add a bit of slop for the transaction stuff.
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_ichange_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
mp->m_sb.sb_inodesize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
512;
|
|
|
|
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Growing the data section of the filesystem.
|
|
|
|
* superblock
|
|
|
|
* agi and agf
|
|
|
|
* allocation btrees
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_growdata_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return mp->m_sb.sb_sectsize * 3 +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 1) +
|
|
|
|
128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Growing the rt section of the filesystem.
|
|
|
|
* In the first set of transactions (ALLOC) we allocate space to the
|
|
|
|
* bitmap or summary files.
|
|
|
|
* superblock: sector size
|
|
|
|
* agf of the ag from which the extent is allocated: sector size
|
|
|
|
* bmap btree for bitmap/summary inode: max depth * blocksize
|
|
|
|
* bitmap/summary inode: inode size
|
|
|
|
* allocation btrees for 1 block alloc: 2 * (2 * maxdepth - 1) * blocksize
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_growrtalloc_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return 2 * mp->m_sb.sb_sectsize +
|
|
|
|
XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) +
|
|
|
|
mp->m_sb.sb_inodesize +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 1) +
|
|
|
|
128 * (3 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) +
|
|
|
|
XFS_ALLOCFREE_LOG_COUNT(mp, 1));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Growing the rt section of the filesystem.
|
|
|
|
* In the second set of transactions (ZERO) we zero the new metadata blocks.
|
|
|
|
* one bitmap/summary block: blocksize
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_growrtzero_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return mp->m_sb.sb_blocksize + 128;
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Growing the rt section of the filesystem.
|
|
|
|
* In the third set of transactions (FREE) we update metadata without
|
|
|
|
* allocating any new blocks.
|
|
|
|
* superblock: sector size
|
|
|
|
* bitmap inode: inode size
|
|
|
|
* summary inode: inode size
|
|
|
|
* one bitmap block: blocksize
|
|
|
|
* summary blocks: new summary size
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_growrtfree_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return mp->m_sb.sb_sectsize +
|
|
|
|
2 * mp->m_sb.sb_inodesize +
|
|
|
|
mp->m_sb.sb_blocksize +
|
|
|
|
mp->m_rsumsize +
|
|
|
|
128 * 5;
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Logging the inode modification timestamp on a synchronous write.
|
|
|
|
* inode
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_swrite_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return mp->m_sb.sb_inodesize + 128;
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Logging the inode mode bits when writing a setuid/setgid file
|
|
|
|
* inode
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
|
|
|
xfs_calc_writeid_reservation(xfs_mount_t *mp)
|
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return mp->m_sb.sb_inodesize + 128;
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Converting the inode from non-attributed to attributed.
|
|
|
|
* the inode being converted: inode size
|
|
|
|
* agf block and superblock (for block allocation)
|
|
|
|
* the new block (directory sized)
|
|
|
|
* bmap blocks for the new directory block
|
|
|
|
* allocation btrees
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_addafork_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
mp->m_sb.sb_inodesize +
|
|
|
|
mp->m_sb.sb_sectsize * 2 +
|
|
|
|
mp->m_dirblksize +
|
|
|
|
XFS_FSB_TO_B(mp, XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1) +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 1) +
|
|
|
|
128 * (4 + XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1 +
|
|
|
|
XFS_ALLOCFREE_LOG_COUNT(mp, 1));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Removing the attribute fork of a file
|
|
|
|
* the inode being truncated: inode size
|
|
|
|
* the inode's bmap btree: max depth * block size
|
|
|
|
* And the bmap_finish transaction can free the blocks and bmap blocks:
|
|
|
|
* the agf for each of the ags: 4 * sector size
|
|
|
|
* the agfl for each of the ags: 4 * sector size
|
|
|
|
* the super block to reflect the freed blocks: sector size
|
|
|
|
* worst case split in allocation btrees per extent assuming 4 extents:
|
|
|
|
* 4 exts * 2 trees * (2 * max depth - 1) * block size
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_attrinval_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return MAX((mp->m_sb.sb_inodesize +
|
|
|
|
XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) +
|
|
|
|
128 * (1 + XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK))),
|
|
|
|
(4 * mp->m_sb.sb_sectsize +
|
|
|
|
4 * mp->m_sb.sb_sectsize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 4) +
|
|
|
|
128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4))));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Setting an attribute.
|
|
|
|
* the inode getting the attribute
|
|
|
|
* the superblock for allocations
|
|
|
|
* the agfs extents are allocated from
|
|
|
|
* the attribute btree * max depth
|
|
|
|
* the inode allocation btree
|
|
|
|
* Since attribute transaction space is dependent on the size of the attribute,
|
|
|
|
* the calculation is done partially at mount time and partially at runtime.
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_attrset_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
mp->m_sb.sb_inodesize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
XFS_FSB_TO_B(mp, XFS_DA_NODE_MAXDEPTH) +
|
|
|
|
128 * (2 + XFS_DA_NODE_MAXDEPTH);
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Removing an attribute.
|
|
|
|
* the inode: inode size
|
|
|
|
* the attribute btree could join: max depth * block size
|
|
|
|
* the inode bmap btree could join or split: max depth * block size
|
|
|
|
* And the bmap_finish transaction can free the attr blocks freed giving:
|
|
|
|
* the agf for the ag in which the blocks live: 2 * sector size
|
|
|
|
* the agfl for the ag in which the blocks live: 2 * sector size
|
|
|
|
* the superblock for the free block count: sector size
|
|
|
|
* the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_attrrm_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return XFS_DQUOT_LOGRES(mp) +
|
|
|
|
MAX((mp->m_sb.sb_inodesize +
|
|
|
|
XFS_FSB_TO_B(mp, XFS_DA_NODE_MAXDEPTH) +
|
|
|
|
XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) +
|
|
|
|
128 * (1 + XFS_DA_NODE_MAXDEPTH +
|
|
|
|
XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK))),
|
|
|
|
(2 * mp->m_sb.sb_sectsize +
|
|
|
|
2 * mp->m_sb.sb_sectsize +
|
|
|
|
mp->m_sb.sb_sectsize +
|
|
|
|
XFS_ALLOCFREE_LOG_RES(mp, 2) +
|
|
|
|
128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))));
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2010-05-04 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Clearing a bad agino number in an agi hash bucket.
|
|
|
|
*/
|
2006-03-14 02:32:41 +00:00
|
|
|
STATIC uint
|
2010-05-04 13:53:48 +00:00
|
|
|
xfs_calc_clear_agi_bucket_reservation(
|
|
|
|
struct xfs_mount *mp)
|
2006-03-14 02:32:41 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
return mp->m_sb.sb_sectsize + 128;
|
2006-03-14 02:32:41 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Initialize the precomputed transaction reservation values
|
|
|
|
* in the mount structure.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_init(
|
2010-05-04 13:53:48 +00:00
|
|
|
struct xfs_mount *mp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-05-04 13:53:48 +00:00
|
|
|
struct xfs_trans_reservations *resp = &mp->m_reservations;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-03-14 02:32:41 +00:00
|
|
|
resp->tr_write = xfs_calc_write_reservation(mp);
|
|
|
|
resp->tr_itruncate = xfs_calc_itruncate_reservation(mp);
|
|
|
|
resp->tr_rename = xfs_calc_rename_reservation(mp);
|
|
|
|
resp->tr_link = xfs_calc_link_reservation(mp);
|
|
|
|
resp->tr_remove = xfs_calc_remove_reservation(mp);
|
|
|
|
resp->tr_symlink = xfs_calc_symlink_reservation(mp);
|
|
|
|
resp->tr_create = xfs_calc_create_reservation(mp);
|
|
|
|
resp->tr_mkdir = xfs_calc_mkdir_reservation(mp);
|
|
|
|
resp->tr_ifree = xfs_calc_ifree_reservation(mp);
|
|
|
|
resp->tr_ichange = xfs_calc_ichange_reservation(mp);
|
|
|
|
resp->tr_growdata = xfs_calc_growdata_reservation(mp);
|
|
|
|
resp->tr_swrite = xfs_calc_swrite_reservation(mp);
|
|
|
|
resp->tr_writeid = xfs_calc_writeid_reservation(mp);
|
|
|
|
resp->tr_addafork = xfs_calc_addafork_reservation(mp);
|
|
|
|
resp->tr_attrinval = xfs_calc_attrinval_reservation(mp);
|
|
|
|
resp->tr_attrset = xfs_calc_attrset_reservation(mp);
|
|
|
|
resp->tr_attrrm = xfs_calc_attrrm_reservation(mp);
|
|
|
|
resp->tr_clearagi = xfs_calc_clear_agi_bucket_reservation(mp);
|
|
|
|
resp->tr_growrtalloc = xfs_calc_growrtalloc_reservation(mp);
|
|
|
|
resp->tr_growrtzero = xfs_calc_growrtzero_reservation(mp);
|
|
|
|
resp->tr_growrtfree = xfs_calc_growrtfree_reservation(mp);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called to allocate a transaction structure.
|
|
|
|
* The type parameter indicates the type of the transaction. These
|
|
|
|
* are enumerated in xfs_trans.h.
|
|
|
|
*
|
|
|
|
* Dynamically allocate the transaction structure from the transaction
|
|
|
|
* zone, initialize it, and return it to the caller.
|
|
|
|
*/
|
|
|
|
xfs_trans_t *
|
|
|
|
xfs_trans_alloc(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
uint type)
|
|
|
|
{
|
2007-08-30 07:21:30 +00:00
|
|
|
xfs_wait_for_freeze(mp, SB_FREEZE_TRANS);
|
2009-10-19 04:00:03 +00:00
|
|
|
return _xfs_trans_alloc(mp, type, KM_SLEEP);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
xfs_trans_t *
|
|
|
|
_xfs_trans_alloc(
|
|
|
|
xfs_mount_t *mp,
|
2009-10-19 04:00:03 +00:00
|
|
|
uint type,
|
|
|
|
uint memflags)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
xfs_trans_t *tp;
|
|
|
|
|
2006-06-09 07:11:55 +00:00
|
|
|
atomic_inc(&mp->m_active_trans);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-10-19 04:00:03 +00:00
|
|
|
tp = kmem_zone_zalloc(xfs_trans_zone, memflags);
|
2005-04-16 22:20:36 +00:00
|
|
|
tp->t_magic = XFS_TRANS_MAGIC;
|
|
|
|
tp->t_type = type;
|
|
|
|
tp->t_mountp = mp;
|
2010-06-23 08:11:15 +00:00
|
|
|
INIT_LIST_HEAD(&tp->t_items);
|
xfs: Improve scalability of busy extent tracking
When we free a metadata extent, we record it in the per-AG busy
extent array so that it is not re-used before the freeing
transaction hits the disk. This array is fixed size, so when it
overflows we make further allocation transactions synchronous
because we cannot track more freed extents until those transactions
hit the disk and are completed. Under heavy mixed allocation and
freeing workloads with large log buffers, we can overflow this array
quite easily.
Further, the array is sparsely populated, which means that inserts
need to search for a free slot, and array searches often have to
search many more slots that are actually used to check all the
busy extents. Quite inefficient, really.
To enable this aspect of extent freeing to scale better, we need
a structure that can grow dynamically. While in other areas of
XFS we have used radix trees, the extents being freed are at random
locations on disk so are better suited to being indexed by an rbtree.
So, use a per-AG rbtree indexed by block number to track busy
extents. This incures a memory allocation when marking an extent
busy, but should not occur too often in low memory situations. This
should scale to an arbitrary number of extents so should not be a
limitation for features such as in-memory aggregation of
transactions.
However, there are still situations where we can't avoid allocating
busy extents (such as allocation from the AGFL). To minimise the
overhead of such occurences, we need to avoid doing a synchronous
log force while holding the AGF locked to ensure that the previous
transactions are safely on disk before we use the extent. We can do
this by marking the transaction doing the allocation as synchronous
rather issuing a log force.
Because of the locking involved and the ordering of transactions,
the synchronous transaction provides the same guarantees as a
synchronous log force because it ensures that all the prior
transactions are already on disk when the synchronous transaction
hits the disk. i.e. it preserves the free->allocate order of the
extent correctly in recovery.
By doing this, we avoid holding the AGF locked while log writes are
in progress, hence reducing the length of time the lock is held and
therefore we increase the rate at which we can allocate and free
from the allocation group, thereby increasing overall throughput.
The only problem with this approach is that when a metadata buffer is
marked stale (e.g. a directory block is removed), then buffer remains
pinned and locked until the log goes to disk. The issue here is that
if that stale buffer is reallocated in a subsequent transaction, the
attempt to lock that buffer in the transaction will hang waiting
the log to go to disk to unlock and unpin the buffer. Hence if
someone tries to lock a pinned, stale, locked buffer we need to
push on the log to get it unlocked ASAP. Effectively we are trading
off a guaranteed log force for a much less common trigger for log
force to occur.
Ideally we should not reallocate busy extents. That is a much more
complex fix to the problem as it involves direct intervention in the
allocation btree searches in many places. This is left to a future
set of modifications.
Finally, now that we track busy extents in allocated memory, we
don't need the descriptors in the transaction structure to point to
them. We can replace the complex busy chunk infrastructure with a
simple linked list of busy extents. This allows us to remove a large
chunk of code, making the overall change a net reduction in code
size.
Signed-off-by: Dave Chinner <david@fromorbit.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 02:07:08 +00:00
|
|
|
INIT_LIST_HEAD(&tp->t_busy);
|
2006-06-09 07:11:55 +00:00
|
|
|
return tp;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-03-22 23:11:05 +00:00
|
|
|
/*
|
|
|
|
* Free the transaction structure. If there is more clean up
|
|
|
|
* to do when the structure is freed, add it here.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_trans_free(
|
xfs: Improve scalability of busy extent tracking
When we free a metadata extent, we record it in the per-AG busy
extent array so that it is not re-used before the freeing
transaction hits the disk. This array is fixed size, so when it
overflows we make further allocation transactions synchronous
because we cannot track more freed extents until those transactions
hit the disk and are completed. Under heavy mixed allocation and
freeing workloads with large log buffers, we can overflow this array
quite easily.
Further, the array is sparsely populated, which means that inserts
need to search for a free slot, and array searches often have to
search many more slots that are actually used to check all the
busy extents. Quite inefficient, really.
To enable this aspect of extent freeing to scale better, we need
a structure that can grow dynamically. While in other areas of
XFS we have used radix trees, the extents being freed are at random
locations on disk so are better suited to being indexed by an rbtree.
So, use a per-AG rbtree indexed by block number to track busy
extents. This incures a memory allocation when marking an extent
busy, but should not occur too often in low memory situations. This
should scale to an arbitrary number of extents so should not be a
limitation for features such as in-memory aggregation of
transactions.
However, there are still situations where we can't avoid allocating
busy extents (such as allocation from the AGFL). To minimise the
overhead of such occurences, we need to avoid doing a synchronous
log force while holding the AGF locked to ensure that the previous
transactions are safely on disk before we use the extent. We can do
this by marking the transaction doing the allocation as synchronous
rather issuing a log force.
Because of the locking involved and the ordering of transactions,
the synchronous transaction provides the same guarantees as a
synchronous log force because it ensures that all the prior
transactions are already on disk when the synchronous transaction
hits the disk. i.e. it preserves the free->allocate order of the
extent correctly in recovery.
By doing this, we avoid holding the AGF locked while log writes are
in progress, hence reducing the length of time the lock is held and
therefore we increase the rate at which we can allocate and free
from the allocation group, thereby increasing overall throughput.
The only problem with this approach is that when a metadata buffer is
marked stale (e.g. a directory block is removed), then buffer remains
pinned and locked until the log goes to disk. The issue here is that
if that stale buffer is reallocated in a subsequent transaction, the
attempt to lock that buffer in the transaction will hang waiting
the log to go to disk to unlock and unpin the buffer. Hence if
someone tries to lock a pinned, stale, locked buffer we need to
push on the log to get it unlocked ASAP. Effectively we are trading
off a guaranteed log force for a much less common trigger for log
force to occur.
Ideally we should not reallocate busy extents. That is a much more
complex fix to the problem as it involves direct intervention in the
allocation btree searches in many places. This is left to a future
set of modifications.
Finally, now that we track busy extents in allocated memory, we
don't need the descriptors in the transaction structure to point to
them. We can replace the complex busy chunk infrastructure with a
simple linked list of busy extents. This allows us to remove a large
chunk of code, making the overall change a net reduction in code
size.
Signed-off-by: Dave Chinner <david@fromorbit.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 02:07:08 +00:00
|
|
|
struct xfs_trans *tp)
|
2010-03-22 23:11:05 +00:00
|
|
|
{
|
2011-04-24 19:06:17 +00:00
|
|
|
xfs_alloc_busy_sort(&tp->t_busy);
|
2011-05-20 13:45:32 +00:00
|
|
|
xfs_alloc_busy_clear(tp->t_mountp, &tp->t_busy, false);
|
xfs: Improve scalability of busy extent tracking
When we free a metadata extent, we record it in the per-AG busy
extent array so that it is not re-used before the freeing
transaction hits the disk. This array is fixed size, so when it
overflows we make further allocation transactions synchronous
because we cannot track more freed extents until those transactions
hit the disk and are completed. Under heavy mixed allocation and
freeing workloads with large log buffers, we can overflow this array
quite easily.
Further, the array is sparsely populated, which means that inserts
need to search for a free slot, and array searches often have to
search many more slots that are actually used to check all the
busy extents. Quite inefficient, really.
To enable this aspect of extent freeing to scale better, we need
a structure that can grow dynamically. While in other areas of
XFS we have used radix trees, the extents being freed are at random
locations on disk so are better suited to being indexed by an rbtree.
So, use a per-AG rbtree indexed by block number to track busy
extents. This incures a memory allocation when marking an extent
busy, but should not occur too often in low memory situations. This
should scale to an arbitrary number of extents so should not be a
limitation for features such as in-memory aggregation of
transactions.
However, there are still situations where we can't avoid allocating
busy extents (such as allocation from the AGFL). To minimise the
overhead of such occurences, we need to avoid doing a synchronous
log force while holding the AGF locked to ensure that the previous
transactions are safely on disk before we use the extent. We can do
this by marking the transaction doing the allocation as synchronous
rather issuing a log force.
Because of the locking involved and the ordering of transactions,
the synchronous transaction provides the same guarantees as a
synchronous log force because it ensures that all the prior
transactions are already on disk when the synchronous transaction
hits the disk. i.e. it preserves the free->allocate order of the
extent correctly in recovery.
By doing this, we avoid holding the AGF locked while log writes are
in progress, hence reducing the length of time the lock is held and
therefore we increase the rate at which we can allocate and free
from the allocation group, thereby increasing overall throughput.
The only problem with this approach is that when a metadata buffer is
marked stale (e.g. a directory block is removed), then buffer remains
pinned and locked until the log goes to disk. The issue here is that
if that stale buffer is reallocated in a subsequent transaction, the
attempt to lock that buffer in the transaction will hang waiting
the log to go to disk to unlock and unpin the buffer. Hence if
someone tries to lock a pinned, stale, locked buffer we need to
push on the log to get it unlocked ASAP. Effectively we are trading
off a guaranteed log force for a much less common trigger for log
force to occur.
Ideally we should not reallocate busy extents. That is a much more
complex fix to the problem as it involves direct intervention in the
allocation btree searches in many places. This is left to a future
set of modifications.
Finally, now that we track busy extents in allocated memory, we
don't need the descriptors in the transaction structure to point to
them. We can replace the complex busy chunk infrastructure with a
simple linked list of busy extents. This allows us to remove a large
chunk of code, making the overall change a net reduction in code
size.
Signed-off-by: Dave Chinner <david@fromorbit.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 02:07:08 +00:00
|
|
|
|
2010-03-22 23:11:05 +00:00
|
|
|
atomic_dec(&tp->t_mountp->m_active_trans);
|
|
|
|
xfs_trans_free_dqinfo(tp);
|
|
|
|
kmem_zone_free(xfs_trans_zone, tp);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* This is called to create a new transaction which will share the
|
|
|
|
* permanent log reservation of the given transaction. The remaining
|
|
|
|
* unused block and rt extent reservations are also inherited. This
|
|
|
|
* implies that the original transaction is no longer allowed to allocate
|
|
|
|
* blocks. Locks and log items, however, are no inherited. They must
|
|
|
|
* be added to the new transaction explicitly.
|
|
|
|
*/
|
|
|
|
xfs_trans_t *
|
|
|
|
xfs_trans_dup(
|
|
|
|
xfs_trans_t *tp)
|
|
|
|
{
|
|
|
|
xfs_trans_t *ntp;
|
|
|
|
|
|
|
|
ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize the new transaction structure.
|
|
|
|
*/
|
|
|
|
ntp->t_magic = XFS_TRANS_MAGIC;
|
|
|
|
ntp->t_type = tp->t_type;
|
|
|
|
ntp->t_mountp = tp->t_mountp;
|
2010-06-23 08:11:15 +00:00
|
|
|
INIT_LIST_HEAD(&ntp->t_items);
|
xfs: Improve scalability of busy extent tracking
When we free a metadata extent, we record it in the per-AG busy
extent array so that it is not re-used before the freeing
transaction hits the disk. This array is fixed size, so when it
overflows we make further allocation transactions synchronous
because we cannot track more freed extents until those transactions
hit the disk and are completed. Under heavy mixed allocation and
freeing workloads with large log buffers, we can overflow this array
quite easily.
Further, the array is sparsely populated, which means that inserts
need to search for a free slot, and array searches often have to
search many more slots that are actually used to check all the
busy extents. Quite inefficient, really.
To enable this aspect of extent freeing to scale better, we need
a structure that can grow dynamically. While in other areas of
XFS we have used radix trees, the extents being freed are at random
locations on disk so are better suited to being indexed by an rbtree.
So, use a per-AG rbtree indexed by block number to track busy
extents. This incures a memory allocation when marking an extent
busy, but should not occur too often in low memory situations. This
should scale to an arbitrary number of extents so should not be a
limitation for features such as in-memory aggregation of
transactions.
However, there are still situations where we can't avoid allocating
busy extents (such as allocation from the AGFL). To minimise the
overhead of such occurences, we need to avoid doing a synchronous
log force while holding the AGF locked to ensure that the previous
transactions are safely on disk before we use the extent. We can do
this by marking the transaction doing the allocation as synchronous
rather issuing a log force.
Because of the locking involved and the ordering of transactions,
the synchronous transaction provides the same guarantees as a
synchronous log force because it ensures that all the prior
transactions are already on disk when the synchronous transaction
hits the disk. i.e. it preserves the free->allocate order of the
extent correctly in recovery.
By doing this, we avoid holding the AGF locked while log writes are
in progress, hence reducing the length of time the lock is held and
therefore we increase the rate at which we can allocate and free
from the allocation group, thereby increasing overall throughput.
The only problem with this approach is that when a metadata buffer is
marked stale (e.g. a directory block is removed), then buffer remains
pinned and locked until the log goes to disk. The issue here is that
if that stale buffer is reallocated in a subsequent transaction, the
attempt to lock that buffer in the transaction will hang waiting
the log to go to disk to unlock and unpin the buffer. Hence if
someone tries to lock a pinned, stale, locked buffer we need to
push on the log to get it unlocked ASAP. Effectively we are trading
off a guaranteed log force for a much less common trigger for log
force to occur.
Ideally we should not reallocate busy extents. That is a much more
complex fix to the problem as it involves direct intervention in the
allocation btree searches in many places. This is left to a future
set of modifications.
Finally, now that we track busy extents in allocated memory, we
don't need the descriptors in the transaction structure to point to
them. We can replace the complex busy chunk infrastructure with a
simple linked list of busy extents. This allows us to remove a large
chunk of code, making the overall change a net reduction in code
size.
Signed-off-by: Dave Chinner <david@fromorbit.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 02:07:08 +00:00
|
|
|
INIT_LIST_HEAD(&ntp->t_busy);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
|
|
|
|
ASSERT(tp->t_ticket != NULL);
|
2005-11-02 04:12:04 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ntp->t_flags = XFS_TRANS_PERM_LOG_RES | (tp->t_flags & XFS_TRANS_RESERVE);
|
2008-11-17 06:37:10 +00:00
|
|
|
ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
|
2005-04-16 22:20:36 +00:00
|
|
|
ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
|
|
|
|
tp->t_blk_res = tp->t_blk_res_used;
|
|
|
|
ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
|
|
|
|
tp->t_rtx_res = tp->t_rtx_res_used;
|
2006-06-09 04:59:13 +00:00
|
|
|
ntp->t_pflags = tp->t_pflags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-08 13:33:32 +00:00
|
|
|
xfs_trans_dup_dqinfo(tp, ntp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
atomic_inc(&tp->t_mountp->m_active_trans);
|
|
|
|
return ntp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called to reserve free disk blocks and log space for the
|
|
|
|
* given transaction. This must be done before allocating any resources
|
|
|
|
* within the transaction.
|
|
|
|
*
|
|
|
|
* This will return ENOSPC if there are not enough blocks available.
|
|
|
|
* It will sleep waiting for available log space.
|
|
|
|
* The only valid value for the flags parameter is XFS_RES_LOG_PERM, which
|
|
|
|
* is used by long running transactions. If any one of the reservations
|
|
|
|
* fails then they will all be backed out.
|
|
|
|
*
|
|
|
|
* This does not do quota reservations. That typically is done by the
|
|
|
|
* caller afterwards.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_trans_reserve(
|
|
|
|
xfs_trans_t *tp,
|
|
|
|
uint blocks,
|
|
|
|
uint logspace,
|
|
|
|
uint rtextents,
|
|
|
|
uint flags,
|
|
|
|
uint logcount)
|
|
|
|
{
|
|
|
|
int log_flags;
|
2006-06-09 04:59:13 +00:00
|
|
|
int error = 0;
|
|
|
|
int rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Mark this thread as being in a transaction */
|
2006-06-09 04:59:13 +00:00
|
|
|
current_set_flags_nested(&tp->t_pflags, PF_FSTRANS);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to reserve the needed disk blocks by decrementing
|
|
|
|
* the number needed from the number available. This will
|
|
|
|
* fail if the count would go below zero.
|
|
|
|
*/
|
|
|
|
if (blocks > 0) {
|
2010-09-30 02:25:55 +00:00
|
|
|
error = xfs_icsb_modify_counters(tp->t_mountp, XFS_SBS_FDBLOCKS,
|
2007-02-10 07:36:10 +00:00
|
|
|
-((int64_t)blocks), rsvd);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (error != 0) {
|
2006-06-09 04:59:13 +00:00
|
|
|
current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
|
2005-04-16 22:20:36 +00:00
|
|
|
return (XFS_ERROR(ENOSPC));
|
|
|
|
}
|
|
|
|
tp->t_blk_res += blocks;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reserve the log space needed for this transaction.
|
|
|
|
*/
|
|
|
|
if (logspace > 0) {
|
|
|
|
ASSERT((tp->t_log_res == 0) || (tp->t_log_res == logspace));
|
|
|
|
ASSERT((tp->t_log_count == 0) ||
|
|
|
|
(tp->t_log_count == logcount));
|
|
|
|
if (flags & XFS_TRANS_PERM_LOG_RES) {
|
|
|
|
log_flags = XFS_LOG_PERM_RESERV;
|
|
|
|
tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
|
|
|
|
} else {
|
|
|
|
ASSERT(tp->t_ticket == NULL);
|
|
|
|
ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
|
|
|
|
log_flags = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = xfs_log_reserve(tp->t_mountp, logspace, logcount,
|
|
|
|
&tp->t_ticket,
|
2005-09-02 06:42:05 +00:00
|
|
|
XFS_TRANSACTION, log_flags, tp->t_type);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (error) {
|
|
|
|
goto undo_blocks;
|
|
|
|
}
|
|
|
|
tp->t_log_res = logspace;
|
|
|
|
tp->t_log_count = logcount;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to reserve the needed realtime extents by decrementing
|
|
|
|
* the number needed from the number available. This will
|
|
|
|
* fail if the count would go below zero.
|
|
|
|
*/
|
|
|
|
if (rtextents > 0) {
|
|
|
|
error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FREXTENTS,
|
2007-02-10 07:36:10 +00:00
|
|
|
-((int64_t)rtextents), rsvd);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (error) {
|
|
|
|
error = XFS_ERROR(ENOSPC);
|
|
|
|
goto undo_log;
|
|
|
|
}
|
|
|
|
tp->t_rtx_res += rtextents;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Error cases jump to one of these labels to undo any
|
|
|
|
* reservations which have already been performed.
|
|
|
|
*/
|
|
|
|
undo_log:
|
|
|
|
if (logspace > 0) {
|
|
|
|
if (flags & XFS_TRANS_PERM_LOG_RES) {
|
|
|
|
log_flags = XFS_LOG_REL_PERM_RESERV;
|
|
|
|
} else {
|
|
|
|
log_flags = 0;
|
|
|
|
}
|
|
|
|
xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, log_flags);
|
|
|
|
tp->t_ticket = NULL;
|
|
|
|
tp->t_log_res = 0;
|
|
|
|
tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
|
|
|
|
}
|
|
|
|
|
|
|
|
undo_blocks:
|
|
|
|
if (blocks > 0) {
|
2010-09-30 02:25:55 +00:00
|
|
|
xfs_icsb_modify_counters(tp->t_mountp, XFS_SBS_FDBLOCKS,
|
2007-02-10 07:36:10 +00:00
|
|
|
(int64_t)blocks, rsvd);
|
2005-04-16 22:20:36 +00:00
|
|
|
tp->t_blk_res = 0;
|
|
|
|
}
|
|
|
|
|
2006-06-09 04:59:13 +00:00
|
|
|
current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-09 04:59:13 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Record the indicated change to the given field for application
|
|
|
|
* to the file system's superblock when the transaction commits.
|
|
|
|
* For now, just store the change in the transaction structure.
|
|
|
|
*
|
|
|
|
* Mark the transaction structure to indicate that the superblock
|
|
|
|
* needs to be updated before committing.
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 05:26:31 +00:00
|
|
|
*
|
|
|
|
* Because we may not be keeping track of allocated/free inodes and
|
|
|
|
* used filesystem blocks in the superblock, we do not mark the
|
|
|
|
* superblock dirty in this transaction if we modify these fields.
|
|
|
|
* We still need to update the transaction deltas so that they get
|
|
|
|
* applied to the incore superblock, but we don't want them to
|
|
|
|
* cause the superblock to get locked and logged if these are the
|
|
|
|
* only fields in the superblock that the transaction modifies.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_mod_sb(
|
|
|
|
xfs_trans_t *tp,
|
|
|
|
uint field,
|
2007-02-10 07:36:10 +00:00
|
|
|
int64_t delta)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 05:26:31 +00:00
|
|
|
uint32_t flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
|
|
|
|
xfs_mount_t *mp = tp->t_mountp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
switch (field) {
|
|
|
|
case XFS_TRANS_SB_ICOUNT:
|
|
|
|
tp->t_icount_delta += delta;
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 05:26:31 +00:00
|
|
|
if (xfs_sb_version_haslazysbcount(&mp->m_sb))
|
|
|
|
flags &= ~XFS_TRANS_SB_DIRTY;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_IFREE:
|
|
|
|
tp->t_ifree_delta += delta;
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 05:26:31 +00:00
|
|
|
if (xfs_sb_version_haslazysbcount(&mp->m_sb))
|
|
|
|
flags &= ~XFS_TRANS_SB_DIRTY;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_FDBLOCKS:
|
|
|
|
/*
|
|
|
|
* Track the number of blocks allocated in the
|
|
|
|
* transaction. Make sure it does not exceed the
|
|
|
|
* number reserved.
|
|
|
|
*/
|
|
|
|
if (delta < 0) {
|
|
|
|
tp->t_blk_res_used += (uint)-delta;
|
|
|
|
ASSERT(tp->t_blk_res_used <= tp->t_blk_res);
|
|
|
|
}
|
|
|
|
tp->t_fdblocks_delta += delta;
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 05:26:31 +00:00
|
|
|
if (xfs_sb_version_haslazysbcount(&mp->m_sb))
|
|
|
|
flags &= ~XFS_TRANS_SB_DIRTY;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_RES_FDBLOCKS:
|
|
|
|
/*
|
|
|
|
* The allocation has already been applied to the
|
|
|
|
* in-core superblock's counter. This should only
|
|
|
|
* be applied to the on-disk superblock.
|
|
|
|
*/
|
|
|
|
ASSERT(delta < 0);
|
|
|
|
tp->t_res_fdblocks_delta += delta;
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 05:26:31 +00:00
|
|
|
if (xfs_sb_version_haslazysbcount(&mp->m_sb))
|
|
|
|
flags &= ~XFS_TRANS_SB_DIRTY;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_FREXTENTS:
|
|
|
|
/*
|
|
|
|
* Track the number of blocks allocated in the
|
|
|
|
* transaction. Make sure it does not exceed the
|
|
|
|
* number reserved.
|
|
|
|
*/
|
|
|
|
if (delta < 0) {
|
|
|
|
tp->t_rtx_res_used += (uint)-delta;
|
|
|
|
ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res);
|
|
|
|
}
|
|
|
|
tp->t_frextents_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_RES_FREXTENTS:
|
|
|
|
/*
|
|
|
|
* The allocation has already been applied to the
|
2006-03-28 22:55:14 +00:00
|
|
|
* in-core superblock's counter. This should only
|
2005-04-16 22:20:36 +00:00
|
|
|
* be applied to the on-disk superblock.
|
|
|
|
*/
|
|
|
|
ASSERT(delta < 0);
|
|
|
|
tp->t_res_frextents_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_DBLOCKS:
|
|
|
|
ASSERT(delta > 0);
|
|
|
|
tp->t_dblocks_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_AGCOUNT:
|
|
|
|
ASSERT(delta > 0);
|
|
|
|
tp->t_agcount_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_IMAXPCT:
|
|
|
|
tp->t_imaxpct_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_REXTSIZE:
|
|
|
|
tp->t_rextsize_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_RBMBLOCKS:
|
|
|
|
tp->t_rbmblocks_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_RBLOCKS:
|
|
|
|
tp->t_rblocks_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_REXTENTS:
|
|
|
|
tp->t_rextents_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_REXTSLOG:
|
|
|
|
tp->t_rextslog_delta += delta;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ASSERT(0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-05-24 05:26:51 +00:00
|
|
|
tp->t_flags |= flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xfs_trans_apply_sb_deltas() is called from the commit code
|
|
|
|
* to bring the superblock buffer into the current transaction
|
|
|
|
* and modify it as requested by earlier calls to xfs_trans_mod_sb().
|
|
|
|
*
|
|
|
|
* For now we just look at each field allowed to change and change
|
|
|
|
* it if necessary.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_trans_apply_sb_deltas(
|
|
|
|
xfs_trans_t *tp)
|
|
|
|
{
|
2007-08-28 03:58:06 +00:00
|
|
|
xfs_dsb_t *sbp;
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_buf_t *bp;
|
|
|
|
int whole = 0;
|
|
|
|
|
|
|
|
bp = xfs_trans_getsb(tp, tp->t_mountp, 0);
|
|
|
|
sbp = XFS_BUF_TO_SBP(bp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check that superblock mods match the mods made to AGF counters.
|
|
|
|
*/
|
|
|
|
ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) ==
|
|
|
|
(tp->t_ag_freeblks_delta + tp->t_ag_flist_delta +
|
|
|
|
tp->t_ag_btree_delta));
|
|
|
|
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 05:26:31 +00:00
|
|
|
/*
|
|
|
|
* Only update the superblock counters if we are logging them
|
|
|
|
*/
|
|
|
|
if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) {
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_icount_delta)
|
2008-02-13 23:03:29 +00:00
|
|
|
be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_ifree_delta)
|
2008-02-13 23:03:29 +00:00
|
|
|
be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_fdblocks_delta)
|
2008-02-13 23:03:29 +00:00
|
|
|
be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_res_fdblocks_delta)
|
2008-02-13 23:03:29 +00:00
|
|
|
be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_frextents_delta)
|
2008-02-13 23:03:29 +00:00
|
|
|
be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta);
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_res_frextents_delta)
|
2008-02-13 23:03:29 +00:00
|
|
|
be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta);
|
2007-08-28 03:58:06 +00:00
|
|
|
|
|
|
|
if (tp->t_dblocks_delta) {
|
2008-02-13 23:03:29 +00:00
|
|
|
be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
|
2005-04-16 22:20:36 +00:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_agcount_delta) {
|
2008-02-13 23:03:29 +00:00
|
|
|
be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
|
2005-04-16 22:20:36 +00:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_imaxpct_delta) {
|
|
|
|
sbp->sb_imax_pct += tp->t_imaxpct_delta;
|
2005-04-16 22:20:36 +00:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_rextsize_delta) {
|
2008-02-13 23:03:29 +00:00
|
|
|
be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
|
2005-04-16 22:20:36 +00:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_rbmblocks_delta) {
|
2008-02-13 23:03:29 +00:00
|
|
|
be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
|
2005-04-16 22:20:36 +00:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_rblocks_delta) {
|
2008-02-13 23:03:29 +00:00
|
|
|
be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
|
2005-04-16 22:20:36 +00:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_rextents_delta) {
|
2008-02-13 23:03:29 +00:00
|
|
|
be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
|
2005-04-16 22:20:36 +00:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 03:58:06 +00:00
|
|
|
if (tp->t_rextslog_delta) {
|
|
|
|
sbp->sb_rextslog += tp->t_rextslog_delta;
|
2005-04-16 22:20:36 +00:00
|
|
|
whole = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (whole)
|
|
|
|
/*
|
2006-03-28 22:55:14 +00:00
|
|
|
* Log the whole thing, the fields are noncontiguous.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2007-08-28 03:58:06 +00:00
|
|
|
xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
|
|
|
/*
|
|
|
|
* Since all the modifiable fields are contiguous, we
|
|
|
|
* can get away with this.
|
|
|
|
*/
|
2007-08-28 03:58:06 +00:00
|
|
|
xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount),
|
|
|
|
offsetof(xfs_dsb_t, sb_frextents) +
|
2005-04-16 22:20:36 +00:00
|
|
|
sizeof(sbp->sb_frextents) - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-06-18 06:49:44 +00:00
|
|
|
* xfs_trans_unreserve_and_mod_sb() is called to release unused reservations
|
|
|
|
* and apply superblock counter changes to the in-core superblock. The
|
|
|
|
* t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT
|
|
|
|
* applied to the in-core superblock. The idea is that that has already been
|
|
|
|
* done.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* This is done efficiently with a single call to xfs_mod_incore_sb_batch().
|
2007-06-18 06:49:44 +00:00
|
|
|
* However, we have to ensure that we only modify each superblock field only
|
|
|
|
* once because the application of the delta values may not be atomic. That can
|
|
|
|
* lead to ENOSPC races occurring if we have two separate modifcations of the
|
|
|
|
* free space counter to put back the entire reservation and then take away
|
|
|
|
* what we used.
|
|
|
|
*
|
|
|
|
* If we are not logging superblock counters, then the inode allocated/free and
|
|
|
|
* used block counts are not updated in the on disk superblock. In this case,
|
|
|
|
* XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we
|
|
|
|
* still need to update the incore superblock with the changes.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
void
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_trans_unreserve_and_mod_sb(
|
|
|
|
xfs_trans_t *tp)
|
|
|
|
{
|
2010-09-30 02:25:56 +00:00
|
|
|
xfs_mod_sb_t msb[9]; /* If you add cases, add entries */
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_mod_sb_t *msbp;
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 05:26:31 +00:00
|
|
|
xfs_mount_t *mp = tp->t_mountp;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* REFERENCED */
|
|
|
|
int error;
|
|
|
|
int rsvd;
|
2007-06-18 06:49:44 +00:00
|
|
|
int64_t blkdelta = 0;
|
|
|
|
int64_t rtxdelta = 0;
|
2010-09-30 02:25:56 +00:00
|
|
|
int64_t idelta = 0;
|
|
|
|
int64_t ifreedelta = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
msbp = msb;
|
|
|
|
rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
|
|
|
|
|
2010-09-30 02:25:56 +00:00
|
|
|
/* calculate deltas */
|
2007-06-18 06:49:44 +00:00
|
|
|
if (tp->t_blk_res > 0)
|
|
|
|
blkdelta = tp->t_blk_res;
|
|
|
|
if ((tp->t_fdblocks_delta != 0) &&
|
|
|
|
(xfs_sb_version_haslazysbcount(&mp->m_sb) ||
|
|
|
|
(tp->t_flags & XFS_TRANS_SB_DIRTY)))
|
|
|
|
blkdelta += tp->t_fdblocks_delta;
|
|
|
|
|
|
|
|
if (tp->t_rtx_res > 0)
|
|
|
|
rtxdelta = tp->t_rtx_res;
|
|
|
|
if ((tp->t_frextents_delta != 0) &&
|
|
|
|
(tp->t_flags & XFS_TRANS_SB_DIRTY))
|
|
|
|
rtxdelta += tp->t_frextents_delta;
|
|
|
|
|
2010-09-30 02:25:56 +00:00
|
|
|
if (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
|
|
|
|
(tp->t_flags & XFS_TRANS_SB_DIRTY)) {
|
|
|
|
idelta = tp->t_icount_delta;
|
|
|
|
ifreedelta = tp->t_ifree_delta;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* apply the per-cpu counters */
|
|
|
|
if (blkdelta) {
|
|
|
|
error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
|
|
|
|
blkdelta, rsvd);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (idelta) {
|
|
|
|
error = xfs_icsb_modify_counters(mp, XFS_SBS_ICOUNT,
|
|
|
|
idelta, rsvd);
|
|
|
|
if (error)
|
|
|
|
goto out_undo_fdblocks;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ifreedelta) {
|
|
|
|
error = xfs_icsb_modify_counters(mp, XFS_SBS_IFREE,
|
|
|
|
ifreedelta, rsvd);
|
|
|
|
if (error)
|
|
|
|
goto out_undo_icount;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* apply remaining deltas */
|
2007-06-18 06:49:44 +00:00
|
|
|
if (rtxdelta != 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
msbp->msb_field = XFS_SBS_FREXTENTS;
|
2007-06-18 06:49:44 +00:00
|
|
|
msbp->msb_delta = rtxdelta;
|
2005-04-16 22:20:36 +00:00
|
|
|
msbp++;
|
|
|
|
}
|
|
|
|
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 05:26:31 +00:00
|
|
|
if (tp->t_flags & XFS_TRANS_SB_DIRTY) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (tp->t_dblocks_delta != 0) {
|
|
|
|
msbp->msb_field = XFS_SBS_DBLOCKS;
|
2007-02-10 07:36:10 +00:00
|
|
|
msbp->msb_delta = tp->t_dblocks_delta;
|
2005-04-16 22:20:36 +00:00
|
|
|
msbp++;
|
|
|
|
}
|
|
|
|
if (tp->t_agcount_delta != 0) {
|
|
|
|
msbp->msb_field = XFS_SBS_AGCOUNT;
|
2007-02-10 07:36:10 +00:00
|
|
|
msbp->msb_delta = tp->t_agcount_delta;
|
2005-04-16 22:20:36 +00:00
|
|
|
msbp++;
|
|
|
|
}
|
|
|
|
if (tp->t_imaxpct_delta != 0) {
|
|
|
|
msbp->msb_field = XFS_SBS_IMAX_PCT;
|
2007-02-10 07:36:10 +00:00
|
|
|
msbp->msb_delta = tp->t_imaxpct_delta;
|
2005-04-16 22:20:36 +00:00
|
|
|
msbp++;
|
|
|
|
}
|
|
|
|
if (tp->t_rextsize_delta != 0) {
|
|
|
|
msbp->msb_field = XFS_SBS_REXTSIZE;
|
2007-02-10 07:36:10 +00:00
|
|
|
msbp->msb_delta = tp->t_rextsize_delta;
|
2005-04-16 22:20:36 +00:00
|
|
|
msbp++;
|
|
|
|
}
|
|
|
|
if (tp->t_rbmblocks_delta != 0) {
|
|
|
|
msbp->msb_field = XFS_SBS_RBMBLOCKS;
|
2007-02-10 07:36:10 +00:00
|
|
|
msbp->msb_delta = tp->t_rbmblocks_delta;
|
2005-04-16 22:20:36 +00:00
|
|
|
msbp++;
|
|
|
|
}
|
|
|
|
if (tp->t_rblocks_delta != 0) {
|
|
|
|
msbp->msb_field = XFS_SBS_RBLOCKS;
|
2007-02-10 07:36:10 +00:00
|
|
|
msbp->msb_delta = tp->t_rblocks_delta;
|
2005-04-16 22:20:36 +00:00
|
|
|
msbp++;
|
|
|
|
}
|
|
|
|
if (tp->t_rextents_delta != 0) {
|
|
|
|
msbp->msb_field = XFS_SBS_REXTENTS;
|
2007-02-10 07:36:10 +00:00
|
|
|
msbp->msb_delta = tp->t_rextents_delta;
|
2005-04-16 22:20:36 +00:00
|
|
|
msbp++;
|
|
|
|
}
|
|
|
|
if (tp->t_rextslog_delta != 0) {
|
|
|
|
msbp->msb_field = XFS_SBS_REXTSLOG;
|
2007-02-10 07:36:10 +00:00
|
|
|
msbp->msb_delta = tp->t_rextslog_delta;
|
2005-04-16 22:20:36 +00:00
|
|
|
msbp++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we need to change anything, do it.
|
|
|
|
*/
|
|
|
|
if (msbp > msb) {
|
|
|
|
error = xfs_mod_incore_sb_batch(tp->t_mountp, msb,
|
|
|
|
(uint)(msbp - msb), rsvd);
|
2010-09-30 02:25:56 +00:00
|
|
|
if (error)
|
|
|
|
goto out_undo_ifreecount;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2010-09-30 02:25:56 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
out_undo_ifreecount:
|
|
|
|
if (ifreedelta)
|
|
|
|
xfs_icsb_modify_counters(mp, XFS_SBS_IFREE, -ifreedelta, rsvd);
|
|
|
|
out_undo_icount:
|
|
|
|
if (idelta)
|
|
|
|
xfs_icsb_modify_counters(mp, XFS_SBS_ICOUNT, -idelta, rsvd);
|
|
|
|
out_undo_fdblocks:
|
|
|
|
if (blkdelta)
|
|
|
|
xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS, -blkdelta, rsvd);
|
|
|
|
out:
|
2010-12-25 20:14:53 +00:00
|
|
|
ASSERT(error == 0);
|
2010-09-30 02:25:56 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-06-23 08:11:15 +00:00
|
|
|
/*
|
|
|
|
* Add the given log item to the transaction's list of log items.
|
|
|
|
*
|
|
|
|
* The log item will now point to its new descriptor with its li_desc field.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_add_item(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
struct xfs_log_item_desc *lidp;
|
|
|
|
|
|
|
|
ASSERT(lip->li_mountp = tp->t_mountp);
|
|
|
|
ASSERT(lip->li_ailp = tp->t_mountp->m_ail);
|
|
|
|
|
2010-07-20 07:53:44 +00:00
|
|
|
lidp = kmem_zone_zalloc(xfs_log_item_desc_zone, KM_SLEEP | KM_NOFS);
|
2010-06-23 08:11:15 +00:00
|
|
|
|
|
|
|
lidp->lid_item = lip;
|
|
|
|
lidp->lid_flags = 0;
|
|
|
|
lidp->lid_size = 0;
|
|
|
|
list_add_tail(&lidp->lid_trans, &tp->t_items);
|
|
|
|
|
|
|
|
lip->li_desc = lidp;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC void
|
|
|
|
xfs_trans_free_item_desc(
|
|
|
|
struct xfs_log_item_desc *lidp)
|
|
|
|
{
|
|
|
|
list_del_init(&lidp->lid_trans);
|
|
|
|
kmem_zone_free(xfs_log_item_desc_zone, lidp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unlink and free the given descriptor.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_del_item(
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
xfs_trans_free_item_desc(lip->li_desc);
|
|
|
|
lip->li_desc = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unlock all of the items of a transaction and free all the descriptors
|
|
|
|
* of that transaction.
|
|
|
|
*/
|
2010-08-24 01:42:52 +00:00
|
|
|
void
|
2010-06-23 08:11:15 +00:00
|
|
|
xfs_trans_free_items(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
xfs_lsn_t commit_lsn,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
struct xfs_log_item_desc *lidp, *next;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(lidp, next, &tp->t_items, lid_trans) {
|
|
|
|
struct xfs_log_item *lip = lidp->lid_item;
|
|
|
|
|
|
|
|
lip->li_desc = NULL;
|
|
|
|
|
|
|
|
if (commit_lsn != NULLCOMMITLSN)
|
|
|
|
IOP_COMMITTING(lip, commit_lsn);
|
|
|
|
if (flags & XFS_TRANS_ABORT)
|
|
|
|
lip->li_flags |= XFS_LI_ABORTED;
|
|
|
|
IOP_UNLOCK(lip);
|
|
|
|
|
|
|
|
xfs_trans_free_item_desc(lidp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unlock the items associated with a transaction.
|
|
|
|
*
|
|
|
|
* Items which were not logged should be freed. Those which were logged must
|
|
|
|
* still be tracked so they can be unpinned when the transaction commits.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_trans_unlock_items(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
xfs_lsn_t commit_lsn)
|
|
|
|
{
|
|
|
|
struct xfs_log_item_desc *lidp, *next;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(lidp, next, &tp->t_items, lid_trans) {
|
|
|
|
struct xfs_log_item *lip = lidp->lid_item;
|
|
|
|
|
|
|
|
lip->li_desc = NULL;
|
|
|
|
|
|
|
|
if (commit_lsn != NULLCOMMITLSN)
|
|
|
|
IOP_COMMITTING(lip, commit_lsn);
|
|
|
|
IOP_UNLOCK(lip);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free the descriptor if the item is not dirty
|
|
|
|
* within this transaction.
|
|
|
|
*/
|
|
|
|
if (!(lidp->lid_flags & XFS_LID_DIRTY))
|
|
|
|
xfs_trans_free_item_desc(lidp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2010-03-08 00:28:28 +00:00
|
|
|
* Total up the number of log iovecs needed to commit this
|
|
|
|
* transaction. The transaction itself needs one for the
|
|
|
|
* transaction header. Ask each dirty item in turn how many
|
|
|
|
* it needs to get the total.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2010-03-08 00:28:28 +00:00
|
|
|
static uint
|
|
|
|
xfs_trans_count_vecs(
|
2010-03-22 23:11:05 +00:00
|
|
|
struct xfs_trans *tp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-03-08 00:28:28 +00:00
|
|
|
int nvecs;
|
2010-06-23 08:11:15 +00:00
|
|
|
struct xfs_log_item_desc *lidp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-03-08 00:28:28 +00:00
|
|
|
nvecs = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-03-08 00:28:28 +00:00
|
|
|
/* In the non-debug case we need to start bailing out if we
|
|
|
|
* didn't find a log_item here, return zero and let trans_commit
|
|
|
|
* deal with it.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2010-06-23 08:11:15 +00:00
|
|
|
if (list_empty(&tp->t_items)) {
|
|
|
|
ASSERT(0);
|
2010-03-08 00:28:28 +00:00
|
|
|
return 0;
|
2010-06-23 08:11:15 +00:00
|
|
|
}
|
2010-03-08 00:28:28 +00:00
|
|
|
|
2010-06-23 08:11:15 +00:00
|
|
|
list_for_each_entry(lidp, &tp->t_items, lid_trans) {
|
2010-03-08 00:28:28 +00:00
|
|
|
/*
|
|
|
|
* Skip items which aren't dirty in this transaction.
|
|
|
|
*/
|
2010-06-23 08:11:15 +00:00
|
|
|
if (!(lidp->lid_flags & XFS_LID_DIRTY))
|
2010-03-08 00:28:28 +00:00
|
|
|
continue;
|
|
|
|
lidp->lid_size = IOP_SIZE(lidp->lid_item);
|
|
|
|
nvecs += lidp->lid_size;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2010-03-08 00:28:28 +00:00
|
|
|
|
|
|
|
return nvecs;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill in the vector with pointers to data to be logged
|
|
|
|
* by this transaction. The transaction header takes
|
|
|
|
* the first vector, and then each dirty item takes the
|
|
|
|
* number of vectors it indicated it needed in xfs_trans_count_vecs().
|
|
|
|
*
|
|
|
|
* As each item fills in the entries it needs, also pin the item
|
|
|
|
* so that it cannot be flushed out until the log write completes.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
xfs_trans_fill_vecs(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_log_iovec *log_vector)
|
|
|
|
{
|
2010-06-23 08:11:15 +00:00
|
|
|
struct xfs_log_item_desc *lidp;
|
2010-03-08 00:28:28 +00:00
|
|
|
struct xfs_log_iovec *vecp;
|
|
|
|
uint nitems;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2010-03-08 00:28:28 +00:00
|
|
|
* Skip over the entry for the transaction header, we'll
|
|
|
|
* fill that in at the end.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2010-03-08 00:28:28 +00:00
|
|
|
vecp = log_vector + 1;
|
|
|
|
|
|
|
|
nitems = 0;
|
2010-06-23 08:11:15 +00:00
|
|
|
ASSERT(!list_empty(&tp->t_items));
|
|
|
|
list_for_each_entry(lidp, &tp->t_items, lid_trans) {
|
2010-03-08 00:28:28 +00:00
|
|
|
/* Skip items which aren't dirty in this transaction. */
|
2010-06-23 08:11:15 +00:00
|
|
|
if (!(lidp->lid_flags & XFS_LID_DIRTY))
|
2010-03-08 00:28:28 +00:00
|
|
|
continue;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2010-03-08 00:28:28 +00:00
|
|
|
* The item may be marked dirty but not log anything. This can
|
|
|
|
* be used to get called when a transaction is committed.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2010-03-08 00:28:28 +00:00
|
|
|
if (lidp->lid_size)
|
|
|
|
nitems++;
|
|
|
|
IOP_FORMAT(lidp->lid_item, vecp);
|
|
|
|
vecp += lidp->lid_size;
|
|
|
|
IOP_PIN(lidp->lid_item);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-03-08 00:28:28 +00:00
|
|
|
* Now that we've counted the number of items in this transaction, fill
|
|
|
|
* in the transaction header. Note that the transaction header does not
|
|
|
|
* have a log item.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2010-03-08 00:28:28 +00:00
|
|
|
tp->t_header.th_magic = XFS_TRANS_HEADER_MAGIC;
|
|
|
|
tp->t_header.th_type = tp->t_type;
|
|
|
|
tp->t_header.th_num_items = nitems;
|
|
|
|
log_vector->i_addr = (xfs_caddr_t)&tp->t_header;
|
|
|
|
log_vector->i_len = sizeof(xfs_trans_header_t);
|
|
|
|
log_vector->i_type = XLOG_REG_TYPE_TRANSHDR;
|
|
|
|
}
|
|
|
|
|
2010-03-22 23:11:05 +00:00
|
|
|
/*
|
|
|
|
* The committed item processing consists of calling the committed routine of
|
|
|
|
* each logged item, updating the item's position in the AIL if necessary, and
|
|
|
|
* unpinning each item. If the committed routine returns -1, then do nothing
|
|
|
|
* further with the item because it may have been freed.
|
|
|
|
*
|
|
|
|
* Since items are unlocked when they are copied to the incore log, it is
|
|
|
|
* possible for two transactions to be completing and manipulating the same
|
|
|
|
* item simultaneously. The AIL lock will protect the lsn field of each item.
|
|
|
|
* The value of this field can never go backwards.
|
|
|
|
*
|
|
|
|
* We unpin the items after repositioning them in the AIL, because otherwise
|
|
|
|
* they could be immediately flushed and we'd have to race with the flusher
|
|
|
|
* trying to pull the item from the AIL as we add it.
|
|
|
|
*/
|
2010-12-20 01:02:19 +00:00
|
|
|
static void
|
2010-03-22 23:11:05 +00:00
|
|
|
xfs_trans_item_committed(
|
|
|
|
struct xfs_log_item *lip,
|
|
|
|
xfs_lsn_t commit_lsn,
|
|
|
|
int aborted)
|
|
|
|
{
|
|
|
|
xfs_lsn_t item_lsn;
|
|
|
|
struct xfs_ail *ailp;
|
|
|
|
|
|
|
|
if (aborted)
|
|
|
|
lip->li_flags |= XFS_LI_ABORTED;
|
|
|
|
item_lsn = IOP_COMMITTED(lip, commit_lsn);
|
|
|
|
|
xfs: unpin stale inodes directly in IOP_COMMITTED
When inodes are marked stale in a transaction, they are treated
specially when the inode log item is being inserted into the AIL.
It tries to avoid moving the log item forward in the AIL due to a
race condition with the writing the underlying buffer back to disk.
The was "fixed" in commit de25c18 ("xfs: avoid moving stale inodes
in the AIL").
To avoid moving the item forward, we return a LSN smaller than the
commit_lsn of the completing transaction, thereby trying to trick
the commit code into not moving the inode forward at all. I'm not
sure this ever worked as intended - it assumes the inode is already
in the AIL, but I don't think the returned LSN would have been small
enough to prevent moving the inode. It appears that the reason it
worked is that the lower LSN of the inodes meant they were inserted
into the AIL and flushed before the inode buffer (which was moved to
the commit_lsn of the transaction).
The big problem is that with delayed logging, the returning of the
different LSN means insertion takes the slow, non-bulk path. Worse
yet is that insertion is to a position -before- the commit_lsn so it
is doing a AIL traversal on every insertion, and has to walk over
all the items that have already been inserted into the AIL. It's
expensive.
To compound the matter further, with delayed logging inodes are
likely to go from clean to stale in a single checkpoint, which means
they aren't even in the AIL at all when we come across them at AIL
insertion time. Hence these were all getting inserted into the AIL
when they simply do not need to be as inodes marked XFS_ISTALE are
never written back.
Transactional/recovery integrity is maintained in this case by the
other items in the unlink transaction that were modified (e.g. the
AGI btree blocks) and committed in the same checkpoint.
So to fix this, simply unpin the stale inodes directly in
xfs_inode_item_committed() and return -1 to indicate that the AIL
insertion code does not need to do any further processing of these
inodes.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2011-07-04 05:27:36 +00:00
|
|
|
/* item_lsn of -1 means the item needs no further processing */
|
2010-03-22 23:11:05 +00:00
|
|
|
if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the returned lsn is greater than what it contained before, update
|
|
|
|
* the location of the item in the AIL. If it is not, then do nothing.
|
|
|
|
* Items can never move backwards in the AIL.
|
|
|
|
*
|
|
|
|
* While the new lsn should usually be greater, it is possible that a
|
|
|
|
* later transaction completing simultaneously with an earlier one
|
|
|
|
* using the same item could complete first with a higher lsn. This
|
|
|
|
* would cause the earlier transaction to fail the test below.
|
|
|
|
*/
|
|
|
|
ailp = lip->li_ailp;
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0) {
|
|
|
|
/*
|
|
|
|
* This will set the item's lsn to item_lsn and update the
|
|
|
|
* position of the item in the AIL.
|
|
|
|
*
|
|
|
|
* xfs_trans_ail_update() drops the AIL lock.
|
|
|
|
*/
|
|
|
|
xfs_trans_ail_update(ailp, lip, item_lsn);
|
|
|
|
} else {
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now that we've repositioned the item in the AIL, unpin it so it can
|
|
|
|
* be flushed. Pass information about buffer stale state down from the
|
|
|
|
* log item flags, if anyone else stales the buffer we do not want to
|
|
|
|
* pay any attention to it.
|
|
|
|
*/
|
2010-06-23 08:11:15 +00:00
|
|
|
IOP_UNPIN(lip, 0);
|
2010-03-22 23:11:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is typically called by the LM when a transaction has been fully
|
|
|
|
* committed to disk. It needs to unpin the items which have
|
|
|
|
* been logged by the transaction and update their positions
|
|
|
|
* in the AIL if necessary.
|
|
|
|
*
|
|
|
|
* This also gets called when the transactions didn't get written out
|
|
|
|
* because of an I/O error. Abortflag & XFS_LI_ABORTED is set then.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_trans_committed(
|
2010-10-06 18:41:13 +00:00
|
|
|
void *arg,
|
2010-03-22 23:11:05 +00:00
|
|
|
int abortflag)
|
|
|
|
{
|
2010-10-06 18:41:13 +00:00
|
|
|
struct xfs_trans *tp = arg;
|
2010-06-23 08:11:15 +00:00
|
|
|
struct xfs_log_item_desc *lidp, *next;
|
2010-03-22 23:11:05 +00:00
|
|
|
|
2010-06-23 08:11:15 +00:00
|
|
|
list_for_each_entry_safe(lidp, next, &tp->t_items, lid_trans) {
|
2010-03-22 23:11:05 +00:00
|
|
|
xfs_trans_item_committed(lidp->lid_item, tp->t_lsn, abortflag);
|
2010-06-23 08:11:15 +00:00
|
|
|
xfs_trans_free_item_desc(lidp);
|
2010-03-22 23:11:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
xfs_trans_free(tp);
|
|
|
|
}
|
|
|
|
|
2010-12-20 01:02:19 +00:00
|
|
|
static inline void
|
|
|
|
xfs_log_item_batch_insert(
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_item **log_items,
|
|
|
|
int nr_items,
|
|
|
|
xfs_lsn_t commit_lsn)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
/* xfs_trans_ail_update_bulk drops ailp->xa_lock */
|
|
|
|
xfs_trans_ail_update_bulk(ailp, log_items, nr_items, commit_lsn);
|
|
|
|
|
|
|
|
for (i = 0; i < nr_items; i++)
|
|
|
|
IOP_UNPIN(log_items[i], 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Bulk operation version of xfs_trans_committed that takes a log vector of
|
|
|
|
* items to insert into the AIL. This uses bulk AIL insertion techniques to
|
|
|
|
* minimise lock traffic.
|
2011-01-27 01:13:35 +00:00
|
|
|
*
|
|
|
|
* If we are called with the aborted flag set, it is because a log write during
|
|
|
|
* a CIL checkpoint commit has failed. In this case, all the items in the
|
|
|
|
* checkpoint have already gone through IOP_COMMITED and IOP_UNLOCK, which
|
|
|
|
* means that checkpoint commit abort handling is treated exactly the same
|
|
|
|
* as an iclog write error even though we haven't started any IO yet. Hence in
|
|
|
|
* this case all we need to do is IOP_COMMITTED processing, followed by an
|
|
|
|
* IOP_UNPIN(aborted) call.
|
2010-12-20 01:02:19 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_committed_bulk(
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_vec *log_vector,
|
|
|
|
xfs_lsn_t commit_lsn,
|
|
|
|
int aborted)
|
|
|
|
{
|
|
|
|
#define LOG_ITEM_BATCH_SIZE 32
|
|
|
|
struct xfs_log_item *log_items[LOG_ITEM_BATCH_SIZE];
|
|
|
|
struct xfs_log_vec *lv;
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
/* unpin all the log items */
|
|
|
|
for (lv = log_vector; lv; lv = lv->lv_next ) {
|
|
|
|
struct xfs_log_item *lip = lv->lv_item;
|
|
|
|
xfs_lsn_t item_lsn;
|
|
|
|
|
|
|
|
if (aborted)
|
|
|
|
lip->li_flags |= XFS_LI_ABORTED;
|
|
|
|
item_lsn = IOP_COMMITTED(lip, commit_lsn);
|
|
|
|
|
xfs: unpin stale inodes directly in IOP_COMMITTED
When inodes are marked stale in a transaction, they are treated
specially when the inode log item is being inserted into the AIL.
It tries to avoid moving the log item forward in the AIL due to a
race condition with the writing the underlying buffer back to disk.
The was "fixed" in commit de25c18 ("xfs: avoid moving stale inodes
in the AIL").
To avoid moving the item forward, we return a LSN smaller than the
commit_lsn of the completing transaction, thereby trying to trick
the commit code into not moving the inode forward at all. I'm not
sure this ever worked as intended - it assumes the inode is already
in the AIL, but I don't think the returned LSN would have been small
enough to prevent moving the inode. It appears that the reason it
worked is that the lower LSN of the inodes meant they were inserted
into the AIL and flushed before the inode buffer (which was moved to
the commit_lsn of the transaction).
The big problem is that with delayed logging, the returning of the
different LSN means insertion takes the slow, non-bulk path. Worse
yet is that insertion is to a position -before- the commit_lsn so it
is doing a AIL traversal on every insertion, and has to walk over
all the items that have already been inserted into the AIL. It's
expensive.
To compound the matter further, with delayed logging inodes are
likely to go from clean to stale in a single checkpoint, which means
they aren't even in the AIL at all when we come across them at AIL
insertion time. Hence these were all getting inserted into the AIL
when they simply do not need to be as inodes marked XFS_ISTALE are
never written back.
Transactional/recovery integrity is maintained in this case by the
other items in the unlink transaction that were modified (e.g. the
AGI btree blocks) and committed in the same checkpoint.
So to fix this, simply unpin the stale inodes directly in
xfs_inode_item_committed() and return -1 to indicate that the AIL
insertion code does not need to do any further processing of these
inodes.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2011-07-04 05:27:36 +00:00
|
|
|
/* item_lsn of -1 means the item needs no further processing */
|
2010-12-20 01:02:19 +00:00
|
|
|
if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
|
|
|
|
continue;
|
|
|
|
|
2011-01-27 01:13:35 +00:00
|
|
|
/*
|
|
|
|
* if we are aborting the operation, no point in inserting the
|
|
|
|
* object into the AIL as we are in a shutdown situation.
|
|
|
|
*/
|
|
|
|
if (aborted) {
|
|
|
|
ASSERT(XFS_FORCED_SHUTDOWN(ailp->xa_mount));
|
|
|
|
IOP_UNPIN(lip, 1);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-12-20 01:02:19 +00:00
|
|
|
if (item_lsn != commit_lsn) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Not a bulk update option due to unusual item_lsn.
|
|
|
|
* Push into AIL immediately, rechecking the lsn once
|
|
|
|
* we have the ail lock. Then unpin the item.
|
|
|
|
*/
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0)
|
|
|
|
xfs_trans_ail_update(ailp, lip, item_lsn);
|
|
|
|
else
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
IOP_UNPIN(lip, 0);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Item is a candidate for bulk AIL insert. */
|
|
|
|
log_items[i++] = lv->lv_item;
|
|
|
|
if (i >= LOG_ITEM_BATCH_SIZE) {
|
|
|
|
xfs_log_item_batch_insert(ailp, log_items,
|
|
|
|
LOG_ITEM_BATCH_SIZE, commit_lsn);
|
|
|
|
i = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* make sure we insert the remainder! */
|
|
|
|
if (i)
|
|
|
|
xfs_log_item_batch_insert(ailp, log_items, i, commit_lsn);
|
|
|
|
}
|
|
|
|
|
2010-03-22 23:11:05 +00:00
|
|
|
/*
|
2011-01-27 01:13:35 +00:00
|
|
|
* Called from the trans_commit code when we notice that the filesystem is in
|
|
|
|
* the middle of a forced shutdown.
|
|
|
|
*
|
|
|
|
* When we are called here, we have already pinned all the items in the
|
|
|
|
* transaction. However, neither IOP_COMMITTING or IOP_UNLOCK has been called
|
|
|
|
* so we can simply walk the items in the transaction, unpin them with an abort
|
|
|
|
* flag and then free the items. Note that unpinning the items can result in
|
|
|
|
* them being freed immediately, so we need to use a safe list traversal method
|
|
|
|
* here.
|
2010-03-22 23:11:05 +00:00
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_trans_uncommit(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
uint flags)
|
|
|
|
{
|
2011-01-27 01:13:35 +00:00
|
|
|
struct xfs_log_item_desc *lidp, *n;
|
2010-03-22 23:11:05 +00:00
|
|
|
|
2011-01-27 01:13:35 +00:00
|
|
|
list_for_each_entry_safe(lidp, n, &tp->t_items, lid_trans) {
|
2010-03-22 23:11:05 +00:00
|
|
|
if (lidp->lid_flags & XFS_LID_DIRTY)
|
2010-06-23 08:11:15 +00:00
|
|
|
IOP_UNPIN(lidp->lid_item, 1);
|
2010-03-22 23:11:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
xfs_trans_unreserve_and_mod_sb(tp);
|
|
|
|
xfs_trans_unreserve_and_mod_dquots(tp);
|
|
|
|
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
xfs_trans_free_items(tp, NULLCOMMITLSN, flags);
|
2010-03-22 23:11:05 +00:00
|
|
|
xfs_trans_free(tp);
|
|
|
|
}
|
|
|
|
|
2010-03-08 00:28:28 +00:00
|
|
|
/*
|
|
|
|
* Format the transaction direct to the iclog. This isolates the physical
|
|
|
|
* transaction commit operation from the logical operation and hence allows
|
|
|
|
* other methods to be introduced without affecting the existing commit path.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_trans_commit_iclog(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
xfs_lsn_t *commit_lsn,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
int shutdown;
|
|
|
|
int error;
|
|
|
|
int log_flags = 0;
|
|
|
|
struct xlog_in_core *commit_iclog;
|
|
|
|
#define XFS_TRANS_LOGVEC_COUNT 16
|
|
|
|
struct xfs_log_iovec log_vector_fast[XFS_TRANS_LOGVEC_COUNT];
|
|
|
|
struct xfs_log_iovec *log_vector;
|
|
|
|
uint nvec;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Ask each log item how many log_vector entries it will
|
|
|
|
* need so we can figure out how many to allocate.
|
|
|
|
* Try to avoid the kmem_alloc() call in the common case
|
|
|
|
* by using a vector from the stack when it fits.
|
|
|
|
*/
|
|
|
|
nvec = xfs_trans_count_vecs(tp);
|
|
|
|
if (nvec == 0) {
|
2010-03-08 00:28:28 +00:00
|
|
|
return ENOMEM; /* triggers a shutdown! */
|
2005-11-02 04:12:04 +00:00
|
|
|
} else if (nvec <= XFS_TRANS_LOGVEC_COUNT) {
|
2005-04-16 22:20:36 +00:00
|
|
|
log_vector = log_vector_fast;
|
|
|
|
} else {
|
|
|
|
log_vector = (xfs_log_iovec_t *)kmem_alloc(nvec *
|
|
|
|
sizeof(xfs_log_iovec_t),
|
|
|
|
KM_SLEEP);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill in the log_vector and pin the logged items, and
|
|
|
|
* then write the transaction to the log.
|
|
|
|
*/
|
|
|
|
xfs_trans_fill_vecs(tp, log_vector);
|
|
|
|
|
2010-03-08 00:28:28 +00:00
|
|
|
if (flags & XFS_TRANS_RELEASE_LOG_RES)
|
|
|
|
log_flags = XFS_LOG_REL_PERM_RESERV;
|
|
|
|
|
2005-11-02 04:12:04 +00:00
|
|
|
error = xfs_log_write(mp, log_vector, nvec, tp->t_ticket, &(tp->t_lsn));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2005-11-02 04:12:04 +00:00
|
|
|
* The transaction is committed incore here, and can go out to disk
|
|
|
|
* at any time after this call. However, all the items associated
|
|
|
|
* with the transaction are still locked and pinned in memory.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2010-03-08 00:28:28 +00:00
|
|
|
*commit_lsn = xfs_log_done(mp, tp->t_ticket, &commit_iclog, log_flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-03-08 00:28:28 +00:00
|
|
|
tp->t_commit_lsn = *commit_lsn;
|
xfs: Improve scalability of busy extent tracking
When we free a metadata extent, we record it in the per-AG busy
extent array so that it is not re-used before the freeing
transaction hits the disk. This array is fixed size, so when it
overflows we make further allocation transactions synchronous
because we cannot track more freed extents until those transactions
hit the disk and are completed. Under heavy mixed allocation and
freeing workloads with large log buffers, we can overflow this array
quite easily.
Further, the array is sparsely populated, which means that inserts
need to search for a free slot, and array searches often have to
search many more slots that are actually used to check all the
busy extents. Quite inefficient, really.
To enable this aspect of extent freeing to scale better, we need
a structure that can grow dynamically. While in other areas of
XFS we have used radix trees, the extents being freed are at random
locations on disk so are better suited to being indexed by an rbtree.
So, use a per-AG rbtree indexed by block number to track busy
extents. This incures a memory allocation when marking an extent
busy, but should not occur too often in low memory situations. This
should scale to an arbitrary number of extents so should not be a
limitation for features such as in-memory aggregation of
transactions.
However, there are still situations where we can't avoid allocating
busy extents (such as allocation from the AGFL). To minimise the
overhead of such occurences, we need to avoid doing a synchronous
log force while holding the AGF locked to ensure that the previous
transactions are safely on disk before we use the extent. We can do
this by marking the transaction doing the allocation as synchronous
rather issuing a log force.
Because of the locking involved and the ordering of transactions,
the synchronous transaction provides the same guarantees as a
synchronous log force because it ensures that all the prior
transactions are already on disk when the synchronous transaction
hits the disk. i.e. it preserves the free->allocate order of the
extent correctly in recovery.
By doing this, we avoid holding the AGF locked while log writes are
in progress, hence reducing the length of time the lock is held and
therefore we increase the rate at which we can allocate and free
from the allocation group, thereby increasing overall throughput.
The only problem with this approach is that when a metadata buffer is
marked stale (e.g. a directory block is removed), then buffer remains
pinned and locked until the log goes to disk. The issue here is that
if that stale buffer is reallocated in a subsequent transaction, the
attempt to lock that buffer in the transaction will hang waiting
the log to go to disk to unlock and unpin the buffer. Hence if
someone tries to lock a pinned, stale, locked buffer we need to
push on the log to get it unlocked ASAP. Effectively we are trading
off a guaranteed log force for a much less common trigger for log
force to occur.
Ideally we should not reallocate busy extents. That is a much more
complex fix to the problem as it involves direct intervention in the
allocation btree searches in many places. This is left to a future
set of modifications.
Finally, now that we track busy extents in allocated memory, we
don't need the descriptors in the transaction structure to point to
them. We can replace the complex busy chunk infrastructure with a
simple linked list of busy extents. This allows us to remove a large
chunk of code, making the overall change a net reduction in code
size.
Signed-off-by: Dave Chinner <david@fromorbit.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 02:07:08 +00:00
|
|
|
trace_xfs_trans_commit_lsn(tp);
|
|
|
|
|
2010-03-08 00:28:28 +00:00
|
|
|
if (nvec > XFS_TRANS_LOGVEC_COUNT)
|
2008-05-19 06:31:57 +00:00
|
|
|
kmem_free(log_vector);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we got a log write error. Unpin the logitems that we
|
|
|
|
* had pinned, clean up, free trans structure, and return error.
|
|
|
|
*/
|
2010-03-08 00:28:28 +00:00
|
|
|
if (error || *commit_lsn == -1) {
|
2006-06-09 04:59:13 +00:00
|
|
|
current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_trans_uncommit(tp, flags|XFS_TRANS_ABORT);
|
|
|
|
return XFS_ERROR(EIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Once the transaction has committed, unused
|
|
|
|
* reservations need to be released and changes to
|
|
|
|
* the superblock need to be reflected in the in-core
|
|
|
|
* version. Do that now.
|
|
|
|
*/
|
|
|
|
xfs_trans_unreserve_and_mod_sb(tp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Tell the LM to call the transaction completion routine
|
|
|
|
* when the log write with LSN commit_lsn completes (e.g.
|
|
|
|
* when the transaction commit really hits the on-disk log).
|
|
|
|
* After this call we cannot reference tp, because the call
|
|
|
|
* can happen at any time and the call will free the transaction
|
|
|
|
* structure pointed to by tp. The only case where we call
|
|
|
|
* the completion routine (xfs_trans_committed) directly is
|
|
|
|
* if the log is turned off on a debug kernel or we're
|
|
|
|
* running in simulation mode (the log is explicitly turned
|
|
|
|
* off).
|
|
|
|
*/
|
2010-10-06 18:41:13 +00:00
|
|
|
tp->t_logcb.cb_func = xfs_trans_committed;
|
2005-04-16 22:20:36 +00:00
|
|
|
tp->t_logcb.cb_arg = tp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to pass the iclog buffer which was used for the
|
|
|
|
* transaction commit record into this function, and attach
|
|
|
|
* the callback to it. The callback must be attached before
|
|
|
|
* the items are unlocked to avoid racing with other threads
|
|
|
|
* waiting for an item to unlock.
|
|
|
|
*/
|
|
|
|
shutdown = xfs_log_notify(mp, commit_iclog, &(tp->t_logcb));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark this thread as no longer being in a transaction
|
|
|
|
*/
|
2006-06-09 04:59:13 +00:00
|
|
|
current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Once all the items of the transaction have been copied
|
|
|
|
* to the in core log and the callback is attached, the
|
|
|
|
* items can be unlocked.
|
|
|
|
*
|
|
|
|
* This will free descriptors pointing to items which were
|
|
|
|
* not logged since there is nothing more to do with them.
|
|
|
|
* For items which were logged, we will keep pointers to them
|
|
|
|
* so they can be unpinned after the transaction commits to disk.
|
|
|
|
* This will also stamp each modified meta-data item with
|
|
|
|
* the commit lsn of this transaction for dependency tracking
|
|
|
|
* purposes.
|
|
|
|
*/
|
2010-03-08 00:28:28 +00:00
|
|
|
xfs_trans_unlock_items(tp, *commit_lsn);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we detected a log error earlier, finish committing
|
|
|
|
* the transaction now (unpin log items, etc).
|
|
|
|
*
|
|
|
|
* Order is critical here, to avoid using the transaction
|
|
|
|
* pointer after its been freed (by xfs_trans_committed
|
|
|
|
* either here now, or as a callback). We cannot do this
|
|
|
|
* step inside xfs_log_notify as was done earlier because
|
|
|
|
* of this issue.
|
|
|
|
*/
|
|
|
|
if (shutdown)
|
|
|
|
xfs_trans_committed(tp, XFS_LI_ABORTED);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now that the xfs_trans_committed callback has been attached,
|
|
|
|
* and the items are released we can finally allow the iclog to
|
|
|
|
* go to disk.
|
|
|
|
*/
|
2010-03-08 00:28:28 +00:00
|
|
|
return xfs_log_release_iclog(mp, commit_iclog);
|
|
|
|
}
|
|
|
|
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
/*
|
|
|
|
* Walk the log items and allocate log vector structures for
|
|
|
|
* each item large enough to fit all the vectors they require.
|
|
|
|
* Note that this format differs from the old log vector format in
|
|
|
|
* that there is no transaction header in these log vectors.
|
|
|
|
*/
|
|
|
|
STATIC struct xfs_log_vec *
|
|
|
|
xfs_trans_alloc_log_vecs(
|
|
|
|
xfs_trans_t *tp)
|
|
|
|
{
|
2010-06-23 08:11:15 +00:00
|
|
|
struct xfs_log_item_desc *lidp;
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
struct xfs_log_vec *lv = NULL;
|
|
|
|
struct xfs_log_vec *ret_lv = NULL;
|
|
|
|
|
|
|
|
|
|
|
|
/* Bail out if we didn't find a log item. */
|
2010-06-23 08:11:15 +00:00
|
|
|
if (list_empty(&tp->t_items)) {
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
ASSERT(0);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-06-23 08:11:15 +00:00
|
|
|
list_for_each_entry(lidp, &tp->t_items, lid_trans) {
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
struct xfs_log_vec *new_lv;
|
|
|
|
|
|
|
|
/* Skip items which aren't dirty in this transaction. */
|
2010-06-23 08:11:15 +00:00
|
|
|
if (!(lidp->lid_flags & XFS_LID_DIRTY))
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Skip items that do not have any vectors for writing */
|
|
|
|
lidp->lid_size = IOP_SIZE(lidp->lid_item);
|
2010-06-23 08:11:15 +00:00
|
|
|
if (!lidp->lid_size)
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
new_lv = kmem_zalloc(sizeof(*new_lv) +
|
|
|
|
lidp->lid_size * sizeof(struct xfs_log_iovec),
|
|
|
|
KM_SLEEP);
|
|
|
|
|
|
|
|
/* The allocated iovec region lies beyond the log vector. */
|
|
|
|
new_lv->lv_iovecp = (struct xfs_log_iovec *)&new_lv[1];
|
|
|
|
new_lv->lv_niovecs = lidp->lid_size;
|
|
|
|
new_lv->lv_item = lidp->lid_item;
|
|
|
|
if (!ret_lv)
|
|
|
|
ret_lv = new_lv;
|
|
|
|
else
|
|
|
|
lv->lv_next = new_lv;
|
|
|
|
lv = new_lv;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret_lv;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xfs_trans_commit_cil(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
xfs_lsn_t *commit_lsn,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
struct xfs_log_vec *log_vector;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get each log item to allocate a vector structure for
|
|
|
|
* the log item to to pass to the log write code. The
|
|
|
|
* CIL commit code will format the vector and save it away.
|
|
|
|
*/
|
|
|
|
log_vector = xfs_trans_alloc_log_vecs(tp);
|
|
|
|
if (!log_vector)
|
|
|
|
return ENOMEM;
|
|
|
|
|
2011-01-27 02:23:28 +00:00
|
|
|
xfs_log_commit_cil(mp, tp, log_vector, commit_lsn, flags);
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
|
|
|
|
current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
|
|
|
|
xfs_trans_free(tp);
|
|
|
|
return 0;
|
|
|
|
}
|
2010-03-08 00:28:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* xfs_trans_commit
|
|
|
|
*
|
|
|
|
* Commit the given transaction to the log a/synchronously.
|
|
|
|
*
|
|
|
|
* XFS disk error handling mechanism is not based on a typical
|
|
|
|
* transaction abort mechanism. Logically after the filesystem
|
|
|
|
* gets marked 'SHUTDOWN', we can't let any new transactions
|
|
|
|
* be durable - ie. committed to disk - because some metadata might
|
|
|
|
* be inconsistent. In such cases, this returns an error, and the
|
|
|
|
* caller may assume that all locked objects joined to the transaction
|
|
|
|
* have already been unlocked as if the commit had succeeded.
|
|
|
|
* Do not reference the transaction structure after this call.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
_xfs_trans_commit(
|
2010-03-15 01:52:49 +00:00
|
|
|
struct xfs_trans *tp,
|
|
|
|
uint flags,
|
|
|
|
int *log_flushed)
|
2010-03-08 00:28:28 +00:00
|
|
|
{
|
2010-03-15 01:52:49 +00:00
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
2010-03-08 00:28:28 +00:00
|
|
|
xfs_lsn_t commit_lsn = -1;
|
2010-03-15 01:52:49 +00:00
|
|
|
int error = 0;
|
2010-03-08 00:28:28 +00:00
|
|
|
int log_flags = 0;
|
|
|
|
int sync = tp->t_flags & XFS_TRANS_SYNC;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine whether this commit is releasing a permanent
|
|
|
|
* log reservation or not.
|
|
|
|
*/
|
|
|
|
if (flags & XFS_TRANS_RELEASE_LOG_RES) {
|
|
|
|
ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
|
|
|
|
log_flags = XFS_LOG_REL_PERM_RESERV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is nothing to be logged by the transaction,
|
|
|
|
* then unlock all of the items associated with the
|
|
|
|
* transaction and free the transaction structure.
|
|
|
|
* Also make sure to return any reserved blocks to
|
|
|
|
* the free pool.
|
|
|
|
*/
|
2010-03-15 01:52:49 +00:00
|
|
|
if (!(tp->t_flags & XFS_TRANS_DIRTY))
|
|
|
|
goto out_unreserve;
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp)) {
|
|
|
|
error = XFS_ERROR(EIO);
|
|
|
|
goto out_unreserve;
|
2010-03-08 00:28:28 +00:00
|
|
|
}
|
2010-03-15 01:52:49 +00:00
|
|
|
|
2010-03-08 00:28:28 +00:00
|
|
|
ASSERT(tp->t_ticket != NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we need to update the superblock, then do it now.
|
|
|
|
*/
|
|
|
|
if (tp->t_flags & XFS_TRANS_SB_DIRTY)
|
|
|
|
xfs_trans_apply_sb_deltas(tp);
|
|
|
|
xfs_trans_apply_dquot_deltas(tp);
|
|
|
|
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
if (mp->m_flags & XFS_MOUNT_DELAYLOG)
|
|
|
|
error = xfs_trans_commit_cil(mp, tp, &commit_lsn, flags);
|
|
|
|
else
|
|
|
|
error = xfs_trans_commit_iclog(mp, tp, &commit_lsn, flags);
|
|
|
|
|
2010-03-08 00:28:28 +00:00
|
|
|
if (error == ENOMEM) {
|
|
|
|
xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
|
2010-03-15 01:52:49 +00:00
|
|
|
error = XFS_ERROR(EIO);
|
|
|
|
goto out_unreserve;
|
2010-03-08 00:28:28 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the transaction needs to be synchronous, then force the
|
|
|
|
* log out now and wait for it.
|
|
|
|
*/
|
|
|
|
if (sync) {
|
2005-11-01 23:26:59 +00:00
|
|
|
if (!error) {
|
2010-01-19 09:56:46 +00:00
|
|
|
error = _xfs_log_force_lsn(mp, commit_lsn,
|
|
|
|
XFS_LOG_SYNC, log_flushed);
|
2005-11-01 23:26:59 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
XFS_STATS_INC(xs_trans_sync);
|
|
|
|
} else {
|
|
|
|
XFS_STATS_INC(xs_trans_async);
|
|
|
|
}
|
|
|
|
|
2010-03-15 01:52:49 +00:00
|
|
|
return error;
|
|
|
|
|
|
|
|
out_unreserve:
|
|
|
|
xfs_trans_unreserve_and_mod_sb(tp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It is indeed possible for the transaction to be not dirty but
|
|
|
|
* the dqinfo portion to be. All that means is that we have some
|
|
|
|
* (non-persistent) quota reservations that need to be unreserved.
|
|
|
|
*/
|
|
|
|
xfs_trans_unreserve_and_mod_dquots(tp);
|
|
|
|
if (tp->t_ticket) {
|
|
|
|
commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
|
|
|
|
if (commit_lsn == -1 && !error)
|
|
|
|
error = XFS_ERROR(EIO);
|
|
|
|
}
|
|
|
|
current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
xfs_trans_free_items(tp, NULLCOMMITLSN, error ? XFS_TRANS_ABORT : 0);
|
2010-03-15 01:52:49 +00:00
|
|
|
xfs_trans_free(tp);
|
|
|
|
|
|
|
|
XFS_STATS_INC(xs_trans_empty);
|
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unlock all of the transaction's items and free the transaction.
|
|
|
|
* The transaction must not have modified any of its items, because
|
|
|
|
* there is no way to restore them to their previous state.
|
|
|
|
*
|
|
|
|
* If the transaction has made a log reservation, make sure to release
|
|
|
|
* it as well.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_cancel(
|
|
|
|
xfs_trans_t *tp,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
int log_flags;
|
2006-01-11 04:36:44 +00:00
|
|
|
xfs_mount_t *mp = tp->t_mountp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* See if the caller is being too lazy to figure out if
|
|
|
|
* the transaction really needs an abort.
|
|
|
|
*/
|
|
|
|
if ((flags & XFS_TRANS_ABORT) && !(tp->t_flags & XFS_TRANS_DIRTY))
|
|
|
|
flags &= ~XFS_TRANS_ABORT;
|
|
|
|
/*
|
|
|
|
* See if the caller is relying on us to shut down the
|
|
|
|
* filesystem. This happens in paths where we detect
|
|
|
|
* corruption and decide to give up.
|
|
|
|
*/
|
2006-01-11 04:37:00 +00:00
|
|
|
if ((tp->t_flags & XFS_TRANS_DIRTY) && !XFS_FORCED_SHUTDOWN(mp)) {
|
2006-01-11 04:36:44 +00:00
|
|
|
XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
|
2006-06-09 04:58:38 +00:00
|
|
|
xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
|
2006-01-11 04:37:00 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef DEBUG
|
2010-06-23 08:11:15 +00:00
|
|
|
if (!(flags & XFS_TRANS_ABORT) && !XFS_FORCED_SHUTDOWN(mp)) {
|
|
|
|
struct xfs_log_item_desc *lidp;
|
|
|
|
|
|
|
|
list_for_each_entry(lidp, &tp->t_items, lid_trans)
|
|
|
|
ASSERT(!(lidp->lid_item->li_type == XFS_LI_EFD));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
xfs_trans_unreserve_and_mod_sb(tp);
|
2009-06-08 13:33:32 +00:00
|
|
|
xfs_trans_unreserve_and_mod_dquots(tp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (tp->t_ticket) {
|
|
|
|
if (flags & XFS_TRANS_RELEASE_LOG_RES) {
|
|
|
|
ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
|
|
|
|
log_flags = XFS_LOG_REL_PERM_RESERV;
|
|
|
|
} else {
|
|
|
|
log_flags = 0;
|
|
|
|
}
|
2006-01-11 04:36:44 +00:00
|
|
|
xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* mark this thread as no longer being in a transaction */
|
2006-06-09 04:59:13 +00:00
|
|
|
current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 04:37:18 +00:00
|
|
|
xfs_trans_free_items(tp, NULLCOMMITLSN, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_trans_free(tp);
|
|
|
|
}
|
|
|
|
|
2008-08-13 06:05:49 +00:00
|
|
|
/*
|
|
|
|
* Roll from one trans in the sequence of PERMANENT transactions to
|
|
|
|
* the next: permanent transactions are only flushed out when
|
|
|
|
* committed with XFS_TRANS_RELEASE_LOG_RES, but we still want as soon
|
|
|
|
* as possible to let chunks of it go to the log. So we commit the
|
|
|
|
* chunk we've been working on and get a new transaction to continue.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_trans_roll(
|
|
|
|
struct xfs_trans **tpp,
|
|
|
|
struct xfs_inode *dp)
|
|
|
|
{
|
|
|
|
struct xfs_trans *trans;
|
|
|
|
unsigned int logres, count;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ensure that the inode is always logged.
|
|
|
|
*/
|
|
|
|
trans = *tpp;
|
|
|
|
xfs_trans_log_inode(trans, dp, XFS_ILOG_CORE);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy the critical parameters from one trans to the next.
|
|
|
|
*/
|
|
|
|
logres = trans->t_log_res;
|
|
|
|
count = trans->t_log_count;
|
|
|
|
*tpp = xfs_trans_dup(trans);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Commit the current transaction.
|
|
|
|
* If this commit failed, then it'd just unlock those items that
|
|
|
|
* are not marked ihold. That also means that a filesystem shutdown
|
|
|
|
* is in progress. The caller takes the responsibility to cancel
|
|
|
|
* the duplicate transaction that gets returned.
|
|
|
|
*/
|
|
|
|
error = xfs_trans_commit(trans, 0);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
trans = *tpp;
|
|
|
|
|
2008-11-17 06:37:10 +00:00
|
|
|
/*
|
|
|
|
* transaction commit worked ok so we can drop the extra ticket
|
|
|
|
* reference that we gained in xfs_trans_dup()
|
|
|
|
*/
|
|
|
|
xfs_log_ticket_put(trans->t_ticket);
|
|
|
|
|
|
|
|
|
2008-08-13 06:05:49 +00:00
|
|
|
/*
|
|
|
|
* Reserve space in the log for th next transaction.
|
|
|
|
* This also pushes items in the "AIL", the list of logged items,
|
|
|
|
* out to disk if they are taking up space at the tail of the log
|
|
|
|
* that we want to use. This requires that either nothing be locked
|
|
|
|
* across this call, or that anything that is locked be logged in
|
|
|
|
* the prior and the next transactions.
|
|
|
|
*/
|
|
|
|
error = xfs_trans_reserve(trans, 0, logres, 0,
|
|
|
|
XFS_TRANS_PERM_LOG_RES, count);
|
|
|
|
/*
|
|
|
|
* Ensure that the inode is in the new transaction and locked.
|
|
|
|
*/
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2010-06-24 01:36:58 +00:00
|
|
|
xfs_trans_ijoin(trans, dp);
|
2008-08-13 06:05:49 +00:00
|
|
|
return 0;
|
|
|
|
}
|