mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-21 03:33:59 +08:00
7f884dc198
Al Viro reports that generic/231 fails frequently on XFS and bisected
the problem to the following commit:
5d11fb4b xfs: rework zero range to prevent invalid i_size updates
... which is just the first commit that happens to cause fsx to
reproduce the problem. fsx reproduces via zero range calls. The
aforementioned commit overhauls zero range to use hole punch and
fallocate. As it turns out, the problem is reproducible on demand using
basic hole punch as follows:
$ mkfs.xfs -f -m crc=1,finobt=1 <dev>
$ mount <dev> /mnt -o uquota
$ xfs_io -f -c "falloc 0 50m" /mnt/file
$ for i in $(seq 1 20); do xfs_io -c "fpunch ${i}m 32k" /mnt/file; done
$ rm -f /mnt/file
$ repquota -us /mnt
...
User used soft hard grace used soft hard grace
----------------------------------------------------------------------
root -- 32K 0K 0K 3 0 0
A file is allocated with a single 50m extent. The extent count increases
via hole punches until the bmap converts to btree format. The file is
removed but quota reports 32k of space usage for the user. This
reservation is effectively leaked for the lifetime of the mount.
The reason this occurs is because the quota block reservation tracking
is confused when a transaction happens to free and allocate blocks at
the same time. Consider the following sequence of events:
- tp is allocated from xfs_free_file_space() and reserves several blocks
for btree management. Blocks are reserved against the dquot and marked
as such in the transaction (qtrx->qt_blk_res).
- 8 blocks are accounted free when the 32k range is punched out.
xfs_trans_mod_dquot() is called with XFS_TRANS_DQ_BCOUNT and sets
->qt_bcount_delta to -8.
- Subsequently, a block is allocated against the same transaction by
xfs_bmap_extents_to_btree() for btree conversion. A call to
xfs_trans_mod_dquot() increases qt_blk_res_used to 1 and qt_bcount_delta
to -7.
- The transaction is dup'd and committed by xfs_bmap_finish().
xfs_trans_dup_dqinfo() sets the first transaction up such that it has a
matching qt_blk_res and qt_blk_res_used of 1. The remaining unused
reservation is transferred to the duplicate tp.
When the transactions are committed, the dquots are fixed up in
xfs_trans_apply_dquot_deltas() according to one of two methods:
1.) If the transaction holds a block reservation (->qt_blk_res != 0),
_only_ the unused portion reservation is unaccounted from the dquot.
Note that the tp duplication behavior of xfs_bmap_finish() makes it such
that qt_blk_res is typically 0 for tp's with unused reservation.
2.) Otherwise, the dquot is fixed up based on the block delta
(->qt_bcount_delta) created by the transaction.
Therefore, if a transaction has a negative qt_bcount_delta and positive
qt_blk_res_used, the former set of blocks that have been removed from
the file are never factored out of the in-core dquot reservation.
Instead, *_apply_dquot_deltas() sees 1 block used out of a 1 block
reservation and believes there is nothing to fix up. The on-disk
d_bcount is updated independently from qt_bcount_delta, and thus is
correct (and allows the quota usage to correct on remount).
To deal with this situation, we effectively want the "used reservation"
part of the transaction to be consistent with any freed blocks with
respect to quota tracking. For example, if 8 blocks are freed, the
subsequent single block allocation does not need to consume the initial
reservation made by the tp. Instead, it simply borrows one from the
previously freed. One possible implementation of such borrowing is to
avoid the blks_res_used increment when bcount_delta is negative. This
alone is flawed logic in that it only handles the case where blocks are
freed before allocated, however.
Rather than add more complexity to manage synchronization between
bcount_delta and blks_res_used, kill the latter entirely. blk_res_used
is only updated in one place and always in sync with delta_bcount.
Therefore, the net block reservation consumption of the transaction is
always available from bcount_delta. Calculate the reservation
consumption on the fly where necessary based on whether the tp has a
reservation and results in a positive net block delta on the inode.
Reported-by: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
155 lines
6.0 KiB
C
155 lines
6.0 KiB
C
/*
|
|
* Copyright (c) 2000-2005 Silicon Graphics, Inc.
|
|
* All Rights Reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* 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.
|
|
*
|
|
* 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
|
|
*/
|
|
#ifndef __XFS_QUOTA_H__
|
|
#define __XFS_QUOTA_H__
|
|
|
|
#include "xfs_quota_defs.h"
|
|
|
|
/*
|
|
* Kernel only quota definitions and functions
|
|
*/
|
|
|
|
struct xfs_trans;
|
|
|
|
/*
|
|
* This check is done typically without holding the inode lock;
|
|
* that may seem racy, but it is harmless in the context that it is used.
|
|
* The inode cannot go inactive as long a reference is kept, and
|
|
* therefore if dquot(s) were attached, they'll stay consistent.
|
|
* If, for example, the ownership of the inode changes while
|
|
* we didn't have the inode locked, the appropriate dquot(s) will be
|
|
* attached atomically.
|
|
*/
|
|
#define XFS_NOT_DQATTACHED(mp, ip) \
|
|
((XFS_IS_UQUOTA_ON(mp) && (ip)->i_udquot == NULL) || \
|
|
(XFS_IS_GQUOTA_ON(mp) && (ip)->i_gdquot == NULL) || \
|
|
(XFS_IS_PQUOTA_ON(mp) && (ip)->i_pdquot == NULL))
|
|
|
|
#define XFS_QM_NEED_QUOTACHECK(mp) \
|
|
((XFS_IS_UQUOTA_ON(mp) && \
|
|
(mp->m_sb.sb_qflags & XFS_UQUOTA_CHKD) == 0) || \
|
|
(XFS_IS_GQUOTA_ON(mp) && \
|
|
(mp->m_sb.sb_qflags & XFS_GQUOTA_CHKD) == 0) || \
|
|
(XFS_IS_PQUOTA_ON(mp) && \
|
|
(mp->m_sb.sb_qflags & XFS_PQUOTA_CHKD) == 0))
|
|
|
|
/*
|
|
* The structure kept inside the xfs_trans_t keep track of dquot changes
|
|
* within a transaction and apply them later.
|
|
*/
|
|
typedef struct xfs_dqtrx {
|
|
struct xfs_dquot *qt_dquot; /* the dquot this refers to */
|
|
ulong qt_blk_res; /* blks reserved on a dquot */
|
|
ulong qt_ino_res; /* inode reserved on a dquot */
|
|
ulong qt_ino_res_used; /* inodes used from the reservation */
|
|
long qt_bcount_delta; /* dquot blk count changes */
|
|
long qt_delbcnt_delta; /* delayed dquot blk count changes */
|
|
long qt_icount_delta; /* dquot inode count changes */
|
|
ulong qt_rtblk_res; /* # blks reserved on a dquot */
|
|
ulong qt_rtblk_res_used;/* # blks used from reservation */
|
|
long qt_rtbcount_delta;/* dquot realtime blk changes */
|
|
long qt_delrtb_delta; /* delayed RT blk count changes */
|
|
} xfs_dqtrx_t;
|
|
|
|
#ifdef CONFIG_XFS_QUOTA
|
|
extern void xfs_trans_dup_dqinfo(struct xfs_trans *, struct xfs_trans *);
|
|
extern void xfs_trans_free_dqinfo(struct xfs_trans *);
|
|
extern void xfs_trans_mod_dquot_byino(struct xfs_trans *, struct xfs_inode *,
|
|
uint, long);
|
|
extern void xfs_trans_apply_dquot_deltas(struct xfs_trans *);
|
|
extern void xfs_trans_unreserve_and_mod_dquots(struct xfs_trans *);
|
|
extern int xfs_trans_reserve_quota_nblks(struct xfs_trans *,
|
|
struct xfs_inode *, long, long, uint);
|
|
extern int xfs_trans_reserve_quota_bydquots(struct xfs_trans *,
|
|
struct xfs_mount *, struct xfs_dquot *,
|
|
struct xfs_dquot *, struct xfs_dquot *, long, long, uint);
|
|
|
|
extern int xfs_qm_vop_dqalloc(struct xfs_inode *, xfs_dqid_t, xfs_dqid_t,
|
|
prid_t, uint, struct xfs_dquot **, struct xfs_dquot **,
|
|
struct xfs_dquot **);
|
|
extern void xfs_qm_vop_create_dqattach(struct xfs_trans *, struct xfs_inode *,
|
|
struct xfs_dquot *, struct xfs_dquot *, struct xfs_dquot *);
|
|
extern int xfs_qm_vop_rename_dqattach(struct xfs_inode **);
|
|
extern struct xfs_dquot *xfs_qm_vop_chown(struct xfs_trans *,
|
|
struct xfs_inode *, struct xfs_dquot **, struct xfs_dquot *);
|
|
extern int xfs_qm_vop_chown_reserve(struct xfs_trans *, struct xfs_inode *,
|
|
struct xfs_dquot *, struct xfs_dquot *,
|
|
struct xfs_dquot *, uint);
|
|
extern int xfs_qm_dqattach(struct xfs_inode *, uint);
|
|
extern int xfs_qm_dqattach_locked(struct xfs_inode *, uint);
|
|
extern void xfs_qm_dqdetach(struct xfs_inode *);
|
|
extern void xfs_qm_dqrele(struct xfs_dquot *);
|
|
extern void xfs_qm_statvfs(struct xfs_inode *, struct kstatfs *);
|
|
extern int xfs_qm_newmount(struct xfs_mount *, uint *, uint *);
|
|
extern void xfs_qm_mount_quotas(struct xfs_mount *);
|
|
extern void xfs_qm_unmount(struct xfs_mount *);
|
|
extern void xfs_qm_unmount_quotas(struct xfs_mount *);
|
|
|
|
#else
|
|
static inline int
|
|
xfs_qm_vop_dqalloc(struct xfs_inode *ip, xfs_dqid_t uid, xfs_dqid_t gid,
|
|
prid_t prid, uint flags, struct xfs_dquot **udqp,
|
|
struct xfs_dquot **gdqp, struct xfs_dquot **pdqp)
|
|
{
|
|
*udqp = NULL;
|
|
*gdqp = NULL;
|
|
*pdqp = NULL;
|
|
return 0;
|
|
}
|
|
#define xfs_trans_dup_dqinfo(tp, tp2)
|
|
#define xfs_trans_free_dqinfo(tp)
|
|
#define xfs_trans_mod_dquot_byino(tp, ip, fields, delta)
|
|
#define xfs_trans_apply_dquot_deltas(tp)
|
|
#define xfs_trans_unreserve_and_mod_dquots(tp)
|
|
static inline int xfs_trans_reserve_quota_nblks(struct xfs_trans *tp,
|
|
struct xfs_inode *ip, long nblks, long ninos, uint flags)
|
|
{
|
|
return 0;
|
|
}
|
|
static inline int xfs_trans_reserve_quota_bydquots(struct xfs_trans *tp,
|
|
struct xfs_mount *mp, struct xfs_dquot *udqp,
|
|
struct xfs_dquot *gdqp, struct xfs_dquot *pdqp,
|
|
long nblks, long nions, uint flags)
|
|
{
|
|
return 0;
|
|
}
|
|
#define xfs_qm_vop_create_dqattach(tp, ip, u, g, p)
|
|
#define xfs_qm_vop_rename_dqattach(it) (0)
|
|
#define xfs_qm_vop_chown(tp, ip, old, new) (NULL)
|
|
#define xfs_qm_vop_chown_reserve(tp, ip, u, g, p, fl) (0)
|
|
#define xfs_qm_dqattach(ip, fl) (0)
|
|
#define xfs_qm_dqattach_locked(ip, fl) (0)
|
|
#define xfs_qm_dqdetach(ip)
|
|
#define xfs_qm_dqrele(d)
|
|
#define xfs_qm_statvfs(ip, s)
|
|
#define xfs_qm_newmount(mp, a, b) (0)
|
|
#define xfs_qm_mount_quotas(mp)
|
|
#define xfs_qm_unmount(mp)
|
|
#define xfs_qm_unmount_quotas(mp)
|
|
#endif /* CONFIG_XFS_QUOTA */
|
|
|
|
#define xfs_trans_unreserve_quota_nblks(tp, ip, nblks, ninos, flags) \
|
|
xfs_trans_reserve_quota_nblks(tp, ip, -(nblks), -(ninos), flags)
|
|
#define xfs_trans_reserve_quota(tp, mp, ud, gd, pd, nb, ni, f) \
|
|
xfs_trans_reserve_quota_bydquots(tp, mp, ud, gd, pd, nb, ni, \
|
|
f | XFS_QMOPT_RES_REGBLKS)
|
|
|
|
extern int xfs_mount_reset_sbqflags(struct xfs_mount *);
|
|
|
|
#endif /* __XFS_QUOTA_H__ */
|