xfs: use ordered buffers to initialize dquot buffers during quotacheck
PATCH v2 1/1 xfs: use ordered buffers to initialize dquot buffers during quotacheck
From: Darrick J. Wong <[email protected]>
While QAing the new xfs_repair quotacheck code, I uncovered a quota corruption bug resulting from a bad interaction between dquot buffer initialization and quotacheck. The bug can be reproduced with the following sequence:
# mkfs.xfs -f /dev/sdf
# mount /dev/sdf /opt -o usrquota
# su nobody -s /bin/bash -c 'touch /opt/barf'
# sync
# xfs_quota -x -c 'report -ahi' /opt
User quota on /opt (/dev/sdf)
Inodes
User ID Used Soft Hard Warn/Grace
---------- ---------------------------------
root 3 0 0 00 [------]
nobody 1 0 0 00 [------]# xfs_io -x -c 'shutdown' /opt
# umount /opt
# mount /dev/sdf /opt -o usrquota
# touch /opt/man2
# xfs_quota -x -c 'report -ahi' /opt
User quota on /opt (/dev/sdf)
Inodes
User ID Used Soft Hard Warn/Grace
---------- ---------------------------------
root 1 0 0 00 [------]
nobody 1 0 0 00 [------]# umount /opt
Notice how the initial quotacheck set the root dquot icount to 3 (rootino, rbmino, rsumino), but after shutdown -> remount -> recovery, xfs_quota reports that the root dquot has only 1 icount. We haven't deleted anything from the filesystem, which means that quota is now under-counting. This behavior is not limited to icount or the root dquot, but this is the shortest reproducer.
I traced the cause of this discrepancy to the way that we handle ondisk dquot updates during quotacheck vs. regular fs activity. Normally, when we allocate a disk block for a dquot, we log the buffer as a regular (dquot) buffer. Subsequent updates to the dquots backed by that block are done via separate dquot log item updates, which means that they depend on the logged buffer update being written to disk before the dquot items. Because individual dquots have their own LSN fields, that initial dquot buffer must always be recovered.
However, the story changes for quotacheck, which can cause dquot block allocations but persists the final dquot counter values via a delwri list. Because recovery doesn't gate dquot buffer replay on an LSN, this means that the initial dquot buffer can be replayed over the (newer) contents that were delwritten at the end of quotacheck. In effect, this re-initializes the dquot counters after they've been updated. If the log does not contain any other dquot items to recover, the obsolete dquot contents will not be corrected by log recovery.
Because quotacheck uses a transaction to log the setting of the CHKD flags in the superblock, we skip quotacheck during the second mount call, which allows the incorrect icount to remain.
Fix this by changing the ondisk dquot initialization function to use ordered buffers to write out fresh dquot blocks if it detects that we're running quotacheck. If the system goes down before quotacheck can complete, the CHKD flags will not be set in the superblock and the next mount will run quotacheck again, which can fix uninitialized dquot buffers. This requires amending the defer code to maintaine ordered buffer state across defer rolls for the sake of the dquot allocation code.
For regular operations we preserve the current behavior since the dquot items require properly initialized ondisk dquot records.
---
v2: rework the code comment explaining all this
--- fs/xfs/libxfs/xfs_defer.c | 10 +++++++ fs/xfs/xfs_dquot.c | 62 ++++++++++++++++++++++++++++++++++++--------- 2 files changed, 58 insertions(+), 14 deletions(-)
fs/xfs/libxfs/xfs_defer.c +9 -1
@@ -240,10 +240,13 @@ xfs_defer_trans_roll(struct xfs_log_item *lip;struct xfs_buf *bplist[XFS_DEFER_OPS_NR_BUFS ];struct xfs_inode *iplist[XFS_DEFER_OPS_NR_INODES ]; +unsigned int ordered =0 ;/* bitmap */ int bpcount =0 , ipcount =0 ;int i;int error; +BUILD_BUG_ON (NBBY *sizeof (ordered) <XFS_DEFER_OPS_NR_BUFS ); +list_for_each_entry (lip, &tp->t_items, li_trans) {switch (lip->li_type) {case XFS_LI_BUF :
@@ -254,7 +257,10 @@ xfs_defer_trans_roll(ASSERT (0 );return -EFSCORRUPTED ; } -xfs_trans_dirty_buf (tp, bli->bli_buf); +if (bli->bli_flags &XFS_BLI_ORDERED ) + ordered |= (1U << bpcount); +else +xfs_trans_dirty_buf (tp, bli->bli_buf); bplist[bpcount++] = bli->bli_buf; }break ;
@@ -295,6 +301,8 @@ xfs_defer_trans_roll(/* Rejoin the buffers and dirty them so the log moves forward. */ for (i =0 ; i < bpcount; i++) {xfs_trans_bjoin (tp, bplist[i]); +if (ordered & (1U << i)) +xfs_trans_ordered_buf (tp, bplist[i]);xfs_trans_bhold (tp, bplist[i]); }
fs/xfs/xfs_dquot.c +49 -13
76 lines not on this page · raw message
Quoted 2 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
...
Quoted 21 lines
Fix this by changing the ondisk dquot initialization function to use ordered buffers to write out fresh dquot blocks if it detects that we're running quotacheck. If the system goes down before quotacheck can complete, the CHKD flags will not be set in the superblock and the next mount will run quotacheck again, which can fix uninitialized dquot buffers. This requires amending the defer code to maintaine ordered buffer state across defer rolls for the sake of the dquot allocation code.
For regular operations we preserve the current behavior since the dquot items require properly initialized ondisk dquot records.
Signed-off-by Darrick J. Wong <[email protected]>---
v2: rework the code comment explaining all this--- fs/xfs/libxfs/xfs_defer.c | 10 +++++++ fs/xfs/xfs_dquot.c | 62 ++++++++++++++++++++++++++++++++++++--------- 2 files changed, 58 insertions(+), 14 deletions(-)
...
Quoted 4 lines
fs/xfs/xfs_dquot.c +0
-0
...
Quoted 1 line
fs/xfs/xfs_dquot.c +0
-0@@ -238,11 +240,45 @@ xfs_qm_init_dquot_blk(
...
Quoted 13 lines
fs/xfs/xfs_dquot.c +13
-0+ +/* +* When quotacheck runs, we use delayed writes to update all the dquots +* on disk in an efficient manner instead of logging the individual +* dquot changes as they are made. +* +* Hence if we log the buffer that we allocate here, then crash +* post-quotacheck while the logged initialisation is still in the +* active region of the log, we can lose the information quotacheck +* wrote directly to the buffer. That is, log recovery will replay the +* dquot buffer initialisation over the top of whatever information +* quotacheck had written to the buffer. +*
fs/xfs/xfs_dquot.c
Quoted 10 lines
fs/xfs/xfs_dquot.c +10
-0+* To avoid this problem, dquot allocation during quotacheck needs to +* avoid logging the initialised buffer, but we still need to have +* writeback of the buffer pin the tail of the log so that it is +* initialised on disk before we remove the allocation transaction from +* the active region of the log. Marking the buffer as ordered instead +* of logging it provides this behaviour. +* +* If we crash before quotacheck completes, a subsequent quotacheck run +* will re-allocate and re-initialize the dquot records as needed. +*/
I took a stab at condensing the comment a bit, FWIW (diff below). LGTM either way. Thanks for the update.
fs/xfs/xfs_dquot.c
Quoted 8 lines
fs/xfs/xfs_dquot.c +4
-0+if (!(mp->m_qflags & qflag)) +xfs_trans_ordered_buf (tp, bp); +else +xfs_trans_log_buf (tp, bp,0 ,BBTOB (q->qi_dqchunklen) -1 ); }/*
fs/xfs/xfs_dquot.c +13 -19
@@ -254,26 +254,20 @@ xfs_qm_init_dquot_blk(xfs_trans_dquot_buf (tp, bp, blftype);/* -* When quotacheck runs, we use delayed writes to update all the dquots -* on disk in an efficient manner instead of logging the individual -* dquot changes as they are made. +* quotacheck uses delayed writes to update all the dquots on disk in an +* efficient manner instead of logging the individual dquot changes as +* they are made. However if we log the buffer allocated here and crash +* after quotacheck while the logged initialisation is still in the +* active region of the log, log recovery can replay the dquot buffer +* initialisation over the top of the checked dquots and corrupt quota +* accounting. * -* Hence if we log the buffer that we allocate here, then crash -* post-quotacheck while the logged initialisation is still in the -* active region of the log, we can lose the information quotacheck -* wrote directly to the buffer. That is, log recovery will replay the -* dquot buffer initialisation over the top of whatever information -* quotacheck had written to the buffer. -* -* To avoid this problem, dquot allocation during quotacheck needs to -* avoid logging the initialised buffer, but we still need to have -* writeback of the buffer pin the tail of the log so that it is -* initialised on disk before we remove the allocation transaction from -* the active region of the log. Marking the buffer as ordered instead -* of logging it provides this behaviour. -* -* If we crash before quotacheck completes, a subsequent quotacheck run -* will re-allocate and re-initialize the dquot records as needed. +* To avoid this problem, quotacheck cannot log the initialised buffer. +* We must still dirty the buffer and write it back before the +* allocation transaction clears the log. Therefore, mark the buffer as +* ordered instead of logging it directly. This is safe for quotacheck +* because it detects and repairs allocated but initialized dquot blocks +* in the quota inodes. */ if (!(mp->m_qflags & qflag))xfs_trans_ordered_buf (tp, bp);
Quoted 102 lines · Brian Foster
Quoted 2 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
...
Quoted 21 lines
Fix this by changing the ondisk dquot initialization function to use ordered buffers to write out fresh dquot blocks if it detects that we're running quotacheck. If the system goes down before quotacheck can complete, the CHKD flags will not be set in the superblock and the next mount will run quotacheck again, which can fix uninitialized dquot buffers. This requires amending the defer code to maintaine ordered buffer state across defer rolls for the sake of the dquot allocation code.
For regular operations we preserve the current behavior since the dquot items require properly initialized ondisk dquot records.
Signed-off-by Darrick J. Wong <[email protected]>---
v2: rework the code comment explaining all this--- fs/xfs/libxfs/xfs_defer.c | 10 +++++++ fs/xfs/xfs_dquot.c | 62 ++++++++++++++++++++++++++++++++++++--------- 2 files changed, 58 insertions(+), 14 deletions(-)...
Quoted 4 lines
fs/xfs/xfs_dquot.c +0
-0...
Quoted 1 line
fs/xfs/xfs_dquot.c +0
-0@@ -238,11 +240,45 @@ xfs_qm_init_dquot_blk(...
Quoted 13 lines
fs/xfs/xfs_dquot.c +13
-0+ +/* +* When quotacheck runs, we use delayed writes to update all the dquots +* on disk in an efficient manner instead of logging the individual +* dquot changes as they are made. +* +* Hence if we log the buffer that we allocate here, then crash +* post-quotacheck while the logged initialisation is still in the +* active region of the log, we can lose the information quotacheck +* wrote directly to the buffer. That is, log recovery will replay the +* dquot buffer initialisation over the top of whatever information +* quotacheck had written to the buffer. +* fs/xfs/xfs_dquot.c
Quoted 10 lines
fs/xfs/xfs_dquot.c +10
-0+* To avoid this problem, dquot allocation during quotacheck needs to +* avoid logging the initialised buffer, but we still need to have +* writeback of the buffer pin the tail of the log so that it is +* initialised on disk before we remove the allocation transaction from +* the active region of the log. Marking the buffer as ordered instead +* of logging it provides this behaviour. +* +* If we crash before quotacheck completes, a subsequent quotacheck run +* will re-allocate and re-initialize the dquot records as needed. +*/ I took a stab at condensing the comment a bit, FWIW (diff below). LGTM either way. Thanks for the update.
Reviewed-by Brian Foster <[email protected]>Quoted 8 lines
fs/xfs/xfs_dquot.c +4
-0+if (!(mp->m_qflags & qflag)) +xfs_trans_ordered_buf (tp, bp); +else +xfs_trans_log_buf (tp, bp,0 ,BBTOB (q->qi_dqchunklen) -1 ); }/* fs/xfs/xfs_dquot.c +7
-15@@ -254,26 +254,20 @@ xfs_qm_init_dquot_blk(xfs_trans_dquot_buf (tp, bp, blftype);/* -* When quotacheck runs, we use delayed writes to update all the dquots -* on disk in an efficient manner instead of logging the individual -* dquot changes as they are made. +* quotacheck uses delayed writes to update all the dquots on disk in an +* efficient manner instead of logging the individual dquot changes as +* they are made. However if we log the buffer allocated here and crash +* after quotacheck while the logged initialisation is still in the +* active region of the log, log recovery can replay the dquot buffer +* initialisation over the top of the checked dquots and corrupt quota +* accounting. * -* Hence if we log the buffer that we allocate here, then crash -* post-quotacheck while the logged initialisation is still in the -* active region of the log, we can lose the information quotacheck -* wrote directly to the buffer. That is, log recovery will replay the -* dquot buffer initialisation over the top of whatever information -* quotacheck had written to the buffer. -* -* To avoid this problem, dquot allocation during quotacheck needs to -* avoid logging the initialised buffer, but we still need to have -* writeback of the buffer pin the tail of the log so that it is -* initialised on disk before we remove the allocation transaction from -* the active region of the log. Marking the buffer as ordered instead
fs/xfs/xfs_dquot.c xfs_qm_init_dquot_blk( · line 270
Quoted 10 lines
fs/xfs/xfs_dquot.c +6
-4-* of logging it provides this behaviour. -* -* If we crash before quotacheck completes, a subsequent quotacheck run -* will re-allocate and re-initialize the dquot records as needed. +* To avoid this problem, quotacheck cannot log the initialised buffer. +* We must still dirty the buffer and write it back before the +* allocation transaction clears the log. Therefore, mark the buffer as +* ordered instead of logging it directly. This is safe for quotacheck +* because it detects and repairs allocated but initialized dquot blocks +* in the quota inodes.
I think I like your revised comment better. :)
--D
Quoted 4 lines
fs/xfs/xfs_dquot.c +0
-0*/ if (!(mp->m_qflags & qflag))xfs_trans_ordered_buf (tp, bp);
I would have split the addition of support for order buffers to the defer mechanism into a separate patch.
Otherwise this looks good: