2018-06-06 05:42:14 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2008-10-30 09:06:08 +03:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2000-2005 Silicon Graphics, Inc.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
|
|
|
#include "xfs_fs.h"
|
2019-06-29 05:25:35 +03:00
|
|
|
#include "xfs_shared.h"
|
2013-08-12 14:49:26 +04:00
|
|
|
#include "xfs_format.h"
|
2013-10-23 03:50:10 +04:00
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2008-10-30 09:06:08 +03:00
|
|
|
#include "xfs_sb.h"
|
|
|
|
#include "xfs_mount.h"
|
|
|
|
#include "xfs_inode.h"
|
2013-10-23 03:50:10 +04:00
|
|
|
#include "xfs_trans.h"
|
|
|
|
#include "xfs_trans_priv.h"
|
2008-10-30 09:06:08 +03:00
|
|
|
#include "xfs_inode_item.h"
|
2009-06-08 17:33:32 +04:00
|
|
|
#include "xfs_quota.h"
|
2009-12-15 02:14:59 +03:00
|
|
|
#include "xfs_trace.h"
|
2012-10-08 14:56:09 +04:00
|
|
|
#include "xfs_icache.h"
|
2013-08-12 14:49:45 +04:00
|
|
|
#include "xfs_bmap_util.h"
|
2014-07-24 13:49:28 +04:00
|
|
|
#include "xfs_dquot_item.h"
|
|
|
|
#include "xfs_dquot.h"
|
2016-10-03 19:11:46 +03:00
|
|
|
#include "xfs_reflink.h"
|
2020-05-15 00:01:19 +03:00
|
|
|
#include "xfs_ialloc.h"
|
2008-10-30 09:06:08 +03:00
|
|
|
|
2017-12-11 14:35:19 +03:00
|
|
|
#include <linux/iversion.h>
|
2008-10-30 09:06:18 +03:00
|
|
|
|
2012-10-08 14:56:11 +04:00
|
|
|
/*
|
|
|
|
* Allocate and initialise an xfs_inode.
|
|
|
|
*/
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-30 04:23:45 +04:00
|
|
|
struct xfs_inode *
|
2012-10-08 14:56:11 +04:00
|
|
|
xfs_inode_alloc(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_ino_t ino)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip;
|
|
|
|
|
|
|
|
/*
|
2020-07-22 19:23:04 +03:00
|
|
|
* XXX: If this didn't occur in transactions, we could drop GFP_NOFAIL
|
|
|
|
* and return NULL here on ENOMEM.
|
2012-10-08 14:56:11 +04:00
|
|
|
*/
|
2020-07-22 19:23:04 +03:00
|
|
|
ip = kmem_cache_alloc(xfs_inode_zone, GFP_KERNEL | __GFP_NOFAIL);
|
|
|
|
|
2012-10-08 14:56:11 +04:00
|
|
|
if (inode_init_always(mp->m_super, VFS_I(ip))) {
|
2019-11-14 23:43:04 +03:00
|
|
|
kmem_cache_free(xfs_inode_zone, ip);
|
2012-10-08 14:56:11 +04:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-02-09 08:54:58 +03:00
|
|
|
/* VFS doesn't initialise i_mode! */
|
|
|
|
VFS_I(ip)->i_mode = 0;
|
|
|
|
|
2015-10-12 10:21:22 +03:00
|
|
|
XFS_STATS_INC(mp, vn_active);
|
2012-10-08 14:56:11 +04:00
|
|
|
ASSERT(atomic_read(&ip->i_pincount) == 0);
|
|
|
|
ASSERT(ip->i_ino == 0);
|
|
|
|
|
|
|
|
/* initialise the xfs inode */
|
|
|
|
ip->i_ino = ino;
|
|
|
|
ip->i_mount = mp;
|
|
|
|
memset(&ip->i_imap, 0, sizeof(struct xfs_imap));
|
|
|
|
ip->i_afp = NULL;
|
2016-10-03 19:11:32 +03:00
|
|
|
ip->i_cowfp = NULL;
|
2018-07-18 02:51:50 +03:00
|
|
|
memset(&ip->i_df, 0, sizeof(ip->i_df));
|
2012-10-08 14:56:11 +04:00
|
|
|
ip->i_flags = 0;
|
|
|
|
ip->i_delayed_blks = 0;
|
2016-02-09 08:54:58 +03:00
|
|
|
memset(&ip->i_d, 0, sizeof(ip->i_d));
|
2019-04-12 17:40:25 +03:00
|
|
|
ip->i_sick = 0;
|
|
|
|
ip->i_checked = 0;
|
xfs: implement per-inode writeback completion queues
When scheduling writeback of dirty file data in the page cache, XFS uses
IO completion workqueue items to ensure that filesystem metadata only
updates after the write completes successfully. This is essential for
converting unwritten extents to real extents at the right time and
performing COW remappings.
Unfortunately, XFS queues each IO completion work item to an unbounded
workqueue, which means that the kernel can spawn dozens of threads to
try to handle the items quickly. These threads need to take the ILOCK
to update file metadata, which results in heavy ILOCK contention if a
large number of the work items target a single file, which is
inefficient.
Worse yet, the writeback completion threads get stuck waiting for the
ILOCK while holding transaction reservations, which can use up all
available log reservation space. When that happens, metadata updates to
other parts of the filesystem grind to a halt, even if the filesystem
could otherwise have handled it.
Even worse, if one of the things grinding to a halt happens to be a
thread in the middle of a defer-ops finish holding the same ILOCK and
trying to obtain more log reservation having exhausted the permanent
reservation, we now have an ABBA deadlock - writeback completion has a
transaction reserved and wants the ILOCK, and someone else has the ILOCK
and wants a transaction reservation.
Therefore, we create a per-inode writeback io completion queue + work
item. When writeback finishes, it can add the ioend to the per-inode
queue and let the single worker item process that queue. This
dramatically cuts down on the number of kworkers and ILOCK contention in
the system, and seems to have eliminated an occasional deadlock I was
seeing while running generic/476.
Testing with a program that simulates a heavy random-write workload to a
single file demonstrates that the number of kworkers drops from
approximately 120 threads per file to 1, without dramatically changing
write bandwidth or pagecache access latency.
Note that we leave the xfs-conv workqueue's max_active alone because we
still want to be able to run ioend processing for as many inodes as the
system can handle.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
2019-04-15 23:13:20 +03:00
|
|
|
INIT_WORK(&ip->i_ioend_work, xfs_end_io);
|
|
|
|
INIT_LIST_HEAD(&ip->i_ioend_list);
|
|
|
|
spin_lock_init(&ip->i_ioend_lock);
|
2012-10-08 14:56:11 +04:00
|
|
|
|
|
|
|
return ip;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC void
|
|
|
|
xfs_inode_free_callback(
|
|
|
|
struct rcu_head *head)
|
|
|
|
{
|
|
|
|
struct inode *inode = container_of(head, struct inode, i_rcu);
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
|
2016-02-09 08:54:58 +03:00
|
|
|
switch (VFS_I(ip)->i_mode & S_IFMT) {
|
2012-10-08 14:56:11 +04:00
|
|
|
case S_IFREG:
|
|
|
|
case S_IFDIR:
|
|
|
|
case S_IFLNK:
|
2020-05-18 20:29:27 +03:00
|
|
|
xfs_idestroy_fork(&ip->i_df);
|
2012-10-08 14:56:11 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-05-18 20:29:27 +03:00
|
|
|
if (ip->i_afp) {
|
|
|
|
xfs_idestroy_fork(ip->i_afp);
|
|
|
|
kmem_cache_free(xfs_ifork_zone, ip->i_afp);
|
|
|
|
}
|
|
|
|
if (ip->i_cowfp) {
|
|
|
|
xfs_idestroy_fork(ip->i_cowfp);
|
|
|
|
kmem_cache_free(xfs_ifork_zone, ip->i_cowfp);
|
|
|
|
}
|
2012-10-08 14:56:11 +04:00
|
|
|
if (ip->i_itemp) {
|
2018-05-09 17:47:34 +03:00
|
|
|
ASSERT(!test_bit(XFS_LI_IN_AIL,
|
|
|
|
&ip->i_itemp->ili_item.li_flags));
|
2012-10-08 14:56:11 +04:00
|
|
|
xfs_inode_item_destroy(ip);
|
|
|
|
ip->i_itemp = NULL;
|
|
|
|
}
|
|
|
|
|
2019-11-14 23:43:04 +03:00
|
|
|
kmem_cache_free(xfs_inode_zone, ip);
|
xfs: xfs_inode_free() isn't RCU safe
The xfs_inode freed in xfs_inode_free() has multiple allocated
structures attached to it. We free these in xfs_inode_free() before
we mark the inode as invalid, and before we run call_rcu() to queue
the structure for freeing.
Unfortunately, this freeing can race with other accesses that are in
the RCU current grace period that have found the inode in the radix
tree with a valid state. This includes xfs_iflush_cluster(), which
calls xfs_inode_clean(), and that accesses the inode log item on the
xfs_inode.
The log item structure is freed in xfs_inode_free(), so there is the
possibility we can be accessing freed memory in xfs_iflush_cluster()
after validating the xfs_inode structure as being valid for this RCU
context. Hence we can get spuriously incorrect clean state returned
from such checks. This can lead to use thinking the inode is dirty
when it is, in fact, clean, and so incorrectly attaching it to the
buffer for IO and completion processing.
This then leads to use-after-free situations on the xfs_inode itself
if the IO completes after the current RCU grace period expires. The
buffer callbacks will access the xfs_inode and try to do all sorts
of things it shouldn't with freed memory.
IOWs, xfs_iflush_cluster() only works correctly when racing with
inode reclaim if the inode log item is present and correctly stating
the inode is clean. If the inode is being freed, then reclaim has
already made sure the inode is clean, and hence xfs_iflush_cluster
can skip it. However, we are accessing the inode inode under RCU
read lock protection and so also must ensure that all dynamically
allocated memory we reference in this context is not freed until the
RCU grace period expires.
To fix this, move all the potential memory freeing into
xfs_inode_free_callback() so that we are guarantee RCU protected
lookup code will always have the memory structures it needs
available during the RCU grace period that lookup races can occur
in.
Discovered-by: Brain Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-05-18 07:01:53 +03:00
|
|
|
}
|
|
|
|
|
2016-05-18 07:09:12 +03:00
|
|
|
static void
|
|
|
|
__xfs_inode_free(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
/* asserts to verify all state is correct here */
|
|
|
|
ASSERT(atomic_read(&ip->i_pincount) == 0);
|
2020-06-30 00:49:18 +03:00
|
|
|
ASSERT(!ip->i_itemp || list_empty(&ip->i_itemp->ili_item.li_bio_list));
|
2016-05-18 07:09:12 +03:00
|
|
|
XFS_STATS_DEC(ip->i_mount, vn_active);
|
|
|
|
|
|
|
|
call_rcu(&VFS_I(ip)->i_rcu, xfs_inode_free_callback);
|
|
|
|
}
|
|
|
|
|
xfs: xfs_inode_free() isn't RCU safe
The xfs_inode freed in xfs_inode_free() has multiple allocated
structures attached to it. We free these in xfs_inode_free() before
we mark the inode as invalid, and before we run call_rcu() to queue
the structure for freeing.
Unfortunately, this freeing can race with other accesses that are in
the RCU current grace period that have found the inode in the radix
tree with a valid state. This includes xfs_iflush_cluster(), which
calls xfs_inode_clean(), and that accesses the inode log item on the
xfs_inode.
The log item structure is freed in xfs_inode_free(), so there is the
possibility we can be accessing freed memory in xfs_iflush_cluster()
after validating the xfs_inode structure as being valid for this RCU
context. Hence we can get spuriously incorrect clean state returned
from such checks. This can lead to use thinking the inode is dirty
when it is, in fact, clean, and so incorrectly attaching it to the
buffer for IO and completion processing.
This then leads to use-after-free situations on the xfs_inode itself
if the IO completes after the current RCU grace period expires. The
buffer callbacks will access the xfs_inode and try to do all sorts
of things it shouldn't with freed memory.
IOWs, xfs_iflush_cluster() only works correctly when racing with
inode reclaim if the inode log item is present and correctly stating
the inode is clean. If the inode is being freed, then reclaim has
already made sure the inode is clean, and hence xfs_iflush_cluster
can skip it. However, we are accessing the inode inode under RCU
read lock protection and so also must ensure that all dynamically
allocated memory we reference in this context is not freed until the
RCU grace period expires.
To fix this, move all the potential memory freeing into
xfs_inode_free_callback() so that we are guarantee RCU protected
lookup code will always have the memory structures it needs
available during the RCU grace period that lookup races can occur
in.
Discovered-by: Brain Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-05-18 07:01:53 +03:00
|
|
|
void
|
|
|
|
xfs_inode_free(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
2020-08-18 02:41:01 +03:00
|
|
|
ASSERT(!xfs_iflags_test(ip, XFS_IFLUSHING));
|
2016-11-10 00:23:22 +03:00
|
|
|
|
2012-10-08 14:56:11 +04:00
|
|
|
/*
|
|
|
|
* Because we use RCU freeing we need to ensure the inode always
|
|
|
|
* appears to be reclaimed with an invalid inode number when in the
|
|
|
|
* free state. The ip->i_flags_lock provides the barrier against lookup
|
|
|
|
* races.
|
|
|
|
*/
|
|
|
|
spin_lock(&ip->i_flags_lock);
|
|
|
|
ip->i_flags = XFS_IRECLAIM;
|
|
|
|
ip->i_ino = 0;
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
|
2016-05-18 07:09:12 +03:00
|
|
|
__xfs_inode_free(ip);
|
2012-10-08 14:56:11 +04:00
|
|
|
}
|
|
|
|
|
2016-05-18 07:20:08 +03:00
|
|
|
/*
|
2020-06-30 00:49:18 +03:00
|
|
|
* Queue background inode reclaim work if there are reclaimable inodes and there
|
|
|
|
* isn't reclaim work already scheduled or in progress.
|
2016-05-18 07:20:08 +03:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
xfs_reclaim_work_queue(
|
|
|
|
struct xfs_mount *mp)
|
|
|
|
{
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
if (radix_tree_tagged(&mp->m_perag_tree, XFS_ICI_RECLAIM_TAG)) {
|
|
|
|
queue_delayed_work(mp->m_reclaim_workqueue, &mp->m_reclaim_work,
|
|
|
|
msecs_to_jiffies(xfs_syncd_centisecs / 6 * 10));
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xfs_perag_set_reclaim_tag(
|
|
|
|
struct xfs_perag *pag)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = pag->pag_mount;
|
|
|
|
|
2017-06-08 18:23:07 +03:00
|
|
|
lockdep_assert_held(&pag->pag_ici_lock);
|
2016-05-18 07:20:08 +03:00
|
|
|
if (pag->pag_ici_reclaimable++)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* propagate the reclaim tag up into the perag radix tree */
|
|
|
|
spin_lock(&mp->m_perag_lock);
|
|
|
|
radix_tree_tag_set(&mp->m_perag_tree, pag->pag_agno,
|
|
|
|
XFS_ICI_RECLAIM_TAG);
|
|
|
|
spin_unlock(&mp->m_perag_lock);
|
|
|
|
|
|
|
|
/* schedule periodic background inode reclaim */
|
|
|
|
xfs_reclaim_work_queue(mp);
|
|
|
|
|
|
|
|
trace_xfs_perag_set_reclaim(mp, pag->pag_agno, -1, _RET_IP_);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xfs_perag_clear_reclaim_tag(
|
|
|
|
struct xfs_perag *pag)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = pag->pag_mount;
|
|
|
|
|
2017-06-08 18:23:07 +03:00
|
|
|
lockdep_assert_held(&pag->pag_ici_lock);
|
2016-05-18 07:20:08 +03:00
|
|
|
if (--pag->pag_ici_reclaimable)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* clear the reclaim tag from the perag radix tree */
|
|
|
|
spin_lock(&mp->m_perag_lock);
|
|
|
|
radix_tree_tag_clear(&mp->m_perag_tree, pag->pag_agno,
|
|
|
|
XFS_ICI_RECLAIM_TAG);
|
|
|
|
spin_unlock(&mp->m_perag_lock);
|
|
|
|
trace_xfs_perag_clear_reclaim(mp, pag->pag_agno, -1, _RET_IP_);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We set the inode flag atomically with the radix tree tag.
|
|
|
|
* Once we get tag lookups on the radix tree, this inode flag
|
|
|
|
* can go away.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_inode_set_reclaim_tag(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
|
|
|
|
pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
|
|
|
|
spin_lock(&pag->pag_ici_lock);
|
|
|
|
spin_lock(&ip->i_flags_lock);
|
|
|
|
|
|
|
|
radix_tree_tag_set(&pag->pag_ici_root, XFS_INO_TO_AGINO(mp, ip->i_ino),
|
|
|
|
XFS_ICI_RECLAIM_TAG);
|
|
|
|
xfs_perag_set_reclaim_tag(pag);
|
|
|
|
__xfs_iflags_set(ip, XFS_IRECLAIMABLE);
|
|
|
|
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
spin_unlock(&pag->pag_ici_lock);
|
|
|
|
xfs_perag_put(pag);
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC void
|
|
|
|
xfs_inode_clear_reclaim_tag(
|
|
|
|
struct xfs_perag *pag,
|
|
|
|
xfs_ino_t ino)
|
|
|
|
{
|
|
|
|
radix_tree_tag_clear(&pag->pag_ici_root,
|
|
|
|
XFS_INO_TO_AGINO(pag->pag_mount, ino),
|
|
|
|
XFS_ICI_RECLAIM_TAG);
|
|
|
|
xfs_perag_clear_reclaim_tag(pag);
|
|
|
|
}
|
|
|
|
|
2017-04-26 18:30:39 +03:00
|
|
|
static void
|
|
|
|
xfs_inew_wait(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_INEW_BIT);
|
|
|
|
DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_INEW_BIT);
|
|
|
|
|
|
|
|
do {
|
2017-03-05 13:25:39 +03:00
|
|
|
prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
|
2017-04-26 18:30:39 +03:00
|
|
|
if (!xfs_iflags_test(ip, XFS_INEW))
|
|
|
|
break;
|
|
|
|
schedule();
|
|
|
|
} while (true);
|
2017-03-05 13:25:39 +03:00
|
|
|
finish_wait(wq, &wait.wq_entry);
|
2017-04-26 18:30:39 +03:00
|
|
|
}
|
|
|
|
|
2016-02-09 08:54:58 +03:00
|
|
|
/*
|
|
|
|
* When we recycle a reclaimable inode, we need to re-initialise the VFS inode
|
|
|
|
* part of the structure. This is made more complex by the fact we store
|
|
|
|
* information about the on-disk values in the VFS inode and so we can't just
|
2016-02-09 08:54:58 +03:00
|
|
|
* overwrite the values unconditionally. Hence we save the parameters we
|
2016-02-09 08:54:58 +03:00
|
|
|
* need to retain across reinitialisation, and rewrite them into the VFS inode
|
2016-02-09 08:54:58 +03:00
|
|
|
* after reinitialisation even if it fails.
|
2016-02-09 08:54:58 +03:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_reinit_inode(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct inode *inode)
|
|
|
|
{
|
|
|
|
int error;
|
2016-02-09 08:54:58 +03:00
|
|
|
uint32_t nlink = inode->i_nlink;
|
2016-02-09 08:54:58 +03:00
|
|
|
uint32_t generation = inode->i_generation;
|
2017-12-11 14:35:19 +03:00
|
|
|
uint64_t version = inode_peek_iversion(inode);
|
2016-02-09 08:54:58 +03:00
|
|
|
umode_t mode = inode->i_mode;
|
2018-01-26 22:24:40 +03:00
|
|
|
dev_t dev = inode->i_rdev;
|
2020-02-21 19:31:26 +03:00
|
|
|
kuid_t uid = inode->i_uid;
|
|
|
|
kgid_t gid = inode->i_gid;
|
2016-02-09 08:54:58 +03:00
|
|
|
|
|
|
|
error = inode_init_always(mp->m_super, inode);
|
|
|
|
|
2016-02-09 08:54:58 +03:00
|
|
|
set_nlink(inode, nlink);
|
2016-02-09 08:54:58 +03:00
|
|
|
inode->i_generation = generation;
|
2017-12-11 14:35:19 +03:00
|
|
|
inode_set_iversion_queried(inode, version);
|
2016-02-09 08:54:58 +03:00
|
|
|
inode->i_mode = mode;
|
2018-01-26 22:24:40 +03:00
|
|
|
inode->i_rdev = dev;
|
2020-02-21 19:31:26 +03:00
|
|
|
inode->i_uid = uid;
|
|
|
|
inode->i_gid = gid;
|
2016-02-09 08:54:58 +03:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2018-04-18 03:17:34 +03:00
|
|
|
/*
|
|
|
|
* If we are allocating a new inode, then check what was returned is
|
|
|
|
* actually a free, empty inode. If we are not allocating an inode,
|
|
|
|
* then check we didn't find a free inode.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* 0 if the inode free state matches the lookup context
|
|
|
|
* -ENOENT if the inode is free and we are not allocating
|
|
|
|
* -EFSCORRUPTED if there is any state mismatch at all
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_iget_check_free_state(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
if (flags & XFS_IGET_CREATE) {
|
|
|
|
/* should be a free inode */
|
|
|
|
if (VFS_I(ip)->i_mode != 0) {
|
|
|
|
xfs_warn(ip->i_mount,
|
|
|
|
"Corruption detected! Free inode 0x%llx not marked free! (mode 0x%x)",
|
|
|
|
ip->i_ino, VFS_I(ip)->i_mode);
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ip->i_d.di_nblocks != 0) {
|
|
|
|
xfs_warn(ip->i_mount,
|
|
|
|
"Corruption detected! Free inode 0x%llx has blocks allocated!",
|
|
|
|
ip->i_ino);
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* should be an allocated inode */
|
|
|
|
if (VFS_I(ip)->i_mode == 0)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-08 14:56:11 +04:00
|
|
|
/*
|
|
|
|
* Check the validity of the inode we just found it the cache
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_iget_cache_hit(
|
|
|
|
struct xfs_perag *pag,
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
xfs_ino_t ino,
|
|
|
|
int flags,
|
|
|
|
int lock_flags) __releases(RCU)
|
|
|
|
{
|
|
|
|
struct inode *inode = VFS_I(ip);
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check for re-use of an inode within an RCU grace period due to the
|
|
|
|
* radix tree nodes not being updated yet. We monitor for this by
|
|
|
|
* setting the inode number to zero before freeing the inode structure.
|
|
|
|
* If the inode has been reallocated and set up, then the inode number
|
|
|
|
* will not match, so check for that, too.
|
|
|
|
*/
|
|
|
|
spin_lock(&ip->i_flags_lock);
|
|
|
|
if (ip->i_ino != ino) {
|
|
|
|
trace_xfs_iget_skip(ip);
|
2015-10-12 10:21:22 +03:00
|
|
|
XFS_STATS_INC(mp, xs_ig_frecycle);
|
2014-06-25 08:58:08 +04:00
|
|
|
error = -EAGAIN;
|
2012-10-08 14:56:11 +04:00
|
|
|
goto out_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are racing with another cache hit that is currently
|
|
|
|
* instantiating this inode or currently recycling it out of
|
|
|
|
* reclaimabe state, wait for the initialisation to complete
|
|
|
|
* before continuing.
|
|
|
|
*
|
|
|
|
* XXX(hch): eventually we should do something equivalent to
|
|
|
|
* wait_on_inode to wait for these flags to be cleared
|
|
|
|
* instead of polling for it.
|
|
|
|
*/
|
|
|
|
if (ip->i_flags & (XFS_INEW|XFS_IRECLAIM)) {
|
|
|
|
trace_xfs_iget_skip(ip);
|
2015-10-12 10:21:22 +03:00
|
|
|
XFS_STATS_INC(mp, xs_ig_frecycle);
|
2014-06-25 08:58:08 +04:00
|
|
|
error = -EAGAIN;
|
2012-10-08 14:56:11 +04:00
|
|
|
goto out_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2018-04-18 03:17:34 +03:00
|
|
|
* Check the inode free state is valid. This also detects lookup
|
|
|
|
* racing with unlinks.
|
2012-10-08 14:56:11 +04:00
|
|
|
*/
|
2018-04-18 03:17:34 +03:00
|
|
|
error = xfs_iget_check_free_state(ip, flags);
|
|
|
|
if (error)
|
2012-10-08 14:56:11 +04:00
|
|
|
goto out_error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If IRECLAIMABLE is set, we've torn down the VFS inode already.
|
|
|
|
* Need to carefully get it back into useable state.
|
|
|
|
*/
|
|
|
|
if (ip->i_flags & XFS_IRECLAIMABLE) {
|
|
|
|
trace_xfs_iget_reclaim(ip);
|
|
|
|
|
2017-06-19 18:58:56 +03:00
|
|
|
if (flags & XFS_IGET_INCORE) {
|
|
|
|
error = -EAGAIN;
|
|
|
|
goto out_error;
|
|
|
|
}
|
|
|
|
|
2012-10-08 14:56:11 +04:00
|
|
|
/*
|
|
|
|
* We need to set XFS_IRECLAIM to prevent xfs_reclaim_inode
|
|
|
|
* from stomping over us while we recycle the inode. We can't
|
|
|
|
* clear the radix tree reclaimable tag yet as it requires
|
|
|
|
* pag_ici_lock to be held exclusive.
|
|
|
|
*/
|
|
|
|
ip->i_flags |= XFS_IRECLAIM;
|
|
|
|
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
2020-04-23 07:50:57 +03:00
|
|
|
ASSERT(!rwsem_is_locked(&inode->i_rwsem));
|
2016-02-09 08:54:58 +03:00
|
|
|
error = xfs_reinit_inode(mp, inode);
|
2012-10-08 14:56:11 +04:00
|
|
|
if (error) {
|
2017-04-26 18:30:39 +03:00
|
|
|
bool wake;
|
2012-10-08 14:56:11 +04:00
|
|
|
/*
|
|
|
|
* Re-initializing the inode failed, and we are in deep
|
|
|
|
* trouble. Try to re-add it to the reclaim list.
|
|
|
|
*/
|
|
|
|
rcu_read_lock();
|
|
|
|
spin_lock(&ip->i_flags_lock);
|
2017-04-26 18:30:39 +03:00
|
|
|
wake = !!__xfs_iflags_test(ip, XFS_INEW);
|
2012-10-08 14:56:11 +04:00
|
|
|
ip->i_flags &= ~(XFS_INEW | XFS_IRECLAIM);
|
2017-04-26 18:30:39 +03:00
|
|
|
if (wake)
|
|
|
|
wake_up_bit(&ip->i_flags, __XFS_INEW_BIT);
|
2012-10-08 14:56:11 +04:00
|
|
|
ASSERT(ip->i_flags & XFS_IRECLAIMABLE);
|
|
|
|
trace_xfs_iget_reclaim_fail(ip);
|
|
|
|
goto out_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock(&pag->pag_ici_lock);
|
|
|
|
spin_lock(&ip->i_flags_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear the per-lifetime state in the inode as we are now
|
|
|
|
* effectively a new inode and need to return to the initial
|
|
|
|
* state before reuse occurs.
|
|
|
|
*/
|
|
|
|
ip->i_flags &= ~XFS_IRECLAIM_RESET_FLAGS;
|
|
|
|
ip->i_flags |= XFS_INEW;
|
2016-05-18 07:11:41 +03:00
|
|
|
xfs_inode_clear_reclaim_tag(pag, ip->i_ino);
|
2012-10-08 14:56:11 +04:00
|
|
|
inode->i_state = I_NEW;
|
2019-04-12 17:40:25 +03:00
|
|
|
ip->i_sick = 0;
|
|
|
|
ip->i_checked = 0;
|
2012-10-08 14:56:11 +04:00
|
|
|
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
spin_unlock(&pag->pag_ici_lock);
|
|
|
|
} else {
|
|
|
|
/* If the VFS inode is being torn down, pause and try again. */
|
|
|
|
if (!igrab(inode)) {
|
|
|
|
trace_xfs_iget_skip(ip);
|
2014-06-25 08:58:08 +04:00
|
|
|
error = -EAGAIN;
|
2012-10-08 14:56:11 +04:00
|
|
|
goto out_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We've got a live one. */
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
rcu_read_unlock();
|
|
|
|
trace_xfs_iget_hit(ip);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lock_flags != 0)
|
|
|
|
xfs_ilock(ip, lock_flags);
|
|
|
|
|
2017-06-19 18:58:56 +03:00
|
|
|
if (!(flags & XFS_IGET_INCORE))
|
2020-04-30 17:41:37 +03:00
|
|
|
xfs_iflags_clear(ip, XFS_ISTALE);
|
2015-10-12 10:21:22 +03:00
|
|
|
XFS_STATS_INC(mp, xs_ig_found);
|
2012-10-08 14:56:11 +04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_error:
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
xfs_iget_cache_miss(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_perag *pag,
|
|
|
|
xfs_trans_t *tp,
|
|
|
|
xfs_ino_t ino,
|
|
|
|
struct xfs_inode **ipp,
|
|
|
|
int flags,
|
|
|
|
int lock_flags)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip;
|
|
|
|
int error;
|
|
|
|
xfs_agino_t agino = XFS_INO_TO_AGINO(mp, ino);
|
|
|
|
int iflags;
|
|
|
|
|
|
|
|
ip = xfs_inode_alloc(mp, ino);
|
|
|
|
if (!ip)
|
2014-06-25 08:58:08 +04:00
|
|
|
return -ENOMEM;
|
2012-10-08 14:56:11 +04:00
|
|
|
|
2020-05-15 00:01:19 +03:00
|
|
|
error = xfs_imap(mp, tp, ip->i_ino, &ip->i_imap, flags);
|
2012-10-08 14:56:11 +04:00
|
|
|
if (error)
|
|
|
|
goto out_destroy;
|
|
|
|
|
2020-05-15 00:01:19 +03:00
|
|
|
/*
|
|
|
|
* For version 5 superblocks, if we are initialising a new inode and we
|
|
|
|
* are not utilising the XFS_MOUNT_IKEEP inode cluster mode, we can
|
|
|
|
* simply build the new inode core with a random generation number.
|
|
|
|
*
|
|
|
|
* For version 4 (and older) superblocks, log recovery is dependent on
|
|
|
|
* the di_flushiter field being initialised from the current on-disk
|
|
|
|
* value and hence we must also read the inode off disk even when
|
|
|
|
* initializing new inodes.
|
|
|
|
*/
|
|
|
|
if (xfs_sb_version_has_v3inode(&mp->m_sb) &&
|
|
|
|
(flags & XFS_IGET_CREATE) && !(mp->m_flags & XFS_MOUNT_IKEEP)) {
|
|
|
|
VFS_I(ip)->i_generation = prandom_u32();
|
|
|
|
} else {
|
|
|
|
struct xfs_dinode *dip;
|
|
|
|
struct xfs_buf *bp;
|
|
|
|
|
|
|
|
error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &bp, 0);
|
|
|
|
if (error)
|
|
|
|
goto out_destroy;
|
|
|
|
|
|
|
|
error = xfs_inode_from_disk(ip, dip);
|
|
|
|
if (!error)
|
|
|
|
xfs_buf_set_ref(bp, XFS_INO_REF);
|
|
|
|
xfs_trans_brelse(tp, bp);
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
goto out_destroy;
|
|
|
|
}
|
|
|
|
|
2012-10-08 14:56:11 +04:00
|
|
|
trace_xfs_iget_miss(ip);
|
|
|
|
|
xfs: catch inode allocation state mismatch corruption
We recently came across a V4 filesystem causing memory corruption
due to a newly allocated inode being setup twice and being added to
the superblock inode list twice. From code inspection, the only way
this could happen is if a newly allocated inode was not marked as
free on disk (i.e. di_mode wasn't zero).
Running the metadump on an upstream debug kernel fails during inode
allocation like so:
XFS: Assertion failed: ip->i_d.di_nblocks == 0, file: fs/xfs/xfs_inod=
e.c, line: 838
------------[ cut here ]------------
kernel BUG at fs/xfs/xfs_message.c:114!
invalid opcode: 0000 [#1] PREEMPT SMP
CPU: 11 PID: 3496 Comm: mkdir Not tainted 4.16.0-rc5-dgc #442
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.10.2-1 04/0=
1/2014
RIP: 0010:assfail+0x28/0x30
RSP: 0018:ffffc9000236fc80 EFLAGS: 00010202
RAX: 00000000ffffffea RBX: 0000000000004000 RCX: 0000000000000000
RDX: 00000000ffffffc0 RSI: 000000000000000a RDI: ffffffff8227211b
RBP: ffffc9000236fce8 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000bec R11: f000000000000000 R12: ffffc9000236fd30
R13: ffff8805c76bab80 R14: ffff8805c77ac800 R15: ffff88083fb12e10
FS: 00007fac8cbff040(0000) GS:ffff88083fd00000(0000) knlGS:0000000000000=
000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007fffa6783ff8 CR3: 00000005c6e2b003 CR4: 00000000000606e0
Call Trace:
xfs_ialloc+0x383/0x570
xfs_dir_ialloc+0x6a/0x2a0
xfs_create+0x412/0x670
xfs_generic_create+0x1f7/0x2c0
? capable_wrt_inode_uidgid+0x3f/0x50
vfs_mkdir+0xfb/0x1b0
SyS_mkdir+0xcf/0xf0
do_syscall_64+0x73/0x1a0
entry_SYSCALL_64_after_hwframe+0x42/0xb7
Extracting the inode number we crashed on from an event trace and
looking at it with xfs_db:
xfs_db> inode 184452204
xfs_db> p
core.magic = 0x494e
core.mode = 0100644
core.version = 2
core.format = 2 (extents)
core.nlinkv2 = 1
core.onlink = 0
.....
Confirms that it is not a free inode on disk. xfs_repair
also trips over this inode:
.....
zero length extent (off = 0, fsbno = 0) in ino 184452204
correcting nextents for inode 184452204
bad attribute fork in inode 184452204, would clear attr fork
bad nblocks 1 for inode 184452204, would reset to 0
bad anextents 1 for inode 184452204, would reset to 0
imap claims in-use inode 184452204 is free, would correct imap
would have cleared inode 184452204
.....
disconnected inode 184452204, would move to lost+found
And so we have a situation where the directory structure and the
inobt thinks the inode is free, but the inode on disk thinks it is
still in use. Where this corruption came from is not possible to
diagnose, but we can detect it and prevent the kernel from oopsing
on lookup. The reproducer now results in:
$ sudo mkdir /mnt/scratch/{0,1,2,3,4,5}{0,1,2,3,4,5}
mkdir: cannot create directory =E2=80=98/mnt/scratch/00=E2=80=99: File ex=
ists
mkdir: cannot create directory =E2=80=98/mnt/scratch/01=E2=80=99: File ex=
ists
mkdir: cannot create directory =E2=80=98/mnt/scratch/03=E2=80=99: Structu=
re needs cleaning
mkdir: cannot create directory =E2=80=98/mnt/scratch/04=E2=80=99: Input/o=
utput error
mkdir: cannot create directory =E2=80=98/mnt/scratch/05=E2=80=99: Input/o=
utput error
....
And this corruption shutdown:
[ 54.843517] XFS (loop0): Corruption detected! Free inode 0xafe846c not=
marked free on disk
[ 54.845885] XFS (loop0): Internal error xfs_trans_cancel at line 1023 =
of file fs/xfs/xfs_trans.c. Caller xfs_create+0x425/0x670
[ 54.848994] CPU: 10 PID: 3541 Comm: mkdir Not tainted 4.16.0-rc5-dgc #=
443
[ 54.850753] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIO=
S 1.10.2-1 04/01/2014
[ 54.852859] Call Trace:
[ 54.853531] dump_stack+0x85/0xc5
[ 54.854385] xfs_trans_cancel+0x197/0x1c0
[ 54.855421] xfs_create+0x425/0x670
[ 54.856314] xfs_generic_create+0x1f7/0x2c0
[ 54.857390] ? capable_wrt_inode_uidgid+0x3f/0x50
[ 54.858586] vfs_mkdir+0xfb/0x1b0
[ 54.859458] SyS_mkdir+0xcf/0xf0
[ 54.860254] do_syscall_64+0x73/0x1a0
[ 54.861193] entry_SYSCALL_64_after_hwframe+0x42/0xb7
[ 54.862492] RIP: 0033:0x7fb73bddf547
[ 54.863358] RSP: 002b:00007ffdaa553338 EFLAGS: 00000246 ORIG_RAX: 0000=
000000000053
[ 54.865133] RAX: ffffffffffffffda RBX: 00007ffdaa55449a RCX: 00007fb73=
bddf547
[ 54.866766] RDX: 0000000000000001 RSI: 00000000000001ff RDI: 00007ffda=
a55449a
[ 54.868432] RBP: 00007ffdaa55449a R08: 00000000000001ff R09: 00005623a=
8670dd0
[ 54.870110] R10: 00007fb73be72d5b R11: 0000000000000246 R12: 000000000=
00001ff
[ 54.871752] R13: 00007ffdaa5534b0 R14: 0000000000000000 R15: 00007ffda=
a553500
[ 54.873429] XFS (loop0): xfs_do_force_shutdown(0x8) called from line 1=
024 of file fs/xfs/xfs_trans.c. Return address = ffffffff814cd050
[ 54.882790] XFS (loop0): Corruption of in-memory data detected. Shutt=
ing down filesystem
[ 54.884597] XFS (loop0): Please umount the filesystem and rectify the =
problem(s)
Note that this crash is only possible on v4 filesystemsi or v5
filesystems mounted with the ikeep mount option. For all other V5
filesystems, this problem cannot occur because we don't read inodes
we are allocating from disk - we simply overwrite them with the new
inode information.
Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com>
Tested-by: Carlos Maiolino <cmaiolino@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2018-03-23 20:22:53 +03:00
|
|
|
/*
|
2018-04-18 03:17:34 +03:00
|
|
|
* Check the inode free state is valid. This also detects lookup
|
|
|
|
* racing with unlinks.
|
xfs: catch inode allocation state mismatch corruption
We recently came across a V4 filesystem causing memory corruption
due to a newly allocated inode being setup twice and being added to
the superblock inode list twice. From code inspection, the only way
this could happen is if a newly allocated inode was not marked as
free on disk (i.e. di_mode wasn't zero).
Running the metadump on an upstream debug kernel fails during inode
allocation like so:
XFS: Assertion failed: ip->i_d.di_nblocks == 0, file: fs/xfs/xfs_inod=
e.c, line: 838
------------[ cut here ]------------
kernel BUG at fs/xfs/xfs_message.c:114!
invalid opcode: 0000 [#1] PREEMPT SMP
CPU: 11 PID: 3496 Comm: mkdir Not tainted 4.16.0-rc5-dgc #442
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.10.2-1 04/0=
1/2014
RIP: 0010:assfail+0x28/0x30
RSP: 0018:ffffc9000236fc80 EFLAGS: 00010202
RAX: 00000000ffffffea RBX: 0000000000004000 RCX: 0000000000000000
RDX: 00000000ffffffc0 RSI: 000000000000000a RDI: ffffffff8227211b
RBP: ffffc9000236fce8 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000bec R11: f000000000000000 R12: ffffc9000236fd30
R13: ffff8805c76bab80 R14: ffff8805c77ac800 R15: ffff88083fb12e10
FS: 00007fac8cbff040(0000) GS:ffff88083fd00000(0000) knlGS:0000000000000=
000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007fffa6783ff8 CR3: 00000005c6e2b003 CR4: 00000000000606e0
Call Trace:
xfs_ialloc+0x383/0x570
xfs_dir_ialloc+0x6a/0x2a0
xfs_create+0x412/0x670
xfs_generic_create+0x1f7/0x2c0
? capable_wrt_inode_uidgid+0x3f/0x50
vfs_mkdir+0xfb/0x1b0
SyS_mkdir+0xcf/0xf0
do_syscall_64+0x73/0x1a0
entry_SYSCALL_64_after_hwframe+0x42/0xb7
Extracting the inode number we crashed on from an event trace and
looking at it with xfs_db:
xfs_db> inode 184452204
xfs_db> p
core.magic = 0x494e
core.mode = 0100644
core.version = 2
core.format = 2 (extents)
core.nlinkv2 = 1
core.onlink = 0
.....
Confirms that it is not a free inode on disk. xfs_repair
also trips over this inode:
.....
zero length extent (off = 0, fsbno = 0) in ino 184452204
correcting nextents for inode 184452204
bad attribute fork in inode 184452204, would clear attr fork
bad nblocks 1 for inode 184452204, would reset to 0
bad anextents 1 for inode 184452204, would reset to 0
imap claims in-use inode 184452204 is free, would correct imap
would have cleared inode 184452204
.....
disconnected inode 184452204, would move to lost+found
And so we have a situation where the directory structure and the
inobt thinks the inode is free, but the inode on disk thinks it is
still in use. Where this corruption came from is not possible to
diagnose, but we can detect it and prevent the kernel from oopsing
on lookup. The reproducer now results in:
$ sudo mkdir /mnt/scratch/{0,1,2,3,4,5}{0,1,2,3,4,5}
mkdir: cannot create directory =E2=80=98/mnt/scratch/00=E2=80=99: File ex=
ists
mkdir: cannot create directory =E2=80=98/mnt/scratch/01=E2=80=99: File ex=
ists
mkdir: cannot create directory =E2=80=98/mnt/scratch/03=E2=80=99: Structu=
re needs cleaning
mkdir: cannot create directory =E2=80=98/mnt/scratch/04=E2=80=99: Input/o=
utput error
mkdir: cannot create directory =E2=80=98/mnt/scratch/05=E2=80=99: Input/o=
utput error
....
And this corruption shutdown:
[ 54.843517] XFS (loop0): Corruption detected! Free inode 0xafe846c not=
marked free on disk
[ 54.845885] XFS (loop0): Internal error xfs_trans_cancel at line 1023 =
of file fs/xfs/xfs_trans.c. Caller xfs_create+0x425/0x670
[ 54.848994] CPU: 10 PID: 3541 Comm: mkdir Not tainted 4.16.0-rc5-dgc #=
443
[ 54.850753] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIO=
S 1.10.2-1 04/01/2014
[ 54.852859] Call Trace:
[ 54.853531] dump_stack+0x85/0xc5
[ 54.854385] xfs_trans_cancel+0x197/0x1c0
[ 54.855421] xfs_create+0x425/0x670
[ 54.856314] xfs_generic_create+0x1f7/0x2c0
[ 54.857390] ? capable_wrt_inode_uidgid+0x3f/0x50
[ 54.858586] vfs_mkdir+0xfb/0x1b0
[ 54.859458] SyS_mkdir+0xcf/0xf0
[ 54.860254] do_syscall_64+0x73/0x1a0
[ 54.861193] entry_SYSCALL_64_after_hwframe+0x42/0xb7
[ 54.862492] RIP: 0033:0x7fb73bddf547
[ 54.863358] RSP: 002b:00007ffdaa553338 EFLAGS: 00000246 ORIG_RAX: 0000=
000000000053
[ 54.865133] RAX: ffffffffffffffda RBX: 00007ffdaa55449a RCX: 00007fb73=
bddf547
[ 54.866766] RDX: 0000000000000001 RSI: 00000000000001ff RDI: 00007ffda=
a55449a
[ 54.868432] RBP: 00007ffdaa55449a R08: 00000000000001ff R09: 00005623a=
8670dd0
[ 54.870110] R10: 00007fb73be72d5b R11: 0000000000000246 R12: 000000000=
00001ff
[ 54.871752] R13: 00007ffdaa5534b0 R14: 0000000000000000 R15: 00007ffda=
a553500
[ 54.873429] XFS (loop0): xfs_do_force_shutdown(0x8) called from line 1=
024 of file fs/xfs/xfs_trans.c. Return address = ffffffff814cd050
[ 54.882790] XFS (loop0): Corruption of in-memory data detected. Shutt=
ing down filesystem
[ 54.884597] XFS (loop0): Please umount the filesystem and rectify the =
problem(s)
Note that this crash is only possible on v4 filesystemsi or v5
filesystems mounted with the ikeep mount option. For all other V5
filesystems, this problem cannot occur because we don't read inodes
we are allocating from disk - we simply overwrite them with the new
inode information.
Signed-Off-By: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com>
Tested-by: Carlos Maiolino <cmaiolino@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2018-03-23 20:22:53 +03:00
|
|
|
*/
|
2018-04-18 03:17:34 +03:00
|
|
|
error = xfs_iget_check_free_state(ip, flags);
|
|
|
|
if (error)
|
2012-10-08 14:56:11 +04:00
|
|
|
goto out_destroy;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Preload the radix tree so we can insert safely under the
|
|
|
|
* write spinlock. Note that we cannot sleep inside the preload
|
|
|
|
* region. Since we can be called from transaction context, don't
|
|
|
|
* recurse into the file system.
|
|
|
|
*/
|
|
|
|
if (radix_tree_preload(GFP_NOFS)) {
|
2014-06-25 08:58:08 +04:00
|
|
|
error = -EAGAIN;
|
2012-10-08 14:56:11 +04:00
|
|
|
goto out_destroy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Because the inode hasn't been added to the radix-tree yet it can't
|
|
|
|
* be found by another thread, so we can do the non-sleeping lock here.
|
|
|
|
*/
|
|
|
|
if (lock_flags) {
|
|
|
|
if (!xfs_ilock_nowait(ip, lock_flags))
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These values must be set before inserting the inode into the radix
|
|
|
|
* tree as the moment it is inserted a concurrent lookup (allowed by the
|
|
|
|
* RCU locking mechanism) can find it and that lookup must see that this
|
|
|
|
* is an inode currently under construction (i.e. that XFS_INEW is set).
|
|
|
|
* The ip->i_flags_lock that protects the XFS_INEW flag forms the
|
|
|
|
* memory barrier that ensures this detection works correctly at lookup
|
|
|
|
* time.
|
|
|
|
*/
|
|
|
|
iflags = XFS_INEW;
|
|
|
|
if (flags & XFS_IGET_DONTCACHE)
|
2020-04-30 17:41:37 +03:00
|
|
|
d_mark_dontcache(VFS_I(ip));
|
2013-06-28 02:25:07 +04:00
|
|
|
ip->i_udquot = NULL;
|
|
|
|
ip->i_gdquot = NULL;
|
2013-07-11 09:00:40 +04:00
|
|
|
ip->i_pdquot = NULL;
|
2012-10-08 14:56:11 +04:00
|
|
|
xfs_iflags_set(ip, iflags);
|
|
|
|
|
|
|
|
/* insert the new inode */
|
|
|
|
spin_lock(&pag->pag_ici_lock);
|
|
|
|
error = radix_tree_insert(&pag->pag_ici_root, agino, ip);
|
|
|
|
if (unlikely(error)) {
|
|
|
|
WARN_ON(error != -EEXIST);
|
2015-10-12 10:21:22 +03:00
|
|
|
XFS_STATS_INC(mp, xs_ig_dup);
|
2014-06-25 08:58:08 +04:00
|
|
|
error = -EAGAIN;
|
2012-10-08 14:56:11 +04:00
|
|
|
goto out_preload_end;
|
|
|
|
}
|
|
|
|
spin_unlock(&pag->pag_ici_lock);
|
|
|
|
radix_tree_preload_end();
|
|
|
|
|
|
|
|
*ipp = ip;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_preload_end:
|
|
|
|
spin_unlock(&pag->pag_ici_lock);
|
|
|
|
radix_tree_preload_end();
|
|
|
|
if (lock_flags)
|
|
|
|
xfs_iunlock(ip, lock_flags);
|
|
|
|
out_destroy:
|
|
|
|
__destroy_inode(VFS_I(ip));
|
|
|
|
xfs_inode_free(ip);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2020-06-30 00:49:18 +03:00
|
|
|
* Look up an inode by number in the given file system. The inode is looked up
|
|
|
|
* in the cache held in each AG. If the inode is found in the cache, initialise
|
|
|
|
* the vfs inode if necessary.
|
2012-10-08 14:56:11 +04:00
|
|
|
*
|
2020-06-30 00:49:18 +03:00
|
|
|
* If it is not in core, read it in from the file system's device, add it to the
|
|
|
|
* cache and initialise the vfs inode.
|
2012-10-08 14:56:11 +04:00
|
|
|
*
|
|
|
|
* The inode is locked according to the value of the lock_flags parameter.
|
2020-06-30 00:49:18 +03:00
|
|
|
* Inode lookup is only done during metadata operations and not as part of the
|
|
|
|
* data IO path. Hence we only allow locking of the XFS_ILOCK during lookup.
|
2012-10-08 14:56:11 +04:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_iget(
|
2020-06-30 00:49:18 +03:00
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
xfs_ino_t ino,
|
|
|
|
uint flags,
|
|
|
|
uint lock_flags,
|
|
|
|
struct xfs_inode **ipp)
|
2012-10-08 14:56:11 +04:00
|
|
|
{
|
2020-06-30 00:49:18 +03:00
|
|
|
struct xfs_inode *ip;
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
xfs_agino_t agino;
|
|
|
|
int error;
|
2012-10-08 14:56:11 +04:00
|
|
|
|
|
|
|
ASSERT((lock_flags & (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED)) == 0);
|
|
|
|
|
|
|
|
/* reject inode numbers outside existing AGs */
|
|
|
|
if (!ino || XFS_INO_TO_AGNO(mp, ino) >= mp->m_sb.sb_agcount)
|
2014-06-25 08:58:08 +04:00
|
|
|
return -EINVAL;
|
2012-10-08 14:56:11 +04:00
|
|
|
|
2015-10-12 10:21:22 +03:00
|
|
|
XFS_STATS_INC(mp, xs_ig_attempts);
|
2015-08-28 07:50:56 +03:00
|
|
|
|
2012-10-08 14:56:11 +04:00
|
|
|
/* get the perag structure and ensure that it's inode capable */
|
|
|
|
pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ino));
|
|
|
|
agino = XFS_INO_TO_AGINO(mp, ino);
|
|
|
|
|
|
|
|
again:
|
|
|
|
error = 0;
|
|
|
|
rcu_read_lock();
|
|
|
|
ip = radix_tree_lookup(&pag->pag_ici_root, agino);
|
|
|
|
|
|
|
|
if (ip) {
|
|
|
|
error = xfs_iget_cache_hit(pag, ip, ino, flags, lock_flags);
|
|
|
|
if (error)
|
|
|
|
goto out_error_or_again;
|
|
|
|
} else {
|
|
|
|
rcu_read_unlock();
|
2017-06-19 18:58:56 +03:00
|
|
|
if (flags & XFS_IGET_INCORE) {
|
2017-10-18 07:37:32 +03:00
|
|
|
error = -ENODATA;
|
2017-06-19 18:58:56 +03:00
|
|
|
goto out_error_or_again;
|
|
|
|
}
|
2015-10-12 10:21:22 +03:00
|
|
|
XFS_STATS_INC(mp, xs_ig_missed);
|
2012-10-08 14:56:11 +04:00
|
|
|
|
|
|
|
error = xfs_iget_cache_miss(mp, pag, tp, ino, &ip,
|
|
|
|
flags, lock_flags);
|
|
|
|
if (error)
|
|
|
|
goto out_error_or_again;
|
|
|
|
}
|
|
|
|
xfs_perag_put(pag);
|
|
|
|
|
|
|
|
*ipp = ip;
|
|
|
|
|
|
|
|
/*
|
2015-02-23 14:38:08 +03:00
|
|
|
* If we have a real type for an on-disk inode, we can setup the inode
|
2012-10-08 14:56:11 +04:00
|
|
|
* now. If it's a new inode being created, xfs_ialloc will handle it.
|
|
|
|
*/
|
2016-02-09 08:54:58 +03:00
|
|
|
if (xfs_iflags_test(ip, XFS_INEW) && VFS_I(ip)->i_mode != 0)
|
2015-02-23 14:38:08 +03:00
|
|
|
xfs_setup_existing_inode(ip);
|
2012-10-08 14:56:11 +04:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_error_or_again:
|
2017-06-19 18:58:56 +03:00
|
|
|
if (!(flags & XFS_IGET_INCORE) && error == -EAGAIN) {
|
2012-10-08 14:56:11 +04:00
|
|
|
delay(1);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
xfs_perag_put(pag);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-06-19 18:58:56 +03:00
|
|
|
/*
|
|
|
|
* "Is this a cached inode that's also allocated?"
|
|
|
|
*
|
|
|
|
* Look up an inode by number in the given file system. If the inode is
|
|
|
|
* in cache and isn't in purgatory, return 1 if the inode is allocated
|
|
|
|
* and 0 if it is not. For all other cases (not in cache, being torn
|
|
|
|
* down, etc.), return a negative error code.
|
|
|
|
*
|
|
|
|
* The caller has to prevent inode allocation and freeing activity,
|
|
|
|
* presumably by locking the AGI buffer. This is to ensure that an
|
|
|
|
* inode cannot transition from allocated to freed until the caller is
|
|
|
|
* ready to allow that. If the inode is in an intermediate state (new,
|
|
|
|
* reclaimable, or being reclaimed), -EAGAIN will be returned; if the
|
|
|
|
* inode is not in the cache, -ENOENT will be returned. The caller must
|
|
|
|
* deal with these scenarios appropriately.
|
|
|
|
*
|
|
|
|
* This is a specialized use case for the online scrubber; if you're
|
|
|
|
* reading this, you probably want xfs_iget.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_icache_inode_is_allocated(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
xfs_ino_t ino,
|
|
|
|
bool *inuse)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = xfs_iget(mp, tp, ino, XFS_IGET_INCORE, 0, &ip);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
*inuse = !!(VFS_I(ip)->i_mode);
|
2018-07-25 22:52:32 +03:00
|
|
|
xfs_irele(ip);
|
2017-06-19 18:58:56 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-28 06:28:19 +04:00
|
|
|
/*
|
|
|
|
* The inode lookup is done in batches to keep the amount of lock traffic and
|
|
|
|
* radix tree lookups to a minimum. The batch size is a trade off between
|
|
|
|
* lookup reduction and stack usage. This is in the reclaim path, so we can't
|
|
|
|
* be too greedy.
|
|
|
|
*/
|
|
|
|
#define XFS_LOOKUP_BATCH 32
|
|
|
|
|
2020-05-21 23:08:49 +03:00
|
|
|
/*
|
|
|
|
* Decide if the given @ip is eligible to be a part of the inode walk, and
|
|
|
|
* grab it if so. Returns true if it's ready to go or false if we should just
|
|
|
|
* ignore it.
|
|
|
|
*/
|
|
|
|
STATIC bool
|
2020-05-21 23:08:50 +03:00
|
|
|
xfs_inode_walk_ag_grab(
|
2017-04-26 18:30:39 +03:00
|
|
|
struct xfs_inode *ip,
|
|
|
|
int flags)
|
2010-09-28 06:28:06 +04:00
|
|
|
{
|
|
|
|
struct inode *inode = VFS_I(ip);
|
2020-05-21 23:08:50 +03:00
|
|
|
bool newinos = !!(flags & XFS_INODE_WALK_INEW_WAIT);
|
2010-09-28 06:28:06 +04:00
|
|
|
|
2010-12-17 09:29:43 +03:00
|
|
|
ASSERT(rcu_read_lock_held());
|
|
|
|
|
2020-06-30 00:49:18 +03:00
|
|
|
/* Check for stale RCU freed inode */
|
2010-12-17 09:29:43 +03:00
|
|
|
spin_lock(&ip->i_flags_lock);
|
|
|
|
if (!ip->i_ino)
|
|
|
|
goto out_unlock_noent;
|
|
|
|
|
|
|
|
/* avoid new or reclaimable inodes. Leave for reclaim code to flush */
|
2017-04-26 18:30:39 +03:00
|
|
|
if ((!newinos && __xfs_iflags_test(ip, XFS_INEW)) ||
|
|
|
|
__xfs_iflags_test(ip, XFS_IRECLAIMABLE | XFS_IRECLAIM))
|
2010-12-17 09:29:43 +03:00
|
|
|
goto out_unlock_noent;
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
|
2010-09-28 06:28:06 +04:00
|
|
|
/* nothing to sync during shutdown */
|
|
|
|
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
|
2020-05-21 23:08:49 +03:00
|
|
|
return false;
|
2010-09-28 06:28:06 +04:00
|
|
|
|
|
|
|
/* If we can't grab the inode, it must on it's way to reclaim. */
|
|
|
|
if (!igrab(inode))
|
2020-05-21 23:08:49 +03:00
|
|
|
return false;
|
2010-09-28 06:28:06 +04:00
|
|
|
|
|
|
|
/* inode is valid */
|
2020-05-21 23:08:49 +03:00
|
|
|
return true;
|
2010-12-17 09:29:43 +03:00
|
|
|
|
|
|
|
out_unlock_noent:
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2020-05-21 23:08:49 +03:00
|
|
|
return false;
|
2010-09-28 06:28:06 +04:00
|
|
|
}
|
|
|
|
|
2020-05-21 23:08:50 +03:00
|
|
|
/*
|
|
|
|
* For a given per-AG structure @pag, grab, @execute, and rele all incore
|
|
|
|
* inodes with the given radix tree @tag.
|
|
|
|
*/
|
2009-06-08 17:35:14 +04:00
|
|
|
STATIC int
|
2020-05-21 23:08:50 +03:00
|
|
|
xfs_inode_walk_ag(
|
2010-01-11 14:47:40 +03:00
|
|
|
struct xfs_perag *pag,
|
2020-05-21 23:08:50 +03:00
|
|
|
int iter_flags,
|
2020-05-21 23:08:48 +03:00
|
|
|
int (*execute)(struct xfs_inode *ip, void *args),
|
2012-11-06 18:50:39 +04:00
|
|
|
void *args,
|
2020-05-21 23:08:50 +03:00
|
|
|
int tag)
|
2009-06-08 17:35:14 +04:00
|
|
|
{
|
2020-05-21 23:08:50 +03:00
|
|
|
struct xfs_mount *mp = pag->pag_mount;
|
2009-06-08 17:35:14 +04:00
|
|
|
uint32_t first_index;
|
|
|
|
int last_error = 0;
|
|
|
|
int skipped;
|
2020-05-21 23:08:49 +03:00
|
|
|
bool done;
|
2010-09-28 06:28:19 +04:00
|
|
|
int nr_found;
|
2009-06-08 17:35:14 +04:00
|
|
|
|
|
|
|
restart:
|
2020-05-21 23:08:49 +03:00
|
|
|
done = false;
|
2009-06-08 17:35:14 +04:00
|
|
|
skipped = 0;
|
|
|
|
first_index = 0;
|
2010-09-28 06:28:19 +04:00
|
|
|
nr_found = 0;
|
2009-06-08 17:35:14 +04:00
|
|
|
do {
|
2010-09-28 06:28:19 +04:00
|
|
|
struct xfs_inode *batch[XFS_LOOKUP_BATCH];
|
2009-06-08 17:35:14 +04:00
|
|
|
int error = 0;
|
2010-09-28 06:28:19 +04:00
|
|
|
int i;
|
2009-06-08 17:35:14 +04:00
|
|
|
|
2010-12-17 09:29:43 +03:00
|
|
|
rcu_read_lock();
|
2012-11-06 18:50:39 +04:00
|
|
|
|
2020-05-21 23:08:47 +03:00
|
|
|
if (tag == XFS_ICI_NO_TAG)
|
2012-11-06 18:50:39 +04:00
|
|
|
nr_found = radix_tree_gang_lookup(&pag->pag_ici_root,
|
2010-09-28 06:28:19 +04:00
|
|
|
(void **)batch, first_index,
|
|
|
|
XFS_LOOKUP_BATCH);
|
2012-11-06 18:50:39 +04:00
|
|
|
else
|
|
|
|
nr_found = radix_tree_gang_lookup_tag(
|
|
|
|
&pag->pag_ici_root,
|
|
|
|
(void **) batch, first_index,
|
|
|
|
XFS_LOOKUP_BATCH, tag);
|
|
|
|
|
2010-09-24 12:40:15 +04:00
|
|
|
if (!nr_found) {
|
2010-12-17 09:29:43 +03:00
|
|
|
rcu_read_unlock();
|
2009-06-08 17:35:14 +04:00
|
|
|
break;
|
2010-01-11 02:51:45 +03:00
|
|
|
}
|
2009-06-08 17:35:14 +04:00
|
|
|
|
2010-09-24 12:40:15 +04:00
|
|
|
/*
|
2010-09-28 06:28:19 +04:00
|
|
|
* Grab the inodes before we drop the lock. if we found
|
|
|
|
* nothing, nr == 0 and the loop will be skipped.
|
2010-09-24 12:40:15 +04:00
|
|
|
*/
|
2010-09-28 06:28:19 +04:00
|
|
|
for (i = 0; i < nr_found; i++) {
|
|
|
|
struct xfs_inode *ip = batch[i];
|
|
|
|
|
2020-05-21 23:08:50 +03:00
|
|
|
if (done || !xfs_inode_walk_ag_grab(ip, iter_flags))
|
2010-09-28 06:28:19 +04:00
|
|
|
batch[i] = NULL;
|
|
|
|
|
|
|
|
/*
|
2010-12-17 09:29:43 +03:00
|
|
|
* Update the index for the next lookup. Catch
|
|
|
|
* overflows into the next AG range which can occur if
|
|
|
|
* we have inodes in the last block of the AG and we
|
|
|
|
* are currently pointing to the last inode.
|
|
|
|
*
|
|
|
|
* Because we may see inodes that are from the wrong AG
|
|
|
|
* due to RCU freeing and reallocation, only update the
|
|
|
|
* index if it lies in this AG. It was a race that lead
|
|
|
|
* us to see this inode, so another lookup from the
|
|
|
|
* same index will not find it again.
|
2010-09-28 06:28:19 +04:00
|
|
|
*/
|
2010-12-17 09:29:43 +03:00
|
|
|
if (XFS_INO_TO_AGNO(mp, ip->i_ino) != pag->pag_agno)
|
|
|
|
continue;
|
2010-09-28 06:28:19 +04:00
|
|
|
first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1);
|
|
|
|
if (first_index < XFS_INO_TO_AGINO(mp, ip->i_ino))
|
2020-05-21 23:08:49 +03:00
|
|
|
done = true;
|
2010-09-28 06:28:06 +04:00
|
|
|
}
|
2010-09-28 06:28:19 +04:00
|
|
|
|
|
|
|
/* unlock now we've grabbed the inodes. */
|
2010-12-17 09:29:43 +03:00
|
|
|
rcu_read_unlock();
|
2010-09-28 06:28:06 +04:00
|
|
|
|
2010-09-28 06:28:19 +04:00
|
|
|
for (i = 0; i < nr_found; i++) {
|
|
|
|
if (!batch[i])
|
|
|
|
continue;
|
2020-05-21 23:08:50 +03:00
|
|
|
if ((iter_flags & XFS_INODE_WALK_INEW_WAIT) &&
|
2017-04-26 18:30:39 +03:00
|
|
|
xfs_iflags_test(batch[i], XFS_INEW))
|
|
|
|
xfs_inew_wait(batch[i]);
|
2020-05-21 23:08:48 +03:00
|
|
|
error = execute(batch[i], args);
|
2018-07-25 22:52:32 +03:00
|
|
|
xfs_irele(batch[i]);
|
2014-06-25 08:58:08 +04:00
|
|
|
if (error == -EAGAIN) {
|
2010-09-28 06:28:19 +04:00
|
|
|
skipped++;
|
|
|
|
continue;
|
|
|
|
}
|
2014-06-25 08:58:08 +04:00
|
|
|
if (error && last_error != -EFSCORRUPTED)
|
2010-09-28 06:28:19 +04:00
|
|
|
last_error = error;
|
2009-06-08 17:35:14 +04:00
|
|
|
}
|
2010-01-11 02:51:45 +03:00
|
|
|
|
|
|
|
/* bail out if the filesystem is corrupted. */
|
2014-06-25 08:58:08 +04:00
|
|
|
if (error == -EFSCORRUPTED)
|
2009-06-08 17:35:14 +04:00
|
|
|
break;
|
|
|
|
|
2011-07-08 08:14:46 +04:00
|
|
|
cond_resched();
|
|
|
|
|
2010-09-28 06:28:19 +04:00
|
|
|
} while (nr_found && !done);
|
2009-06-08 17:35:14 +04:00
|
|
|
|
|
|
|
if (skipped) {
|
|
|
|
delay(1);
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
return last_error;
|
|
|
|
}
|
|
|
|
|
2020-05-21 23:08:50 +03:00
|
|
|
/* Fetch the next (possibly tagged) per-AG structure. */
|
|
|
|
static inline struct xfs_perag *
|
|
|
|
xfs_inode_walk_get_perag(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_agnumber_t agno,
|
|
|
|
int tag)
|
|
|
|
{
|
|
|
|
if (tag == XFS_ICI_NO_TAG)
|
|
|
|
return xfs_perag_get(mp, agno);
|
|
|
|
return xfs_perag_get_tag(mp, agno, tag);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call the @execute function on all incore inodes matching the radix tree
|
|
|
|
* @tag.
|
|
|
|
*/
|
|
|
|
int
|
2020-05-21 23:08:50 +03:00
|
|
|
xfs_inode_walk(
|
2020-05-21 23:08:50 +03:00
|
|
|
struct xfs_mount *mp,
|
|
|
|
int iter_flags,
|
|
|
|
int (*execute)(struct xfs_inode *ip, void *args),
|
|
|
|
void *args,
|
|
|
|
int tag)
|
|
|
|
{
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
int error = 0;
|
|
|
|
int last_error = 0;
|
|
|
|
xfs_agnumber_t ag;
|
|
|
|
|
|
|
|
ag = 0;
|
|
|
|
while ((pag = xfs_inode_walk_get_perag(mp, ag, tag))) {
|
|
|
|
ag = pag->pag_agno + 1;
|
2020-05-21 23:08:50 +03:00
|
|
|
error = xfs_inode_walk_ag(pag, iter_flags, execute, args, tag);
|
2020-05-21 23:08:50 +03:00
|
|
|
xfs_perag_put(pag);
|
|
|
|
if (error) {
|
|
|
|
last_error = error;
|
|
|
|
if (error == -EFSCORRUPTED)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return last_error;
|
|
|
|
}
|
|
|
|
|
2012-11-06 18:50:47 +04:00
|
|
|
/*
|
|
|
|
* Background scanning to trim post-EOF preallocated space. This is queued
|
2013-08-15 22:08:02 +04:00
|
|
|
* based on the 'speculative_prealloc_lifetime' tunable (5m by default).
|
2012-11-06 18:50:47 +04:00
|
|
|
*/
|
2016-06-21 04:53:28 +03:00
|
|
|
void
|
2012-11-06 18:50:47 +04:00
|
|
|
xfs_queue_eofblocks(
|
|
|
|
struct xfs_mount *mp)
|
|
|
|
{
|
|
|
|
rcu_read_lock();
|
|
|
|
if (radix_tree_tagged(&mp->m_perag_tree, XFS_ICI_EOFBLOCKS_TAG))
|
|
|
|
queue_delayed_work(mp->m_eofblocks_workqueue,
|
|
|
|
&mp->m_eofblocks_work,
|
|
|
|
msecs_to_jiffies(xfs_eofb_secs * 1000));
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_eofblocks_worker(
|
|
|
|
struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = container_of(to_delayed_work(work),
|
|
|
|
struct xfs_mount, m_eofblocks_work);
|
2020-04-12 23:11:10 +03:00
|
|
|
|
|
|
|
if (!sb_start_write_trylock(mp->m_super))
|
|
|
|
return;
|
2012-11-06 18:50:47 +04:00
|
|
|
xfs_icache_free_eofblocks(mp, NULL);
|
2020-04-12 23:11:10 +03:00
|
|
|
sb_end_write(mp->m_super);
|
|
|
|
|
2012-11-06 18:50:47 +04:00
|
|
|
xfs_queue_eofblocks(mp);
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:11:46 +03:00
|
|
|
/*
|
|
|
|
* Background scanning to trim preallocated CoW space. This is queued
|
|
|
|
* based on the 'speculative_cow_prealloc_lifetime' tunable (5m by default).
|
|
|
|
* (We'll just piggyback on the post-EOF prealloc space workqueue.)
|
|
|
|
*/
|
2017-12-15 02:46:05 +03:00
|
|
|
void
|
2016-10-03 19:11:46 +03:00
|
|
|
xfs_queue_cowblocks(
|
|
|
|
struct xfs_mount *mp)
|
|
|
|
{
|
|
|
|
rcu_read_lock();
|
|
|
|
if (radix_tree_tagged(&mp->m_perag_tree, XFS_ICI_COWBLOCKS_TAG))
|
|
|
|
queue_delayed_work(mp->m_eofblocks_workqueue,
|
|
|
|
&mp->m_cowblocks_work,
|
|
|
|
msecs_to_jiffies(xfs_cowb_secs * 1000));
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_cowblocks_worker(
|
|
|
|
struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = container_of(to_delayed_work(work),
|
|
|
|
struct xfs_mount, m_cowblocks_work);
|
2020-04-12 23:11:10 +03:00
|
|
|
|
|
|
|
if (!sb_start_write_trylock(mp->m_super))
|
|
|
|
return;
|
2016-10-03 19:11:46 +03:00
|
|
|
xfs_icache_free_cowblocks(mp, NULL);
|
2020-04-12 23:11:10 +03:00
|
|
|
sb_end_write(mp->m_super);
|
|
|
|
|
2016-10-03 19:11:46 +03:00
|
|
|
xfs_queue_cowblocks(mp);
|
|
|
|
}
|
|
|
|
|
2010-09-24 13:51:50 +04:00
|
|
|
/*
|
|
|
|
* Grab the inode for reclaim exclusively.
|
2020-07-01 20:21:05 +03:00
|
|
|
*
|
|
|
|
* We have found this inode via a lookup under RCU, so the inode may have
|
|
|
|
* already been freed, or it may be in the process of being recycled by
|
|
|
|
* xfs_iget(). In both cases, the inode will have XFS_IRECLAIM set. If the inode
|
|
|
|
* has been fully recycled by the time we get the i_flags_lock, XFS_IRECLAIMABLE
|
|
|
|
* will not be set. Hence we need to check for both these flag conditions to
|
|
|
|
* avoid inodes that are no longer reclaim candidates.
|
|
|
|
*
|
|
|
|
* Note: checking for other state flags here, under the i_flags_lock or not, is
|
|
|
|
* racy and should be avoided. Those races should be resolved only after we have
|
|
|
|
* ensured that we are able to reclaim this inode and the world can see that we
|
|
|
|
* are going to reclaim it.
|
|
|
|
*
|
|
|
|
* Return true if we grabbed it, false otherwise.
|
2010-09-24 13:51:50 +04:00
|
|
|
*/
|
2020-07-01 20:21:05 +03:00
|
|
|
static bool
|
2010-09-24 13:51:50 +04:00
|
|
|
xfs_reclaim_inode_grab(
|
2020-07-01 20:21:05 +03:00
|
|
|
struct xfs_inode *ip)
|
2010-09-24 13:51:50 +04:00
|
|
|
{
|
2010-12-17 09:29:43 +03:00
|
|
|
ASSERT(rcu_read_lock_held());
|
|
|
|
|
2010-09-24 13:51:50 +04:00
|
|
|
spin_lock(&ip->i_flags_lock);
|
2010-12-17 09:29:43 +03:00
|
|
|
if (!__xfs_iflags_test(ip, XFS_IRECLAIMABLE) ||
|
|
|
|
__xfs_iflags_test(ip, XFS_IRECLAIM)) {
|
|
|
|
/* not a reclaim candidate. */
|
2010-09-24 13:51:50 +04:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2020-07-01 20:21:05 +03:00
|
|
|
return false;
|
2010-09-24 13:51:50 +04:00
|
|
|
}
|
|
|
|
__xfs_iflags_set(ip, XFS_IRECLAIM);
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2020-07-01 20:21:05 +03:00
|
|
|
return true;
|
2010-09-24 13:51:50 +04:00
|
|
|
}
|
|
|
|
|
2010-02-06 04:37:26 +03:00
|
|
|
/*
|
2020-06-30 00:49:18 +03:00
|
|
|
* Inode reclaim is non-blocking, so the default action if progress cannot be
|
|
|
|
* made is to "requeue" the inode for reclaim by unlocking it and clearing the
|
|
|
|
* XFS_IRECLAIM flag. If we are in a shutdown state, we don't care about
|
|
|
|
* blocking anymore and hence we can wait for the inode to be able to reclaim
|
|
|
|
* it.
|
2010-02-06 04:37:26 +03:00
|
|
|
*
|
2020-06-30 00:49:18 +03:00
|
|
|
* We do no IO here - if callers require inodes to be cleaned they must push the
|
|
|
|
* AIL first to trigger writeback of dirty inodes. This enables writeback to be
|
|
|
|
* done in the background in a non-blocking manner, and enables memory reclaim
|
|
|
|
* to make progress without blocking.
|
2010-02-06 04:37:26 +03:00
|
|
|
*/
|
2020-07-01 20:21:28 +03:00
|
|
|
static void
|
2010-01-11 02:51:45 +03:00
|
|
|
xfs_reclaim_inode(
|
2009-06-08 17:35:14 +04:00
|
|
|
struct xfs_inode *ip,
|
2020-07-01 20:21:05 +03:00
|
|
|
struct xfs_perag *pag)
|
2008-10-30 09:37:03 +03:00
|
|
|
{
|
2016-05-18 07:09:12 +03:00
|
|
|
xfs_ino_t ino = ip->i_ino; /* for radix_tree_delete */
|
2010-02-06 04:37:26 +03:00
|
|
|
|
2020-06-30 00:49:17 +03:00
|
|
|
if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL))
|
2020-06-30 00:49:16 +03:00
|
|
|
goto out;
|
2020-08-18 02:41:01 +03:00
|
|
|
if (xfs_iflags_test_and_set(ip, XFS_IFLUSHING))
|
2020-06-30 00:49:17 +03:00
|
|
|
goto out_iunlock;
|
2008-10-30 09:37:37 +03:00
|
|
|
|
2010-02-06 04:37:26 +03:00
|
|
|
if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
|
|
|
|
xfs_iunpin_wait(ip);
|
2020-05-06 23:27:40 +03:00
|
|
|
xfs_iflush_abort(ip);
|
2010-02-06 04:37:26 +03:00
|
|
|
goto reclaim;
|
|
|
|
}
|
2020-06-30 00:49:16 +03:00
|
|
|
if (xfs_ipincount(ip))
|
2020-08-18 02:41:01 +03:00
|
|
|
goto out_clear_flush;
|
2020-06-30 00:49:16 +03:00
|
|
|
if (!xfs_inode_clean(ip))
|
2020-08-18 02:41:01 +03:00
|
|
|
goto out_clear_flush;
|
2012-04-23 09:58:35 +04:00
|
|
|
|
2020-08-18 02:41:01 +03:00
|
|
|
xfs_iflags_clear(ip, XFS_IFLUSHING);
|
2010-02-06 04:37:26 +03:00
|
|
|
reclaim:
|
2016-11-10 00:23:22 +03:00
|
|
|
|
2016-05-18 07:09:12 +03:00
|
|
|
/*
|
|
|
|
* Because we use RCU freeing we need to ensure the inode always appears
|
|
|
|
* to be reclaimed with an invalid inode number when in the free state.
|
2016-11-10 00:23:22 +03:00
|
|
|
* We do this as early as possible under the ILOCK so that
|
2017-08-25 20:05:26 +03:00
|
|
|
* xfs_iflush_cluster() and xfs_ifree_cluster() can be guaranteed to
|
|
|
|
* detect races with us here. By doing this, we guarantee that once
|
|
|
|
* xfs_iflush_cluster() or xfs_ifree_cluster() has locked XFS_ILOCK that
|
|
|
|
* it will see either a valid inode that will serialise correctly, or it
|
|
|
|
* will see an invalid inode that it can skip.
|
2016-05-18 07:09:12 +03:00
|
|
|
*/
|
|
|
|
spin_lock(&ip->i_flags_lock);
|
|
|
|
ip->i_flags = XFS_IRECLAIM;
|
|
|
|
ip->i_ino = 0;
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
|
2010-01-11 02:51:45 +03:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2010-07-20 11:53:25 +04:00
|
|
|
|
2015-10-12 10:21:22 +03:00
|
|
|
XFS_STATS_INC(ip->i_mount, xs_ig_reclaims);
|
2010-07-20 11:53:25 +04:00
|
|
|
/*
|
|
|
|
* Remove the inode from the per-AG radix tree.
|
|
|
|
*
|
|
|
|
* Because radix_tree_delete won't complain even if the item was never
|
|
|
|
* added to the tree assert that it's been there before to catch
|
|
|
|
* problems with the inode life time early on.
|
|
|
|
*/
|
2010-12-16 09:08:41 +03:00
|
|
|
spin_lock(&pag->pag_ici_lock);
|
2010-07-20 11:53:25 +04:00
|
|
|
if (!radix_tree_delete(&pag->pag_ici_root,
|
2016-05-18 07:09:12 +03:00
|
|
|
XFS_INO_TO_AGINO(ip->i_mount, ino)))
|
2010-07-20 11:53:25 +04:00
|
|
|
ASSERT(0);
|
2016-05-18 07:11:41 +03:00
|
|
|
xfs_perag_clear_reclaim_tag(pag);
|
2010-12-16 09:08:41 +03:00
|
|
|
spin_unlock(&pag->pag_ici_lock);
|
2010-07-20 11:53:25 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Here we do an (almost) spurious inode lock in order to coordinate
|
|
|
|
* with inode cache radix tree lookups. This is because the lookup
|
|
|
|
* can reference the inodes in the cache without taking references.
|
|
|
|
*
|
|
|
|
* We make that OK here by ensuring that we wait until the inode is
|
2012-02-17 02:01:00 +04:00
|
|
|
* unlocked after the lookup before we go ahead and free it.
|
2010-07-20 11:53:25 +04:00
|
|
|
*/
|
2012-02-17 02:01:00 +04:00
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
2010-07-20 11:53:25 +04:00
|
|
|
xfs_qm_dqdetach(ip);
|
2012-02-17 02:01:00 +04:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
xfs: Don't allow logging of XFS_ISTALE inodes
In tracking down a problem in this patchset, I discovered we are
reclaiming dirty stale inodes. This wasn't discovered until inodes
were always attached to the cluster buffer and then the rcu callback
that freed inodes was assert failing because the inode still had an
active pointer to the cluster buffer after it had been reclaimed.
Debugging the issue indicated that this was a pre-existing issue
resulting from the way the inodes are handled in xfs_inactive_ifree.
When we free a cluster buffer from xfs_ifree_cluster, all the inodes
in cache are marked XFS_ISTALE. Those that are clean have nothing
else done to them and so eventually get cleaned up by background
reclaim. i.e. it is assumed we'll never dirty/relog an inode marked
XFS_ISTALE.
On journal commit dirty stale inodes as are handled by both
buffer and inode log items to run though xfs_istale_done() and
removed from the AIL (buffer log item commit) or the log item will
simply unpin it because the buffer log item will clean it. What happens
to any specific inode is entirely dependent on which log item wins
the commit race, but the result is the same - stale inodes are
clean, not attached to the cluster buffer, and not in the AIL. Hence
inode reclaim can just free these inodes without further care.
However, if the stale inode is relogged, it gets dirtied again and
relogged into the CIL. Most of the time this isn't an issue, because
relogging simply changes the inode's location in the current
checkpoint. Problems arise, however, when the CIL checkpoints
between two transactions in the xfs_inactive_ifree() deferops
processing. This results in the XFS_ISTALE inode being redirtied
and inserted into the CIL without any of the other stale cluster
buffer infrastructure being in place.
Hence on journal commit, it simply gets unpinned, so it remains
dirty in memory. Everything in inode writeback avoids XFS_ISTALE
inodes so it can't be written back, and it is not tracked in the AIL
so there's not even a trigger to attempt to clean the inode. Hence
the inode just sits dirty in memory until inode reclaim comes along,
sees that it is XFS_ISTALE, and goes to reclaim it. This reclaiming
of a dirty inode caused use after free, list corruptions and other
nasty issues later in this patchset.
Hence this patch addresses a violation of the "never log XFS_ISTALE
inodes" caused by the deferops processing rolling a transaction
and relogging a stale inode in xfs_inactive_free. It also adds a
bunch of asserts to catch this problem in debug kernels so that
we don't reintroduce this problem in future.
Reproducer for this issue was generic/558 on a v4 filesystem.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2020-06-30 00:48:45 +03:00
|
|
|
ASSERT(xfs_inode_clean(ip));
|
2010-07-20 11:53:25 +04:00
|
|
|
|
2016-05-18 07:09:12 +03:00
|
|
|
__xfs_inode_free(ip);
|
2020-07-01 20:21:28 +03:00
|
|
|
return;
|
2012-04-23 09:58:35 +04:00
|
|
|
|
2020-08-18 02:41:01 +03:00
|
|
|
out_clear_flush:
|
|
|
|
xfs_iflags_clear(ip, XFS_IFLUSHING);
|
2020-06-30 00:49:17 +03:00
|
|
|
out_iunlock:
|
2012-04-23 09:58:35 +04:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2020-06-30 00:49:17 +03:00
|
|
|
out:
|
2020-06-30 00:49:16 +03:00
|
|
|
xfs_iflags_clear(ip, XFS_IRECLAIM);
|
2008-10-30 09:37:37 +03:00
|
|
|
}
|
|
|
|
|
2010-09-24 12:40:15 +04:00
|
|
|
/*
|
|
|
|
* Walk the AGs and reclaim the inodes in them. Even if the filesystem is
|
|
|
|
* corrupted, we still want to try to reclaim all the inodes. If we don't,
|
|
|
|
* then a shut down during filesystem unmount reclaim walk leak all the
|
|
|
|
* unreclaimed inodes.
|
2020-06-30 00:49:16 +03:00
|
|
|
*
|
|
|
|
* Returns non-zero if any AGs or inodes were skipped in the reclaim pass
|
|
|
|
* so that callers that want to block until all dirty inodes are written back
|
|
|
|
* and reclaimed can sanely loop.
|
2010-09-24 12:40:15 +04:00
|
|
|
*/
|
2020-07-01 20:21:28 +03:00
|
|
|
static void
|
2010-09-24 12:40:15 +04:00
|
|
|
xfs_reclaim_inodes_ag(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
int *nr_to_scan)
|
|
|
|
{
|
|
|
|
struct xfs_perag *pag;
|
2020-06-30 00:49:16 +03:00
|
|
|
xfs_agnumber_t ag = 0;
|
2010-09-24 12:40:15 +04:00
|
|
|
|
|
|
|
while ((pag = xfs_perag_get_tag(mp, ag, XFS_ICI_RECLAIM_TAG))) {
|
|
|
|
unsigned long first_index = 0;
|
|
|
|
int done = 0;
|
2010-09-24 13:51:50 +04:00
|
|
|
int nr_found = 0;
|
2010-09-24 12:40:15 +04:00
|
|
|
|
|
|
|
ag = pag->pag_agno + 1;
|
|
|
|
|
2020-06-30 00:49:16 +03:00
|
|
|
first_index = READ_ONCE(pag->pag_ici_reclaim_cursor);
|
2010-09-24 12:40:15 +04:00
|
|
|
do {
|
2010-09-24 13:51:50 +04:00
|
|
|
struct xfs_inode *batch[XFS_LOOKUP_BATCH];
|
|
|
|
int i;
|
2010-09-24 12:40:15 +04:00
|
|
|
|
2010-12-17 09:29:43 +03:00
|
|
|
rcu_read_lock();
|
2010-09-24 13:51:50 +04:00
|
|
|
nr_found = radix_tree_gang_lookup_tag(
|
|
|
|
&pag->pag_ici_root,
|
|
|
|
(void **)batch, first_index,
|
|
|
|
XFS_LOOKUP_BATCH,
|
2010-09-24 12:40:15 +04:00
|
|
|
XFS_ICI_RECLAIM_TAG);
|
|
|
|
if (!nr_found) {
|
2011-05-06 06:54:04 +04:00
|
|
|
done = 1;
|
2010-12-17 09:29:43 +03:00
|
|
|
rcu_read_unlock();
|
2010-09-24 12:40:15 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-09-24 13:51:50 +04:00
|
|
|
* Grab the inodes before we drop the lock. if we found
|
|
|
|
* nothing, nr == 0 and the loop will be skipped.
|
2010-09-24 12:40:15 +04:00
|
|
|
*/
|
2010-09-24 13:51:50 +04:00
|
|
|
for (i = 0; i < nr_found; i++) {
|
|
|
|
struct xfs_inode *ip = batch[i];
|
|
|
|
|
2020-07-01 20:21:05 +03:00
|
|
|
if (done || !xfs_reclaim_inode_grab(ip))
|
2010-09-24 13:51:50 +04:00
|
|
|
batch[i] = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update the index for the next lookup. Catch
|
|
|
|
* overflows into the next AG range which can
|
|
|
|
* occur if we have inodes in the last block of
|
|
|
|
* the AG and we are currently pointing to the
|
|
|
|
* last inode.
|
2010-12-17 09:29:43 +03:00
|
|
|
*
|
|
|
|
* Because we may see inodes that are from the
|
|
|
|
* wrong AG due to RCU freeing and
|
|
|
|
* reallocation, only update the index if it
|
|
|
|
* lies in this AG. It was a race that lead us
|
|
|
|
* to see this inode, so another lookup from
|
|
|
|
* the same index will not find it again.
|
2010-09-24 13:51:50 +04:00
|
|
|
*/
|
2010-12-17 09:29:43 +03:00
|
|
|
if (XFS_INO_TO_AGNO(mp, ip->i_ino) !=
|
|
|
|
pag->pag_agno)
|
|
|
|
continue;
|
2010-09-24 13:51:50 +04:00
|
|
|
first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1);
|
|
|
|
if (first_index < XFS_INO_TO_AGINO(mp, ip->i_ino))
|
|
|
|
done = 1;
|
|
|
|
}
|
2010-09-24 12:40:15 +04:00
|
|
|
|
2010-09-24 13:51:50 +04:00
|
|
|
/* unlock now we've grabbed the inodes. */
|
2010-12-17 09:29:43 +03:00
|
|
|
rcu_read_unlock();
|
2010-09-24 13:51:50 +04:00
|
|
|
|
|
|
|
for (i = 0; i < nr_found; i++) {
|
2020-07-01 20:21:28 +03:00
|
|
|
if (batch[i])
|
|
|
|
xfs_reclaim_inode(batch[i], pag);
|
2010-09-24 13:51:50 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
*nr_to_scan -= XFS_LOOKUP_BATCH;
|
2011-07-08 08:14:46 +04:00
|
|
|
cond_resched();
|
2010-09-24 13:51:50 +04:00
|
|
|
} while (nr_found && !done && *nr_to_scan > 0);
|
2010-09-24 12:40:15 +04:00
|
|
|
|
2020-06-30 00:49:16 +03:00
|
|
|
if (done)
|
|
|
|
first_index = 0;
|
|
|
|
WRITE_ONCE(pag->pag_ici_reclaim_cursor, first_index);
|
2010-09-24 12:40:15 +04:00
|
|
|
xfs_perag_put(pag);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-01 20:21:28 +03:00
|
|
|
void
|
2008-10-30 09:37:37 +03:00
|
|
|
xfs_reclaim_inodes(
|
2020-07-01 20:21:28 +03:00
|
|
|
struct xfs_mount *mp)
|
2008-10-30 09:37:37 +03:00
|
|
|
{
|
2010-09-24 12:40:15 +04:00
|
|
|
int nr_to_scan = INT_MAX;
|
|
|
|
|
2020-07-01 20:21:28 +03:00
|
|
|
while (radix_tree_tagged(&mp->m_perag_tree, XFS_ICI_RECLAIM_TAG)) {
|
2020-06-30 00:49:16 +03:00
|
|
|
xfs_ail_push_all_sync(mp->m_ail);
|
2020-07-01 20:21:28 +03:00
|
|
|
xfs_reclaim_inodes_ag(mp, &nr_to_scan);
|
2020-09-09 19:29:16 +03:00
|
|
|
}
|
2010-04-29 03:55:50 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2020-06-30 00:49:18 +03:00
|
|
|
* The shrinker infrastructure determines how many inodes we should scan for
|
|
|
|
* reclaim. We want as many clean inodes ready to reclaim as possible, so we
|
|
|
|
* push the AIL here. We also want to proactively free up memory if we can to
|
|
|
|
* minimise the amount of work memory reclaim has to do so we kick the
|
|
|
|
* background reclaim if it isn't already scheduled.
|
2010-04-29 03:55:50 +04:00
|
|
|
*/
|
2013-08-28 04:17:57 +04:00
|
|
|
long
|
2011-07-08 08:14:46 +04:00
|
|
|
xfs_reclaim_inodes_nr(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
int nr_to_scan)
|
2010-04-29 03:55:50 +04:00
|
|
|
{
|
2011-07-08 08:14:46 +04:00
|
|
|
/* kick background reclaimer and push the AIL */
|
2012-10-08 14:56:05 +04:00
|
|
|
xfs_reclaim_work_queue(mp);
|
2011-07-08 08:14:46 +04:00
|
|
|
xfs_ail_push_all(mp->m_ail);
|
2011-04-08 06:45:07 +04:00
|
|
|
|
2020-07-01 20:21:05 +03:00
|
|
|
xfs_reclaim_inodes_ag(mp, &nr_to_scan);
|
2020-06-30 00:49:16 +03:00
|
|
|
return 0;
|
2011-07-08 08:14:46 +04:00
|
|
|
}
|
2010-04-29 03:55:50 +04:00
|
|
|
|
2011-07-08 08:14:46 +04:00
|
|
|
/*
|
|
|
|
* Return the number of reclaimable inodes in the filesystem for
|
|
|
|
* the shrinker to determine how much to reclaim.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_reclaim_inodes_count(
|
|
|
|
struct xfs_mount *mp)
|
|
|
|
{
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
xfs_agnumber_t ag = 0;
|
|
|
|
int reclaimable = 0;
|
2010-04-29 03:55:50 +04:00
|
|
|
|
2010-09-24 12:40:15 +04:00
|
|
|
while ((pag = xfs_perag_get_tag(mp, ag, XFS_ICI_RECLAIM_TAG))) {
|
|
|
|
ag = pag->pag_agno + 1;
|
2010-07-20 02:07:02 +04:00
|
|
|
reclaimable += pag->pag_ici_reclaimable;
|
|
|
|
xfs_perag_put(pag);
|
2010-04-29 03:55:50 +04:00
|
|
|
}
|
|
|
|
return reclaimable;
|
|
|
|
}
|
|
|
|
|
2020-05-21 23:08:49 +03:00
|
|
|
STATIC bool
|
2012-11-07 21:21:13 +04:00
|
|
|
xfs_inode_match_id(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_eofblocks *eofb)
|
|
|
|
{
|
2013-08-15 22:08:02 +04:00
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&
|
|
|
|
!uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))
|
2020-05-21 23:08:49 +03:00
|
|
|
return false;
|
2012-11-07 21:21:13 +04:00
|
|
|
|
2013-08-15 22:08:02 +04:00
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&
|
|
|
|
!gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))
|
2020-05-21 23:08:49 +03:00
|
|
|
return false;
|
2012-11-06 18:50:45 +04:00
|
|
|
|
2013-08-15 22:08:02 +04:00
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&
|
2019-11-12 19:22:54 +03:00
|
|
|
ip->i_d.di_projid != eofb->eof_prid)
|
2020-05-21 23:08:49 +03:00
|
|
|
return false;
|
2012-11-06 18:50:45 +04:00
|
|
|
|
2020-05-21 23:08:49 +03:00
|
|
|
return true;
|
2012-11-07 21:21:13 +04:00
|
|
|
}
|
|
|
|
|
2014-07-24 13:44:28 +04:00
|
|
|
/*
|
|
|
|
* A union-based inode filtering algorithm. Process the inode if any of the
|
|
|
|
* criteria match. This is for global/internal scans only.
|
|
|
|
*/
|
2020-05-21 23:08:49 +03:00
|
|
|
STATIC bool
|
2014-07-24 13:44:28 +04:00
|
|
|
xfs_inode_match_id_union(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_eofblocks *eofb)
|
|
|
|
{
|
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&
|
|
|
|
uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))
|
2020-05-21 23:08:49 +03:00
|
|
|
return true;
|
2014-07-24 13:44:28 +04:00
|
|
|
|
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&
|
|
|
|
gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))
|
2020-05-21 23:08:49 +03:00
|
|
|
return true;
|
2014-07-24 13:44:28 +04:00
|
|
|
|
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&
|
2019-11-12 19:22:54 +03:00
|
|
|
ip->i_d.di_projid == eofb->eof_prid)
|
2020-05-21 23:08:49 +03:00
|
|
|
return true;
|
2014-07-24 13:44:28 +04:00
|
|
|
|
2020-05-21 23:08:49 +03:00
|
|
|
return false;
|
2014-07-24 13:44:28 +04:00
|
|
|
}
|
|
|
|
|
2020-05-21 23:08:48 +03:00
|
|
|
/*
|
|
|
|
* Is this inode @ip eligible for eof/cow block reclamation, given some
|
|
|
|
* filtering parameters @eofb? The inode is eligible if @eofb is null or
|
|
|
|
* if the predicate functions match.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
xfs_inode_matches_eofb(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_eofblocks *eofb)
|
|
|
|
{
|
2020-05-21 23:08:49 +03:00
|
|
|
bool match;
|
2020-05-21 23:08:48 +03:00
|
|
|
|
|
|
|
if (!eofb)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (eofb->eof_flags & XFS_EOF_FLAGS_UNION)
|
|
|
|
match = xfs_inode_match_id_union(ip, eofb);
|
|
|
|
else
|
|
|
|
match = xfs_inode_match_id(ip, eofb);
|
|
|
|
if (!match)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* skip the inode if the file size is too small */
|
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_MINFILESIZE) &&
|
|
|
|
XFS_ISIZE(ip) < eofb->eof_min_file_size)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-07-01 20:21:28 +03:00
|
|
|
/*
|
|
|
|
* This is a fast pass over the inode cache to try to get reclaim moving on as
|
|
|
|
* many inodes as possible in a short period of time. It kicks itself every few
|
|
|
|
* seconds, as well as being kicked by the inode cache shrinker when memory
|
2020-06-30 00:49:18 +03:00
|
|
|
* goes low.
|
2020-07-01 20:21:28 +03:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_reclaim_worker(
|
|
|
|
struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = container_of(to_delayed_work(work),
|
|
|
|
struct xfs_mount, m_reclaim_work);
|
|
|
|
int nr_to_scan = INT_MAX;
|
|
|
|
|
|
|
|
xfs_reclaim_inodes_ag(mp, &nr_to_scan);
|
|
|
|
xfs_reclaim_work_queue(mp);
|
|
|
|
}
|
|
|
|
|
2012-11-06 18:50:42 +04:00
|
|
|
STATIC int
|
|
|
|
xfs_inode_free_eofblocks(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
void *args)
|
|
|
|
{
|
2020-05-21 23:08:48 +03:00
|
|
|
struct xfs_eofblocks *eofb = args;
|
|
|
|
bool wait;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
wait = eofb && (eofb->eof_flags & XFS_EOF_FLAGS_SYNC);
|
2014-07-24 13:40:22 +04:00
|
|
|
|
2012-11-06 18:50:42 +04:00
|
|
|
if (!xfs_can_free_eofblocks(ip, false)) {
|
|
|
|
/* inode could be preallocated or append-only */
|
|
|
|
trace_xfs_inode_free_eofblocks_invalid(ip);
|
|
|
|
xfs_inode_clear_eofblocks_tag(ip);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the mapping is dirty the operation can block and wait for some
|
|
|
|
* time. Unless we are waiting, skip it.
|
|
|
|
*/
|
2020-05-21 23:08:48 +03:00
|
|
|
if (!wait && mapping_tagged(VFS_I(ip)->i_mapping, PAGECACHE_TAG_DIRTY))
|
2012-11-06 18:50:42 +04:00
|
|
|
return 0;
|
|
|
|
|
2020-05-21 23:08:48 +03:00
|
|
|
if (!xfs_inode_matches_eofb(ip, eofb))
|
|
|
|
return 0;
|
2012-11-07 21:21:13 +04:00
|
|
|
|
2017-01-28 10:22:55 +03:00
|
|
|
/*
|
|
|
|
* If the caller is waiting, return -EAGAIN to keep the background
|
|
|
|
* scanner moving and revisit the inode in a subsequent pass.
|
|
|
|
*/
|
2017-01-28 10:22:56 +03:00
|
|
|
if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
|
2020-05-21 23:08:48 +03:00
|
|
|
if (wait)
|
|
|
|
return -EAGAIN;
|
|
|
|
return 0;
|
2017-01-28 10:22:55 +03:00
|
|
|
}
|
2020-05-21 23:08:48 +03:00
|
|
|
|
2017-01-28 10:22:55 +03:00
|
|
|
ret = xfs_free_eofblocks(ip);
|
2017-01-28 10:22:56 +03:00
|
|
|
xfs_iunlock(ip, XFS_IOLOCK_EXCL);
|
2012-11-06 18:50:42 +04:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:11:46 +03:00
|
|
|
int
|
|
|
|
xfs_icache_free_eofblocks(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_eofblocks *eofb)
|
|
|
|
{
|
2020-05-21 23:08:50 +03:00
|
|
|
return xfs_inode_walk(mp, 0, xfs_inode_free_eofblocks, eofb,
|
2016-10-03 19:11:46 +03:00
|
|
|
XFS_ICI_EOFBLOCKS_TAG);
|
2012-11-06 18:50:42 +04:00
|
|
|
}
|
|
|
|
|
2017-12-15 02:42:22 +03:00
|
|
|
static inline unsigned long
|
|
|
|
xfs_iflag_for_tag(
|
|
|
|
int tag)
|
|
|
|
{
|
|
|
|
switch (tag) {
|
|
|
|
case XFS_ICI_EOFBLOCKS_TAG:
|
|
|
|
return XFS_IEOFBLOCKS;
|
|
|
|
case XFS_ICI_COWBLOCKS_TAG:
|
|
|
|
return XFS_ICOWBLOCKS;
|
|
|
|
default:
|
|
|
|
ASSERT(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:11:46 +03:00
|
|
|
static void
|
2017-12-15 02:42:22 +03:00
|
|
|
__xfs_inode_set_blocks_tag(
|
2016-10-03 19:11:46 +03:00
|
|
|
xfs_inode_t *ip,
|
|
|
|
void (*execute)(struct xfs_mount *mp),
|
|
|
|
void (*set_tp)(struct xfs_mount *mp, xfs_agnumber_t agno,
|
|
|
|
int error, unsigned long caller_ip),
|
|
|
|
int tag)
|
2012-11-06 18:50:38 +04:00
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
int tagged;
|
|
|
|
|
2016-09-19 04:09:48 +03:00
|
|
|
/*
|
|
|
|
* Don't bother locking the AG and looking up in the radix trees
|
|
|
|
* if we already know that we have the tag set.
|
|
|
|
*/
|
2017-12-15 02:42:22 +03:00
|
|
|
if (ip->i_flags & xfs_iflag_for_tag(tag))
|
2016-09-19 04:09:48 +03:00
|
|
|
return;
|
|
|
|
spin_lock(&ip->i_flags_lock);
|
2017-12-15 02:42:22 +03:00
|
|
|
ip->i_flags |= xfs_iflag_for_tag(tag);
|
2016-09-19 04:09:48 +03:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
|
2012-11-06 18:50:38 +04:00
|
|
|
pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
|
|
|
|
spin_lock(&pag->pag_ici_lock);
|
|
|
|
|
2016-10-03 19:11:46 +03:00
|
|
|
tagged = radix_tree_tagged(&pag->pag_ici_root, tag);
|
2012-11-06 18:50:38 +04:00
|
|
|
radix_tree_tag_set(&pag->pag_ici_root,
|
2016-10-03 19:11:46 +03:00
|
|
|
XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino), tag);
|
2012-11-06 18:50:38 +04:00
|
|
|
if (!tagged) {
|
|
|
|
/* propagate the eofblocks tag up into the perag radix tree */
|
|
|
|
spin_lock(&ip->i_mount->m_perag_lock);
|
|
|
|
radix_tree_tag_set(&ip->i_mount->m_perag_tree,
|
|
|
|
XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
|
2016-10-03 19:11:46 +03:00
|
|
|
tag);
|
2012-11-06 18:50:38 +04:00
|
|
|
spin_unlock(&ip->i_mount->m_perag_lock);
|
2012-11-06 18:50:47 +04:00
|
|
|
|
|
|
|
/* kick off background trimming */
|
2016-10-03 19:11:46 +03:00
|
|
|
execute(ip->i_mount);
|
2012-11-06 18:50:38 +04:00
|
|
|
|
2016-10-03 19:11:46 +03:00
|
|
|
set_tp(ip->i_mount, pag->pag_agno, -1, _RET_IP_);
|
2012-11-06 18:50:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&pag->pag_ici_lock);
|
|
|
|
xfs_perag_put(pag);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2016-10-03 19:11:46 +03:00
|
|
|
xfs_inode_set_eofblocks_tag(
|
2012-11-06 18:50:38 +04:00
|
|
|
xfs_inode_t *ip)
|
2016-10-03 19:11:46 +03:00
|
|
|
{
|
|
|
|
trace_xfs_inode_set_eofblocks_tag(ip);
|
2017-12-15 02:42:22 +03:00
|
|
|
return __xfs_inode_set_blocks_tag(ip, xfs_queue_eofblocks,
|
2016-10-03 19:11:46 +03:00
|
|
|
trace_xfs_perag_set_eofblocks,
|
|
|
|
XFS_ICI_EOFBLOCKS_TAG);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2017-12-15 02:42:22 +03:00
|
|
|
__xfs_inode_clear_blocks_tag(
|
2016-10-03 19:11:46 +03:00
|
|
|
xfs_inode_t *ip,
|
|
|
|
void (*clear_tp)(struct xfs_mount *mp, xfs_agnumber_t agno,
|
|
|
|
int error, unsigned long caller_ip),
|
|
|
|
int tag)
|
2012-11-06 18:50:38 +04:00
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
|
2016-09-19 04:09:48 +03:00
|
|
|
spin_lock(&ip->i_flags_lock);
|
2017-12-15 02:42:22 +03:00
|
|
|
ip->i_flags &= ~xfs_iflag_for_tag(tag);
|
2016-09-19 04:09:48 +03:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
|
2012-11-06 18:50:38 +04:00
|
|
|
pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
|
|
|
|
spin_lock(&pag->pag_ici_lock);
|
|
|
|
|
|
|
|
radix_tree_tag_clear(&pag->pag_ici_root,
|
2016-10-03 19:11:46 +03:00
|
|
|
XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino), tag);
|
|
|
|
if (!radix_tree_tagged(&pag->pag_ici_root, tag)) {
|
2012-11-06 18:50:38 +04:00
|
|
|
/* clear the eofblocks tag from the perag radix tree */
|
|
|
|
spin_lock(&ip->i_mount->m_perag_lock);
|
|
|
|
radix_tree_tag_clear(&ip->i_mount->m_perag_tree,
|
|
|
|
XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino),
|
2016-10-03 19:11:46 +03:00
|
|
|
tag);
|
2012-11-06 18:50:38 +04:00
|
|
|
spin_unlock(&ip->i_mount->m_perag_lock);
|
2016-10-03 19:11:46 +03:00
|
|
|
clear_tp(ip->i_mount, pag->pag_agno, -1, _RET_IP_);
|
2012-11-06 18:50:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&pag->pag_ici_lock);
|
|
|
|
xfs_perag_put(pag);
|
|
|
|
}
|
|
|
|
|
2016-10-03 19:11:46 +03:00
|
|
|
void
|
|
|
|
xfs_inode_clear_eofblocks_tag(
|
|
|
|
xfs_inode_t *ip)
|
|
|
|
{
|
|
|
|
trace_xfs_inode_clear_eofblocks_tag(ip);
|
2017-12-15 02:42:22 +03:00
|
|
|
return __xfs_inode_clear_blocks_tag(ip,
|
2016-10-03 19:11:46 +03:00
|
|
|
trace_xfs_perag_clear_eofblocks, XFS_ICI_EOFBLOCKS_TAG);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2018-01-17 06:03:59 +03:00
|
|
|
* Set ourselves up to free CoW blocks from this file. If it's already clean
|
|
|
|
* then we can bail out quickly, but otherwise we must back off if the file
|
|
|
|
* is undergoing some kind of write.
|
2016-10-03 19:11:46 +03:00
|
|
|
*/
|
2018-01-17 06:03:59 +03:00
|
|
|
static bool
|
|
|
|
xfs_prep_free_cowblocks(
|
2018-07-18 02:51:51 +03:00
|
|
|
struct xfs_inode *ip)
|
2016-10-03 19:11:46 +03:00
|
|
|
{
|
2016-11-08 04:53:33 +03:00
|
|
|
/*
|
|
|
|
* Just clear the tag if we have an empty cow fork or none at all. It's
|
|
|
|
* possible the inode was fully unshared since it was originally tagged.
|
|
|
|
*/
|
2018-07-18 02:51:51 +03:00
|
|
|
if (!xfs_inode_has_cow_data(ip)) {
|
2016-10-03 19:11:46 +03:00
|
|
|
trace_xfs_inode_free_cowblocks_invalid(ip);
|
|
|
|
xfs_inode_clear_cowblocks_tag(ip);
|
2018-01-17 06:03:59 +03:00
|
|
|
return false;
|
2016-10-03 19:11:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the mapping is dirty or under writeback we cannot touch the
|
|
|
|
* CoW fork. Leave it alone if we're in the midst of a directio.
|
|
|
|
*/
|
2017-01-04 05:39:33 +03:00
|
|
|
if ((VFS_I(ip)->i_state & I_DIRTY_PAGES) ||
|
|
|
|
mapping_tagged(VFS_I(ip)->i_mapping, PAGECACHE_TAG_DIRTY) ||
|
2016-10-03 19:11:46 +03:00
|
|
|
mapping_tagged(VFS_I(ip)->i_mapping, PAGECACHE_TAG_WRITEBACK) ||
|
|
|
|
atomic_read(&VFS_I(ip)->i_dio_count))
|
2018-01-17 06:03:59 +03:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Automatic CoW Reservation Freeing
|
|
|
|
*
|
|
|
|
* These functions automatically garbage collect leftover CoW reservations
|
|
|
|
* that were made on behalf of a cowextsize hint when we start to run out
|
|
|
|
* of quota or when the reservations sit around for too long. If the file
|
|
|
|
* has dirty pages or is undergoing writeback, its CoW reservations will
|
|
|
|
* be retained.
|
|
|
|
*
|
|
|
|
* The actual garbage collection piggybacks off the same code that runs
|
|
|
|
* the speculative EOF preallocation garbage collector.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_inode_free_cowblocks(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
void *args)
|
|
|
|
{
|
|
|
|
struct xfs_eofblocks *eofb = args;
|
2021-01-23 03:48:35 +03:00
|
|
|
bool wait;
|
2018-01-17 06:03:59 +03:00
|
|
|
int ret = 0;
|
|
|
|
|
2021-01-23 03:48:35 +03:00
|
|
|
wait = eofb && (eofb->eof_flags & XFS_EOF_FLAGS_SYNC);
|
|
|
|
|
2018-07-18 02:51:51 +03:00
|
|
|
if (!xfs_prep_free_cowblocks(ip))
|
2016-10-03 19:11:46 +03:00
|
|
|
return 0;
|
|
|
|
|
2020-05-21 23:08:48 +03:00
|
|
|
if (!xfs_inode_matches_eofb(ip, eofb))
|
|
|
|
return 0;
|
2016-10-03 19:11:46 +03:00
|
|
|
|
2021-01-23 03:48:35 +03:00
|
|
|
/*
|
|
|
|
* If the caller is waiting, return -EAGAIN to keep the background
|
|
|
|
* scanner moving and revisit the inode in a subsequent pass.
|
|
|
|
*/
|
|
|
|
if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
|
|
|
|
if (wait)
|
|
|
|
return -EAGAIN;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!xfs_ilock_nowait(ip, XFS_MMAPLOCK_EXCL)) {
|
|
|
|
if (wait)
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out_iolock;
|
|
|
|
}
|
2016-10-03 19:11:46 +03:00
|
|
|
|
2018-01-17 06:03:59 +03:00
|
|
|
/*
|
|
|
|
* Check again, nobody else should be able to dirty blocks or change
|
|
|
|
* the reflink iflag now that we have the first two locks held.
|
|
|
|
*/
|
2018-07-18 02:51:51 +03:00
|
|
|
if (xfs_prep_free_cowblocks(ip))
|
2018-01-17 06:03:59 +03:00
|
|
|
ret = xfs_reflink_cancel_cow_range(ip, 0, NULLFILEOFF, false);
|
2016-10-03 19:11:46 +03:00
|
|
|
|
2017-01-28 10:22:56 +03:00
|
|
|
xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
|
2021-01-23 03:48:35 +03:00
|
|
|
out_iolock:
|
2017-01-28 10:22:56 +03:00
|
|
|
xfs_iunlock(ip, XFS_IOLOCK_EXCL);
|
2016-10-03 19:11:46 +03:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
xfs_icache_free_cowblocks(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_eofblocks *eofb)
|
|
|
|
{
|
2020-05-21 23:08:50 +03:00
|
|
|
return xfs_inode_walk(mp, 0, xfs_inode_free_cowblocks, eofb,
|
2016-10-03 19:11:46 +03:00
|
|
|
XFS_ICI_COWBLOCKS_TAG);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_inode_set_cowblocks_tag(
|
|
|
|
xfs_inode_t *ip)
|
|
|
|
{
|
2016-10-24 06:21:00 +03:00
|
|
|
trace_xfs_inode_set_cowblocks_tag(ip);
|
2017-12-15 02:42:22 +03:00
|
|
|
return __xfs_inode_set_blocks_tag(ip, xfs_queue_cowblocks,
|
2016-10-24 06:21:00 +03:00
|
|
|
trace_xfs_perag_set_cowblocks,
|
2016-10-03 19:11:46 +03:00
|
|
|
XFS_ICI_COWBLOCKS_TAG);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_inode_clear_cowblocks_tag(
|
|
|
|
xfs_inode_t *ip)
|
|
|
|
{
|
2016-10-24 06:21:00 +03:00
|
|
|
trace_xfs_inode_clear_cowblocks_tag(ip);
|
2017-12-15 02:42:22 +03:00
|
|
|
return __xfs_inode_clear_blocks_tag(ip,
|
2016-10-24 06:21:00 +03:00
|
|
|
trace_xfs_perag_clear_cowblocks, XFS_ICI_COWBLOCKS_TAG);
|
2016-10-03 19:11:46 +03:00
|
|
|
}
|
2018-05-09 20:03:56 +03:00
|
|
|
|
|
|
|
/* Disable post-EOF and CoW block auto-reclamation. */
|
|
|
|
void
|
2019-04-26 04:26:22 +03:00
|
|
|
xfs_stop_block_reaping(
|
2018-05-09 20:03:56 +03:00
|
|
|
struct xfs_mount *mp)
|
|
|
|
{
|
|
|
|
cancel_delayed_work_sync(&mp->m_eofblocks_work);
|
|
|
|
cancel_delayed_work_sync(&mp->m_cowblocks_work);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable post-EOF and CoW block auto-reclamation. */
|
|
|
|
void
|
2019-04-26 04:26:22 +03:00
|
|
|
xfs_start_block_reaping(
|
2018-05-09 20:03:56 +03:00
|
|
|
struct xfs_mount *mp)
|
|
|
|
{
|
|
|
|
xfs_queue_eofblocks(mp);
|
|
|
|
xfs_queue_cowblocks(mp);
|
|
|
|
}
|
2021-01-23 03:48:36 +03:00
|
|
|
|
2021-01-23 03:48:39 +03:00
|
|
|
/* Scan all incore inodes for block preallocations that we can remove. */
|
|
|
|
static inline int
|
|
|
|
xfs_blockgc_scan(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_eofblocks *eofb)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = xfs_icache_free_eofblocks(mp, eofb);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
error = xfs_icache_free_cowblocks(mp, eofb);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to free space in the filesystem by purging eofblocks and cowblocks.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_blockgc_free_space(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_eofblocks *eofb)
|
|
|
|
{
|
|
|
|
trace_xfs_blockgc_free_space(mp, eofb, _RET_IP_);
|
|
|
|
|
|
|
|
return xfs_blockgc_scan(mp, eofb);
|
|
|
|
}
|
|
|
|
|
2021-01-23 03:48:36 +03:00
|
|
|
/*
|
2021-01-23 03:48:37 +03:00
|
|
|
* Run cow/eofblocks scans on the supplied dquots. We don't know exactly which
|
|
|
|
* quota caused an allocation failure, so we make a best effort by including
|
|
|
|
* each quota under low free space conditions (less than 1% free space) in the
|
|
|
|
* scan.
|
2021-01-23 03:48:36 +03:00
|
|
|
*
|
|
|
|
* Callers must not hold any inode's ILOCK. If requesting a synchronous scan
|
|
|
|
* (XFS_EOF_FLAGS_SYNC), the caller also must not hold any inode's IOLOCK or
|
|
|
|
* MMAPLOCK.
|
2021-01-23 03:48:36 +03:00
|
|
|
*/
|
2021-01-23 03:48:36 +03:00
|
|
|
int
|
2021-01-23 03:48:37 +03:00
|
|
|
xfs_blockgc_free_dquots(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_dquot *udqp,
|
|
|
|
struct xfs_dquot *gdqp,
|
|
|
|
struct xfs_dquot *pdqp,
|
2021-01-23 03:48:36 +03:00
|
|
|
unsigned int eof_flags)
|
2021-01-23 03:48:36 +03:00
|
|
|
{
|
|
|
|
struct xfs_eofblocks eofb = {0};
|
|
|
|
bool do_work = false;
|
|
|
|
|
2021-01-23 03:48:37 +03:00
|
|
|
if (!udqp && !gdqp && !pdqp)
|
|
|
|
return 0;
|
|
|
|
|
2021-01-23 03:48:36 +03:00
|
|
|
/*
|
2021-01-23 03:48:36 +03:00
|
|
|
* Run a scan to free blocks using the union filter to cover all
|
|
|
|
* applicable quotas in a single scan.
|
2021-01-23 03:48:36 +03:00
|
|
|
*/
|
2021-01-23 03:48:36 +03:00
|
|
|
eofb.eof_flags = XFS_EOF_FLAGS_UNION | eof_flags;
|
2021-01-23 03:48:36 +03:00
|
|
|
|
2021-01-23 03:48:37 +03:00
|
|
|
if (XFS_IS_UQUOTA_ENFORCED(mp) && udqp && xfs_dquot_lowsp(udqp)) {
|
|
|
|
eofb.eof_uid = make_kuid(mp->m_super->s_user_ns, udqp->q_id);
|
|
|
|
eofb.eof_flags |= XFS_EOF_FLAGS_UID;
|
|
|
|
do_work = true;
|
2021-01-23 03:48:36 +03:00
|
|
|
}
|
|
|
|
|
2021-01-23 03:48:37 +03:00
|
|
|
if (XFS_IS_UQUOTA_ENFORCED(mp) && gdqp && xfs_dquot_lowsp(gdqp)) {
|
|
|
|
eofb.eof_gid = make_kgid(mp->m_super->s_user_ns, gdqp->q_id);
|
|
|
|
eofb.eof_flags |= XFS_EOF_FLAGS_GID;
|
|
|
|
do_work = true;
|
2021-01-23 03:48:36 +03:00
|
|
|
}
|
|
|
|
|
2021-01-23 03:48:37 +03:00
|
|
|
if (XFS_IS_PQUOTA_ENFORCED(mp) && pdqp && xfs_dquot_lowsp(pdqp)) {
|
|
|
|
eofb.eof_prid = pdqp->q_id;
|
|
|
|
eofb.eof_flags |= XFS_EOF_FLAGS_PRID;
|
|
|
|
do_work = true;
|
2021-01-23 03:48:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!do_work)
|
2021-01-23 03:48:36 +03:00
|
|
|
return 0;
|
2021-01-23 03:48:36 +03:00
|
|
|
|
2021-01-23 03:48:39 +03:00
|
|
|
return xfs_blockgc_free_space(mp, &eofb);
|
2021-01-23 03:48:37 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Run cow/eofblocks scans on the quotas attached to the inode. */
|
|
|
|
int
|
|
|
|
xfs_blockgc_free_quota(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
unsigned int eof_flags)
|
|
|
|
{
|
|
|
|
return xfs_blockgc_free_dquots(ip->i_mount,
|
|
|
|
xfs_inode_dquot(ip, XFS_DQTYPE_USER),
|
|
|
|
xfs_inode_dquot(ip, XFS_DQTYPE_GROUP),
|
|
|
|
xfs_inode_dquot(ip, XFS_DQTYPE_PROJ), eof_flags);
|
2021-01-23 03:48:36 +03:00
|
|
|
}
|