2008-10-30 13:06:08 +07:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2000-2005 Silicon Graphics, Inc.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it would be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
|
|
|
#include "xfs_fs.h"
|
2013-08-12 17:49:26 +07:00
|
|
|
#include "xfs_format.h"
|
2013-10-23 06:50:10 +07:00
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2008-10-30 13:06:08 +07:00
|
|
|
#include "xfs_sb.h"
|
|
|
|
#include "xfs_mount.h"
|
|
|
|
#include "xfs_inode.h"
|
|
|
|
#include "xfs_error.h"
|
2013-10-23 06:50:10 +07:00
|
|
|
#include "xfs_trans.h"
|
|
|
|
#include "xfs_trans_priv.h"
|
2008-10-30 13:06:08 +07:00
|
|
|
#include "xfs_inode_item.h"
|
2009-06-08 20:33:32 +07:00
|
|
|
#include "xfs_quota.h"
|
2009-12-15 06:14:59 +07:00
|
|
|
#include "xfs_trace.h"
|
2012-10-08 17:56:09 +07:00
|
|
|
#include "xfs_icache.h"
|
2013-08-12 17:49:45 +07:00
|
|
|
#include "xfs_bmap_util.h"
|
2014-07-24 16:49:28 +07:00
|
|
|
#include "xfs_dquot_item.h"
|
|
|
|
#include "xfs_dquot.h"
|
2016-10-03 23:11:46 +07:00
|
|
|
#include "xfs_reflink.h"
|
2008-10-30 13:06:08 +07:00
|
|
|
|
2008-10-30 13:06:18 +07:00
|
|
|
#include <linux/kthread.h>
|
|
|
|
#include <linux/freezer.h>
|
|
|
|
|
2012-10-08 17:56:11 +07: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 07:23:45 +07:00
|
|
|
struct xfs_inode *
|
2012-10-08 17:56:11 +07:00
|
|
|
xfs_inode_alloc(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_ino_t ino)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if this didn't occur in transactions, we could use
|
|
|
|
* KM_MAYFAIL and return NULL here on ENOMEM. Set the
|
|
|
|
* code up to do this anyway.
|
|
|
|
*/
|
|
|
|
ip = kmem_zone_alloc(xfs_inode_zone, KM_SLEEP);
|
|
|
|
if (!ip)
|
|
|
|
return NULL;
|
|
|
|
if (inode_init_always(mp->m_super, VFS_I(ip))) {
|
|
|
|
kmem_zone_free(xfs_inode_zone, ip);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-02-09 12:54:58 +07:00
|
|
|
/* VFS doesn't initialise i_mode! */
|
|
|
|
VFS_I(ip)->i_mode = 0;
|
|
|
|
|
2015-10-12 14:21:22 +07:00
|
|
|
XFS_STATS_INC(mp, vn_active);
|
2012-10-08 17:56:11 +07:00
|
|
|
ASSERT(atomic_read(&ip->i_pincount) == 0);
|
|
|
|
ASSERT(!xfs_isiflocked(ip));
|
|
|
|
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 23:11:32 +07:00
|
|
|
ip->i_cowfp = NULL;
|
|
|
|
ip->i_cnextents = 0;
|
|
|
|
ip->i_cformat = XFS_DINODE_FMT_EXTENTS;
|
2012-10-08 17:56:11 +07:00
|
|
|
memset(&ip->i_df, 0, sizeof(xfs_ifork_t));
|
|
|
|
ip->i_flags = 0;
|
|
|
|
ip->i_delayed_blks = 0;
|
2016-02-09 12:54:58 +07:00
|
|
|
memset(&ip->i_d, 0, sizeof(ip->i_d));
|
2012-10-08 17:56:11 +07: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 12:54:58 +07:00
|
|
|
switch (VFS_I(ip)->i_mode & S_IFMT) {
|
2012-10-08 17:56:11 +07:00
|
|
|
case S_IFREG:
|
|
|
|
case S_IFDIR:
|
|
|
|
case S_IFLNK:
|
|
|
|
xfs_idestroy_fork(ip, XFS_DATA_FORK);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ip->i_afp)
|
|
|
|
xfs_idestroy_fork(ip, XFS_ATTR_FORK);
|
2016-10-03 23:11:32 +07:00
|
|
|
if (ip->i_cowfp)
|
|
|
|
xfs_idestroy_fork(ip, XFS_COW_FORK);
|
2012-10-08 17:56:11 +07:00
|
|
|
|
|
|
|
if (ip->i_itemp) {
|
|
|
|
ASSERT(!(ip->i_itemp->ili_item.li_flags & XFS_LI_IN_AIL));
|
|
|
|
xfs_inode_item_destroy(ip);
|
|
|
|
ip->i_itemp = NULL;
|
|
|
|
}
|
|
|
|
|
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 11:01:53 +07:00
|
|
|
kmem_zone_free(xfs_inode_zone, ip);
|
|
|
|
}
|
|
|
|
|
2016-05-18 11:09:12 +07: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);
|
|
|
|
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 11:01:53 +07:00
|
|
|
void
|
|
|
|
xfs_inode_free(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
2016-11-10 04:23:22 +07:00
|
|
|
ASSERT(!xfs_isiflocked(ip));
|
|
|
|
|
2012-10-08 17:56:11 +07: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 11:09:12 +07:00
|
|
|
__xfs_inode_free(ip);
|
2012-10-08 17:56:11 +07:00
|
|
|
}
|
|
|
|
|
2016-05-18 11:20:08 +07:00
|
|
|
/*
|
|
|
|
* Queue a new inode reclaim pass if there are reclaimable inodes and there
|
|
|
|
* isn't a reclaim pass already in progress. By default it runs every 5s based
|
|
|
|
* on the xfs periodic sync default of 30s. Perhaps this should have it's own
|
|
|
|
* tunable, but that can be done if this method proves to be ineffective or too
|
|
|
|
* aggressive.
|
|
|
|
*/
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
* goes low. It scans as quickly as possible avoiding locked inodes or those
|
|
|
|
* already being flushed, and once done schedules a future pass.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_reclaim_worker(
|
|
|
|
struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = container_of(to_delayed_work(work),
|
|
|
|
struct xfs_mount, m_reclaim_work);
|
|
|
|
|
|
|
|
xfs_reclaim_inodes(mp, SYNC_TRYLOCK);
|
|
|
|
xfs_reclaim_work_queue(mp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xfs_perag_set_reclaim_tag(
|
|
|
|
struct xfs_perag *pag)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = pag->pag_mount;
|
|
|
|
|
2017-06-08 22:23:07 +07:00
|
|
|
lockdep_assert_held(&pag->pag_ici_lock);
|
2016-05-18 11:20:08 +07: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 22:23:07 +07:00
|
|
|
lockdep_assert_held(&pag->pag_ici_lock);
|
2016-05-18 11:20:08 +07: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 22:30:39 +07: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 17:25:39 +07:00
|
|
|
prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
|
2017-04-26 22:30:39 +07:00
|
|
|
if (!xfs_iflags_test(ip, XFS_INEW))
|
|
|
|
break;
|
|
|
|
schedule();
|
|
|
|
} while (true);
|
2017-03-05 17:25:39 +07:00
|
|
|
finish_wait(wq, &wait.wq_entry);
|
2017-04-26 22:30:39 +07:00
|
|
|
}
|
|
|
|
|
2016-02-09 12:54:58 +07: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 12:54:58 +07:00
|
|
|
* overwrite the values unconditionally. Hence we save the parameters we
|
2016-02-09 12:54:58 +07:00
|
|
|
* need to retain across reinitialisation, and rewrite them into the VFS inode
|
2016-02-09 12:54:58 +07:00
|
|
|
* after reinitialisation even if it fails.
|
2016-02-09 12:54:58 +07:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_reinit_inode(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct inode *inode)
|
|
|
|
{
|
|
|
|
int error;
|
2016-02-09 12:54:58 +07:00
|
|
|
uint32_t nlink = inode->i_nlink;
|
2016-02-09 12:54:58 +07:00
|
|
|
uint32_t generation = inode->i_generation;
|
2016-02-09 12:54:58 +07:00
|
|
|
uint64_t version = inode->i_version;
|
2016-02-09 12:54:58 +07:00
|
|
|
umode_t mode = inode->i_mode;
|
2016-02-09 12:54:58 +07:00
|
|
|
|
|
|
|
error = inode_init_always(mp->m_super, inode);
|
|
|
|
|
2016-02-09 12:54:58 +07:00
|
|
|
set_nlink(inode, nlink);
|
2016-02-09 12:54:58 +07:00
|
|
|
inode->i_generation = generation;
|
2016-02-09 12:54:58 +07:00
|
|
|
inode->i_version = version;
|
2016-02-09 12:54:58 +07:00
|
|
|
inode->i_mode = mode;
|
2016-02-09 12:54:58 +07:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2012-10-08 17:56:11 +07: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 14:21:22 +07:00
|
|
|
XFS_STATS_INC(mp, xs_ig_frecycle);
|
2014-06-25 11:58:08 +07:00
|
|
|
error = -EAGAIN;
|
2012-10-08 17:56:11 +07: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 14:21:22 +07:00
|
|
|
XFS_STATS_INC(mp, xs_ig_frecycle);
|
2014-06-25 11:58:08 +07:00
|
|
|
error = -EAGAIN;
|
2012-10-08 17:56:11 +07:00
|
|
|
goto out_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If lookup is racing with unlink return an error immediately.
|
|
|
|
*/
|
2016-02-09 12:54:58 +07:00
|
|
|
if (VFS_I(ip)->i_mode == 0 && !(flags & XFS_IGET_CREATE)) {
|
2014-06-25 11:58:08 +07:00
|
|
|
error = -ENOENT;
|
2012-10-08 17:56:11 +07: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 22:58:56 +07:00
|
|
|
if (flags & XFS_IGET_INCORE) {
|
|
|
|
error = -EAGAIN;
|
|
|
|
goto out_error;
|
|
|
|
}
|
|
|
|
|
2012-10-08 17:56:11 +07: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();
|
|
|
|
|
2016-02-09 12:54:58 +07:00
|
|
|
error = xfs_reinit_inode(mp, inode);
|
2012-10-08 17:56:11 +07:00
|
|
|
if (error) {
|
2017-04-26 22:30:39 +07:00
|
|
|
bool wake;
|
2012-10-08 17:56:11 +07: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 22:30:39 +07:00
|
|
|
wake = !!__xfs_iflags_test(ip, XFS_INEW);
|
2012-10-08 17:56:11 +07:00
|
|
|
ip->i_flags &= ~(XFS_INEW | XFS_IRECLAIM);
|
2017-04-26 22:30:39 +07:00
|
|
|
if (wake)
|
|
|
|
wake_up_bit(&ip->i_flags, __XFS_INEW_BIT);
|
2012-10-08 17:56:11 +07: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 11:11:41 +07:00
|
|
|
xfs_inode_clear_reclaim_tag(pag, ip->i_ino);
|
2012-10-08 17:56:11 +07:00
|
|
|
inode->i_state = I_NEW;
|
|
|
|
|
2016-11-30 10:33:25 +07:00
|
|
|
ASSERT(!rwsem_is_locked(&inode->i_rwsem));
|
|
|
|
init_rwsem(&inode->i_rwsem);
|
2012-10-08 17:56:11 +07: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 11:58:08 +07:00
|
|
|
error = -EAGAIN;
|
2012-10-08 17:56:11 +07: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 22:58:56 +07:00
|
|
|
if (!(flags & XFS_IGET_INCORE))
|
|
|
|
xfs_iflags_clear(ip, XFS_ISTALE | XFS_IDONTCACHE);
|
2015-10-12 14:21:22 +07:00
|
|
|
XFS_STATS_INC(mp, xs_ig_found);
|
2012-10-08 17:56:11 +07: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 11:58:08 +07:00
|
|
|
return -ENOMEM;
|
2012-10-08 17:56:11 +07:00
|
|
|
|
|
|
|
error = xfs_iread(mp, tp, ip, flags);
|
|
|
|
if (error)
|
|
|
|
goto out_destroy;
|
|
|
|
|
|
|
|
trace_xfs_iget_miss(ip);
|
|
|
|
|
2016-02-09 12:54:58 +07:00
|
|
|
if ((VFS_I(ip)->i_mode == 0) && !(flags & XFS_IGET_CREATE)) {
|
2014-06-25 11:58:08 +07:00
|
|
|
error = -ENOENT;
|
2012-10-08 17:56:11 +07: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 11:58:08 +07:00
|
|
|
error = -EAGAIN;
|
2012-10-08 17:56:11 +07: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)
|
|
|
|
iflags |= XFS_IDONTCACHE;
|
2013-06-28 05:25:07 +07:00
|
|
|
ip->i_udquot = NULL;
|
|
|
|
ip->i_gdquot = NULL;
|
2013-07-11 12:00:40 +07:00
|
|
|
ip->i_pdquot = NULL;
|
2012-10-08 17:56:11 +07: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 14:21:22 +07:00
|
|
|
XFS_STATS_INC(mp, xs_ig_dup);
|
2014-06-25 11:58:08 +07:00
|
|
|
error = -EAGAIN;
|
2012-10-08 17:56:11 +07: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* The inode is locked according to the value of the lock_flags parameter.
|
|
|
|
* This flag parameter indicates how and if the inode's IO lock and inode lock
|
|
|
|
* should be taken.
|
|
|
|
*
|
|
|
|
* mp -- the mount point structure for the current file system. It points
|
|
|
|
* to the inode hash table.
|
|
|
|
* tp -- a pointer to the current transaction if there is one. This is
|
|
|
|
* simply passed through to the xfs_iread() call.
|
|
|
|
* ino -- the number of the inode desired. This is the unique identifier
|
|
|
|
* within the file system for the inode being requested.
|
|
|
|
* lock_flags -- flags indicating how to lock the inode. See the comment
|
|
|
|
* for xfs_ilock() for a list of valid values.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_iget(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
xfs_trans_t *tp,
|
|
|
|
xfs_ino_t ino,
|
|
|
|
uint flags,
|
|
|
|
uint lock_flags,
|
|
|
|
xfs_inode_t **ipp)
|
|
|
|
{
|
|
|
|
xfs_inode_t *ip;
|
|
|
|
int error;
|
|
|
|
xfs_perag_t *pag;
|
|
|
|
xfs_agino_t agino;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xfs_reclaim_inode() uses the ILOCK to ensure an inode
|
|
|
|
* doesn't get freed while it's being referenced during a
|
|
|
|
* radix tree traversal here. It assumes this function
|
|
|
|
* aqcuires only the ILOCK (and therefore it has no need to
|
|
|
|
* involve the IOLOCK in this synchronization).
|
|
|
|
*/
|
|
|
|
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 11:58:08 +07:00
|
|
|
return -EINVAL;
|
2012-10-08 17:56:11 +07:00
|
|
|
|
2015-10-12 14:21:22 +07:00
|
|
|
XFS_STATS_INC(mp, xs_ig_attempts);
|
2015-08-28 11:50:56 +07:00
|
|
|
|
2012-10-08 17:56:11 +07: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 22:58:56 +07:00
|
|
|
if (flags & XFS_IGET_INCORE) {
|
2017-10-18 11:37:32 +07:00
|
|
|
error = -ENODATA;
|
2017-06-19 22:58:56 +07:00
|
|
|
goto out_error_or_again;
|
|
|
|
}
|
2015-10-12 14:21:22 +07:00
|
|
|
XFS_STATS_INC(mp, xs_ig_missed);
|
2012-10-08 17:56:11 +07: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 18:38:08 +07:00
|
|
|
* If we have a real type for an on-disk inode, we can setup the inode
|
2012-10-08 17:56:11 +07:00
|
|
|
* now. If it's a new inode being created, xfs_ialloc will handle it.
|
|
|
|
*/
|
2016-02-09 12:54:58 +07:00
|
|
|
if (xfs_iflags_test(ip, XFS_INEW) && VFS_I(ip)->i_mode != 0)
|
2015-02-23 18:38:08 +07:00
|
|
|
xfs_setup_existing_inode(ip);
|
2012-10-08 17:56:11 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_error_or_again:
|
2017-06-19 22:58:56 +07:00
|
|
|
if (!(flags & XFS_IGET_INCORE) && error == -EAGAIN) {
|
2012-10-08 17:56:11 +07:00
|
|
|
delay(1);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
xfs_perag_put(pag);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-06-19 22:58:56 +07: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);
|
|
|
|
IRELE(ip);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-28 09:28:19 +07: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
|
|
|
|
|
2010-09-28 09:28:06 +07:00
|
|
|
STATIC int
|
|
|
|
xfs_inode_ag_walk_grab(
|
2017-04-26 22:30:39 +07:00
|
|
|
struct xfs_inode *ip,
|
|
|
|
int flags)
|
2010-09-28 09:28:06 +07:00
|
|
|
{
|
|
|
|
struct inode *inode = VFS_I(ip);
|
2017-04-26 22:30:39 +07:00
|
|
|
bool newinos = !!(flags & XFS_AGITER_INEW_WAIT);
|
2010-09-28 09:28:06 +07:00
|
|
|
|
2010-12-17 13:29:43 +07:00
|
|
|
ASSERT(rcu_read_lock_held());
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check for stale RCU freed inode
|
|
|
|
*
|
|
|
|
* If the inode has been reallocated, it doesn't matter if it's not in
|
|
|
|
* the AG we are walking - we are walking for writeback, so if it
|
|
|
|
* passes all the "valid inode" checks and is dirty, then we'll write
|
|
|
|
* it back anyway. If it has been reallocated and still being
|
|
|
|
* initialised, the XFS_INEW check below will catch it.
|
|
|
|
*/
|
|
|
|
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 22:30:39 +07:00
|
|
|
if ((!newinos && __xfs_iflags_test(ip, XFS_INEW)) ||
|
|
|
|
__xfs_iflags_test(ip, XFS_IRECLAIMABLE | XFS_IRECLAIM))
|
2010-12-17 13:29:43 +07:00
|
|
|
goto out_unlock_noent;
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
|
2010-09-28 09:28:06 +07:00
|
|
|
/* nothing to sync during shutdown */
|
|
|
|
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
|
2014-06-25 11:58:08 +07:00
|
|
|
return -EFSCORRUPTED;
|
2010-09-28 09:28:06 +07:00
|
|
|
|
|
|
|
/* If we can't grab the inode, it must on it's way to reclaim. */
|
|
|
|
if (!igrab(inode))
|
2014-06-25 11:58:08 +07:00
|
|
|
return -ENOENT;
|
2010-09-28 09:28:06 +07:00
|
|
|
|
|
|
|
/* inode is valid */
|
|
|
|
return 0;
|
2010-12-17 13:29:43 +07:00
|
|
|
|
|
|
|
out_unlock_noent:
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2014-06-25 11:58:08 +07:00
|
|
|
return -ENOENT;
|
2010-09-28 09:28:06 +07:00
|
|
|
}
|
|
|
|
|
2009-06-08 20:35:14 +07:00
|
|
|
STATIC int
|
|
|
|
xfs_inode_ag_walk(
|
|
|
|
struct xfs_mount *mp,
|
2010-01-11 18:47:40 +07:00
|
|
|
struct xfs_perag *pag,
|
2014-04-14 16:04:19 +07:00
|
|
|
int (*execute)(struct xfs_inode *ip, int flags,
|
2012-11-06 21:50:39 +07:00
|
|
|
void *args),
|
|
|
|
int flags,
|
|
|
|
void *args,
|
2017-04-26 22:30:39 +07:00
|
|
|
int tag,
|
|
|
|
int iter_flags)
|
2009-06-08 20:35:14 +07:00
|
|
|
{
|
|
|
|
uint32_t first_index;
|
|
|
|
int last_error = 0;
|
|
|
|
int skipped;
|
2010-09-24 15:40:15 +07:00
|
|
|
int done;
|
2010-09-28 09:28:19 +07:00
|
|
|
int nr_found;
|
2009-06-08 20:35:14 +07:00
|
|
|
|
|
|
|
restart:
|
2010-09-24 15:40:15 +07:00
|
|
|
done = 0;
|
2009-06-08 20:35:14 +07:00
|
|
|
skipped = 0;
|
|
|
|
first_index = 0;
|
2010-09-28 09:28:19 +07:00
|
|
|
nr_found = 0;
|
2009-06-08 20:35:14 +07:00
|
|
|
do {
|
2010-09-28 09:28:19 +07:00
|
|
|
struct xfs_inode *batch[XFS_LOOKUP_BATCH];
|
2009-06-08 20:35:14 +07:00
|
|
|
int error = 0;
|
2010-09-28 09:28:19 +07:00
|
|
|
int i;
|
2009-06-08 20:35:14 +07:00
|
|
|
|
2010-12-17 13:29:43 +07:00
|
|
|
rcu_read_lock();
|
2012-11-06 21:50:39 +07:00
|
|
|
|
|
|
|
if (tag == -1)
|
|
|
|
nr_found = radix_tree_gang_lookup(&pag->pag_ici_root,
|
2010-09-28 09:28:19 +07:00
|
|
|
(void **)batch, first_index,
|
|
|
|
XFS_LOOKUP_BATCH);
|
2012-11-06 21:50:39 +07:00
|
|
|
else
|
|
|
|
nr_found = radix_tree_gang_lookup_tag(
|
|
|
|
&pag->pag_ici_root,
|
|
|
|
(void **) batch, first_index,
|
|
|
|
XFS_LOOKUP_BATCH, tag);
|
|
|
|
|
2010-09-24 15:40:15 +07:00
|
|
|
if (!nr_found) {
|
2010-12-17 13:29:43 +07:00
|
|
|
rcu_read_unlock();
|
2009-06-08 20:35:14 +07:00
|
|
|
break;
|
2010-01-11 06:51:45 +07:00
|
|
|
}
|
2009-06-08 20:35:14 +07:00
|
|
|
|
2010-09-24 15:40:15 +07:00
|
|
|
/*
|
2010-09-28 09:28:19 +07:00
|
|
|
* Grab the inodes before we drop the lock. if we found
|
|
|
|
* nothing, nr == 0 and the loop will be skipped.
|
2010-09-24 15:40:15 +07:00
|
|
|
*/
|
2010-09-28 09:28:19 +07:00
|
|
|
for (i = 0; i < nr_found; i++) {
|
|
|
|
struct xfs_inode *ip = batch[i];
|
|
|
|
|
2017-04-26 22:30:39 +07:00
|
|
|
if (done || xfs_inode_ag_walk_grab(ip, iter_flags))
|
2010-09-28 09:28:19 +07:00
|
|
|
batch[i] = NULL;
|
|
|
|
|
|
|
|
/*
|
2010-12-17 13:29:43 +07: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 09:28:19 +07:00
|
|
|
*/
|
2010-12-17 13:29:43 +07:00
|
|
|
if (XFS_INO_TO_AGNO(mp, ip->i_ino) != pag->pag_agno)
|
|
|
|
continue;
|
2010-09-28 09:28:19 +07: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-28 09:28:06 +07:00
|
|
|
}
|
2010-09-28 09:28:19 +07:00
|
|
|
|
|
|
|
/* unlock now we've grabbed the inodes. */
|
2010-12-17 13:29:43 +07:00
|
|
|
rcu_read_unlock();
|
2010-09-28 09:28:06 +07:00
|
|
|
|
2010-09-28 09:28:19 +07:00
|
|
|
for (i = 0; i < nr_found; i++) {
|
|
|
|
if (!batch[i])
|
|
|
|
continue;
|
2017-04-26 22:30:39 +07:00
|
|
|
if ((iter_flags & XFS_AGITER_INEW_WAIT) &&
|
|
|
|
xfs_iflags_test(batch[i], XFS_INEW))
|
|
|
|
xfs_inew_wait(batch[i]);
|
2014-04-14 16:04:19 +07:00
|
|
|
error = execute(batch[i], flags, args);
|
2010-09-28 09:28:19 +07:00
|
|
|
IRELE(batch[i]);
|
2014-06-25 11:58:08 +07:00
|
|
|
if (error == -EAGAIN) {
|
2010-09-28 09:28:19 +07:00
|
|
|
skipped++;
|
|
|
|
continue;
|
|
|
|
}
|
2014-06-25 11:58:08 +07:00
|
|
|
if (error && last_error != -EFSCORRUPTED)
|
2010-09-28 09:28:19 +07:00
|
|
|
last_error = error;
|
2009-06-08 20:35:14 +07:00
|
|
|
}
|
2010-01-11 06:51:45 +07:00
|
|
|
|
|
|
|
/* bail out if the filesystem is corrupted. */
|
2014-06-25 11:58:08 +07:00
|
|
|
if (error == -EFSCORRUPTED)
|
2009-06-08 20:35:14 +07:00
|
|
|
break;
|
|
|
|
|
2011-07-08 11:14:46 +07:00
|
|
|
cond_resched();
|
|
|
|
|
2010-09-28 09:28:19 +07:00
|
|
|
} while (nr_found && !done);
|
2009-06-08 20:35:14 +07:00
|
|
|
|
|
|
|
if (skipped) {
|
|
|
|
delay(1);
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
return last_error;
|
|
|
|
}
|
|
|
|
|
2012-11-06 21:50:47 +07:00
|
|
|
/*
|
|
|
|
* Background scanning to trim post-EOF preallocated space. This is queued
|
2013-08-16 01:08:02 +07:00
|
|
|
* based on the 'speculative_prealloc_lifetime' tunable (5m by default).
|
2012-11-06 21:50:47 +07:00
|
|
|
*/
|
2016-06-21 08:53:28 +07:00
|
|
|
void
|
2012-11-06 21:50:47 +07: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);
|
|
|
|
xfs_icache_free_eofblocks(mp, NULL);
|
|
|
|
xfs_queue_eofblocks(mp);
|
|
|
|
}
|
|
|
|
|
2016-10-03 23:11:46 +07: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 06:46:05 +07:00
|
|
|
void
|
2016-10-03 23:11:46 +07: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);
|
|
|
|
xfs_icache_free_cowblocks(mp, NULL);
|
|
|
|
xfs_queue_cowblocks(mp);
|
|
|
|
}
|
|
|
|
|
2009-06-08 20:35:27 +07:00
|
|
|
int
|
2017-04-26 22:30:39 +07:00
|
|
|
xfs_inode_ag_iterator_flags(
|
2009-06-08 20:35:14 +07:00
|
|
|
struct xfs_mount *mp,
|
2014-04-14 16:04:19 +07:00
|
|
|
int (*execute)(struct xfs_inode *ip, int flags,
|
2012-11-06 21:50:39 +07:00
|
|
|
void *args),
|
|
|
|
int flags,
|
2017-04-26 22:30:39 +07:00
|
|
|
void *args,
|
|
|
|
int iter_flags)
|
2009-06-08 20:35:14 +07:00
|
|
|
{
|
2010-07-20 06:43:39 +07:00
|
|
|
struct xfs_perag *pag;
|
2009-06-08 20:35:14 +07:00
|
|
|
int error = 0;
|
|
|
|
int last_error = 0;
|
|
|
|
xfs_agnumber_t ag;
|
|
|
|
|
2010-07-20 06:43:39 +07:00
|
|
|
ag = 0;
|
2010-09-24 15:40:15 +07:00
|
|
|
while ((pag = xfs_perag_get(mp, ag))) {
|
|
|
|
ag = pag->pag_agno + 1;
|
2017-04-26 22:30:39 +07:00
|
|
|
error = xfs_inode_ag_walk(mp, pag, execute, flags, args, -1,
|
|
|
|
iter_flags);
|
2012-11-06 21:50:39 +07:00
|
|
|
xfs_perag_put(pag);
|
|
|
|
if (error) {
|
|
|
|
last_error = error;
|
2014-06-25 11:58:08 +07:00
|
|
|
if (error == -EFSCORRUPTED)
|
2012-11-06 21:50:39 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-06-22 12:04:54 +07:00
|
|
|
return last_error;
|
2012-11-06 21:50:39 +07:00
|
|
|
}
|
|
|
|
|
2017-04-26 22:30:39 +07:00
|
|
|
int
|
|
|
|
xfs_inode_ag_iterator(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
int (*execute)(struct xfs_inode *ip, int flags,
|
|
|
|
void *args),
|
|
|
|
int flags,
|
|
|
|
void *args)
|
|
|
|
{
|
|
|
|
return xfs_inode_ag_iterator_flags(mp, execute, flags, args, 0);
|
|
|
|
}
|
|
|
|
|
2012-11-06 21:50:39 +07:00
|
|
|
int
|
|
|
|
xfs_inode_ag_iterator_tag(
|
|
|
|
struct xfs_mount *mp,
|
2014-04-14 16:04:19 +07:00
|
|
|
int (*execute)(struct xfs_inode *ip, int flags,
|
2012-11-06 21:50:39 +07:00
|
|
|
void *args),
|
|
|
|
int flags,
|
|
|
|
void *args,
|
|
|
|
int tag)
|
|
|
|
{
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
int error = 0;
|
|
|
|
int last_error = 0;
|
|
|
|
xfs_agnumber_t ag;
|
|
|
|
|
|
|
|
ag = 0;
|
|
|
|
while ((pag = xfs_perag_get_tag(mp, ag, tag))) {
|
|
|
|
ag = pag->pag_agno + 1;
|
2017-04-26 22:30:39 +07:00
|
|
|
error = xfs_inode_ag_walk(mp, pag, execute, flags, args, tag,
|
|
|
|
0);
|
2010-01-11 18:47:40 +07:00
|
|
|
xfs_perag_put(pag);
|
2009-06-08 20:35:14 +07:00
|
|
|
if (error) {
|
|
|
|
last_error = error;
|
2014-06-25 11:58:08 +07:00
|
|
|
if (error == -EFSCORRUPTED)
|
2009-06-08 20:35:14 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-06-22 12:04:54 +07:00
|
|
|
return last_error;
|
2009-06-08 20:35:14 +07:00
|
|
|
}
|
|
|
|
|
2010-09-24 16:51:50 +07:00
|
|
|
/*
|
|
|
|
* Grab the inode for reclaim exclusively.
|
|
|
|
* Return 0 if we grabbed it, non-zero otherwise.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_reclaim_inode_grab(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
int flags)
|
|
|
|
{
|
2010-12-17 13:29:43 +07:00
|
|
|
ASSERT(rcu_read_lock_held());
|
|
|
|
|
|
|
|
/* quick check for stale RCU freed inode */
|
|
|
|
if (!ip->i_ino)
|
|
|
|
return 1;
|
2010-09-24 16:51:50 +07:00
|
|
|
|
|
|
|
/*
|
2011-12-19 03:00:09 +07:00
|
|
|
* If we are asked for non-blocking operation, do unlocked checks to
|
|
|
|
* see if the inode already is being flushed or in reclaim to avoid
|
|
|
|
* lock traffic.
|
2010-09-24 16:51:50 +07:00
|
|
|
*/
|
|
|
|
if ((flags & SYNC_TRYLOCK) &&
|
2011-12-19 03:00:09 +07:00
|
|
|
__xfs_iflags_test(ip, XFS_IFLOCK | XFS_IRECLAIM))
|
2010-09-24 16:51:50 +07:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The radix tree lock here protects a thread in xfs_iget from racing
|
|
|
|
* with us starting reclaim on the inode. Once we have the
|
|
|
|
* XFS_IRECLAIM flag set it will not touch us.
|
2010-12-17 13:29:43 +07:00
|
|
|
*
|
|
|
|
* Due to RCU lookup, we may find inodes that have been freed and only
|
|
|
|
* have XFS_IRECLAIM set. Indeed, we may see reallocated inodes that
|
|
|
|
* aren't candidates for reclaim at all, so we must check the
|
|
|
|
* XFS_IRECLAIMABLE is set first before proceeding to reclaim.
|
2010-09-24 16:51:50 +07:00
|
|
|
*/
|
|
|
|
spin_lock(&ip->i_flags_lock);
|
2010-12-17 13:29:43 +07:00
|
|
|
if (!__xfs_iflags_test(ip, XFS_IRECLAIMABLE) ||
|
|
|
|
__xfs_iflags_test(ip, XFS_IRECLAIM)) {
|
|
|
|
/* not a reclaim candidate. */
|
2010-09-24 16:51:50 +07:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__xfs_iflags_set(ip, XFS_IRECLAIM);
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-06 08:37:26 +07:00
|
|
|
/*
|
2012-04-23 12:58:35 +07:00
|
|
|
* Inodes in different states need to be treated differently. The following
|
|
|
|
* table lists the inode states and the reclaim actions necessary:
|
2010-02-06 08:37:26 +07:00
|
|
|
*
|
|
|
|
* inode state iflush ret required action
|
|
|
|
* --------------- ---------- ---------------
|
|
|
|
* bad - reclaim
|
|
|
|
* shutdown EIO unpin and reclaim
|
|
|
|
* clean, unpinned 0 reclaim
|
|
|
|
* stale, unpinned 0 reclaim
|
2010-02-06 08:39:36 +07:00
|
|
|
* clean, pinned(*) 0 requeue
|
|
|
|
* stale, pinned EAGAIN requeue
|
2012-04-23 12:58:35 +07:00
|
|
|
* dirty, async - requeue
|
|
|
|
* dirty, sync 0 reclaim
|
2010-02-06 08:37:26 +07:00
|
|
|
*
|
|
|
|
* (*) dgc: I don't think the clean, pinned state is possible but it gets
|
|
|
|
* handled anyway given the order of checks implemented.
|
|
|
|
*
|
2010-02-06 08:39:36 +07:00
|
|
|
* Also, because we get the flush lock first, we know that any inode that has
|
|
|
|
* been flushed delwri has had the flush completed by the time we check that
|
2012-04-23 12:58:35 +07:00
|
|
|
* the inode is clean.
|
2010-02-06 08:39:36 +07:00
|
|
|
*
|
2012-04-23 12:58:35 +07:00
|
|
|
* Note that because the inode is flushed delayed write by AIL pushing, the
|
|
|
|
* flush lock may already be held here and waiting on it can result in very
|
|
|
|
* long latencies. Hence for sync reclaims, where we wait on the flush lock,
|
|
|
|
* the caller should push the AIL first before trying to reclaim inodes to
|
|
|
|
* minimise the amount of time spent waiting. For background relaim, we only
|
|
|
|
* bother to reclaim clean inodes anyway.
|
2010-02-06 08:39:36 +07:00
|
|
|
*
|
2010-02-06 08:37:26 +07:00
|
|
|
* Hence the order of actions after gaining the locks should be:
|
|
|
|
* bad => reclaim
|
|
|
|
* shutdown => unpin and reclaim
|
2012-04-23 12:58:35 +07:00
|
|
|
* pinned, async => requeue
|
2010-02-06 08:39:36 +07:00
|
|
|
* pinned, sync => unpin
|
2010-02-06 08:37:26 +07:00
|
|
|
* stale => reclaim
|
|
|
|
* clean => reclaim
|
2012-04-23 12:58:35 +07:00
|
|
|
* dirty, async => requeue
|
2010-02-06 08:39:36 +07:00
|
|
|
* dirty, sync => flush, wait and reclaim
|
2010-02-06 08:37:26 +07:00
|
|
|
*/
|
2009-06-08 20:35:14 +07:00
|
|
|
STATIC int
|
2010-01-11 06:51:45 +07:00
|
|
|
xfs_reclaim_inode(
|
2009-06-08 20:35:14 +07:00
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_perag *pag,
|
2010-01-11 06:51:45 +07:00
|
|
|
int sync_mode)
|
2008-10-30 13:37:03 +07:00
|
|
|
{
|
2012-04-23 12:58:36 +07:00
|
|
|
struct xfs_buf *bp = NULL;
|
2016-05-18 11:09:12 +07:00
|
|
|
xfs_ino_t ino = ip->i_ino; /* for radix_tree_delete */
|
2012-04-23 12:58:36 +07:00
|
|
|
int error;
|
2010-02-06 08:37:26 +07:00
|
|
|
|
2011-03-26 05:13:55 +07:00
|
|
|
restart:
|
|
|
|
error = 0;
|
2010-01-11 06:51:45 +07:00
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
2010-02-06 08:39:36 +07:00
|
|
|
if (!xfs_iflock_nowait(ip)) {
|
|
|
|
if (!(sync_mode & SYNC_WAIT))
|
|
|
|
goto out;
|
|
|
|
xfs_iflock(ip);
|
|
|
|
}
|
2008-10-30 13:37:37 +07:00
|
|
|
|
2010-02-06 08:37:26 +07:00
|
|
|
if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
|
|
|
|
xfs_iunpin_wait(ip);
|
2016-11-10 04:23:22 +07:00
|
|
|
/* xfs_iflush_abort() drops the flush lock */
|
2012-04-23 12:58:41 +07:00
|
|
|
xfs_iflush_abort(ip, false);
|
2010-02-06 08:37:26 +07:00
|
|
|
goto reclaim;
|
|
|
|
}
|
2010-02-06 08:39:36 +07:00
|
|
|
if (xfs_ipincount(ip)) {
|
2012-04-23 12:58:35 +07:00
|
|
|
if (!(sync_mode & SYNC_WAIT))
|
|
|
|
goto out_ifunlock;
|
2010-02-06 08:37:26 +07:00
|
|
|
xfs_iunpin_wait(ip);
|
2010-02-06 08:39:36 +07:00
|
|
|
}
|
2016-11-10 04:23:22 +07:00
|
|
|
if (xfs_iflags_test(ip, XFS_ISTALE) || xfs_inode_clean(ip)) {
|
|
|
|
xfs_ifunlock(ip);
|
2010-02-06 08:37:26 +07:00
|
|
|
goto reclaim;
|
2016-11-10 04:23:22 +07:00
|
|
|
}
|
2010-02-06 08:37:26 +07:00
|
|
|
|
2012-04-23 12:58:35 +07:00
|
|
|
/*
|
|
|
|
* Never flush out dirty data during non-blocking reclaim, as it would
|
|
|
|
* just contend with AIL pushing trying to do the same job.
|
|
|
|
*/
|
|
|
|
if (!(sync_mode & SYNC_WAIT))
|
|
|
|
goto out_ifunlock;
|
|
|
|
|
2011-03-26 05:13:55 +07:00
|
|
|
/*
|
|
|
|
* Now we have an inode that needs flushing.
|
|
|
|
*
|
2012-04-23 12:58:36 +07:00
|
|
|
* Note that xfs_iflush will never block on the inode buffer lock, as
|
2011-03-26 05:13:55 +07:00
|
|
|
* xfs_ifree_cluster() can lock the inode buffer before it locks the
|
2012-04-23 12:58:36 +07:00
|
|
|
* ip->i_lock, and we are doing the exact opposite here. As a result,
|
2012-07-03 23:21:22 +07:00
|
|
|
* doing a blocking xfs_imap_to_bp() to get the cluster buffer would
|
|
|
|
* result in an ABBA deadlock with xfs_ifree_cluster().
|
2011-03-26 05:13:55 +07:00
|
|
|
*
|
|
|
|
* As xfs_ifree_cluser() must gather all inodes that are active in the
|
|
|
|
* cache to mark them stale, if we hit this case we don't actually want
|
|
|
|
* to do IO here - we want the inode marked stale so we can simply
|
2012-04-23 12:58:36 +07:00
|
|
|
* reclaim it. Hence if we get an EAGAIN error here, just unlock the
|
|
|
|
* inode, back off and try again. Hopefully the next pass through will
|
|
|
|
* see the stale flag set on the inode.
|
2011-03-26 05:13:55 +07:00
|
|
|
*/
|
2012-04-23 12:58:36 +07:00
|
|
|
error = xfs_iflush(ip, &bp);
|
2014-06-25 11:58:08 +07:00
|
|
|
if (error == -EAGAIN) {
|
2012-04-23 12:58:35 +07:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
/* backoff longer than in xfs_ifree_cluster */
|
|
|
|
delay(2);
|
|
|
|
goto restart;
|
2010-02-06 08:39:36 +07:00
|
|
|
}
|
|
|
|
|
2012-04-23 12:58:36 +07:00
|
|
|
if (!error) {
|
|
|
|
error = xfs_bwrite(bp);
|
|
|
|
xfs_buf_relse(bp);
|
|
|
|
}
|
|
|
|
|
2010-02-06 08:37:26 +07:00
|
|
|
reclaim:
|
2016-11-10 04:23:22 +07:00
|
|
|
ASSERT(!xfs_isiflocked(ip));
|
|
|
|
|
2016-05-18 11:09:12 +07: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 04:23:22 +07:00
|
|
|
* We do this as early as possible under the ILOCK so that
|
2017-08-26 00:05:26 +07: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 11:09:12 +07: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 06:51:45 +07:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2010-07-20 14:53:25 +07:00
|
|
|
|
2015-10-12 14:21:22 +07:00
|
|
|
XFS_STATS_INC(ip->i_mount, xs_ig_reclaims);
|
2010-07-20 14:53:25 +07: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 13:08:41 +07:00
|
|
|
spin_lock(&pag->pag_ici_lock);
|
2010-07-20 14:53:25 +07:00
|
|
|
if (!radix_tree_delete(&pag->pag_ici_root,
|
2016-05-18 11:09:12 +07:00
|
|
|
XFS_INO_TO_AGINO(ip->i_mount, ino)))
|
2010-07-20 14:53:25 +07:00
|
|
|
ASSERT(0);
|
2016-05-18 11:11:41 +07:00
|
|
|
xfs_perag_clear_reclaim_tag(pag);
|
2010-12-16 13:08:41 +07:00
|
|
|
spin_unlock(&pag->pag_ici_lock);
|
2010-07-20 14:53:25 +07: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 05:01:00 +07:00
|
|
|
* unlocked after the lookup before we go ahead and free it.
|
2010-07-20 14:53:25 +07:00
|
|
|
*/
|
2012-02-17 05:01:00 +07:00
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
2010-07-20 14:53:25 +07:00
|
|
|
xfs_qm_dqdetach(ip);
|
2012-02-17 05:01:00 +07:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2010-07-20 14:53:25 +07:00
|
|
|
|
2016-05-18 11:09:12 +07:00
|
|
|
__xfs_inode_free(ip);
|
2012-02-17 05:01:00 +07:00
|
|
|
return error;
|
2012-04-23 12:58:35 +07:00
|
|
|
|
|
|
|
out_ifunlock:
|
|
|
|
xfs_ifunlock(ip);
|
|
|
|
out:
|
|
|
|
xfs_iflags_clear(ip, XFS_IRECLAIM);
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
/*
|
2014-06-25 11:58:08 +07:00
|
|
|
* We could return -EAGAIN here to make reclaim rescan the inode tree in
|
2012-04-23 12:58:35 +07:00
|
|
|
* a short while. However, this just burns CPU time scanning the tree
|
2012-10-08 17:56:05 +07:00
|
|
|
* waiting for IO to complete and the reclaim work never goes back to
|
|
|
|
* the idle state. Instead, return 0 to let the next scheduled
|
|
|
|
* background reclaim attempt to reclaim the inode again.
|
2012-04-23 12:58:35 +07:00
|
|
|
*/
|
|
|
|
return 0;
|
2008-10-30 13:37:37 +07:00
|
|
|
}
|
|
|
|
|
2010-09-24 15:40:15 +07: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.
|
|
|
|
*/
|
2012-10-08 17:56:11 +07:00
|
|
|
STATIC int
|
2010-09-24 15:40:15 +07:00
|
|
|
xfs_reclaim_inodes_ag(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
int flags,
|
|
|
|
int *nr_to_scan)
|
|
|
|
{
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
int error = 0;
|
|
|
|
int last_error = 0;
|
|
|
|
xfs_agnumber_t ag;
|
2010-09-27 08:09:51 +07:00
|
|
|
int trylock = flags & SYNC_TRYLOCK;
|
|
|
|
int skipped;
|
2010-09-24 15:40:15 +07:00
|
|
|
|
2010-09-27 08:09:51 +07:00
|
|
|
restart:
|
2010-09-24 15:40:15 +07:00
|
|
|
ag = 0;
|
2010-09-27 08:09:51 +07:00
|
|
|
skipped = 0;
|
2010-09-24 15:40:15 +07:00
|
|
|
while ((pag = xfs_perag_get_tag(mp, ag, XFS_ICI_RECLAIM_TAG))) {
|
|
|
|
unsigned long first_index = 0;
|
|
|
|
int done = 0;
|
2010-09-24 16:51:50 +07:00
|
|
|
int nr_found = 0;
|
2010-09-24 15:40:15 +07:00
|
|
|
|
|
|
|
ag = pag->pag_agno + 1;
|
|
|
|
|
2010-09-27 08:09:51 +07:00
|
|
|
if (trylock) {
|
|
|
|
if (!mutex_trylock(&pag->pag_ici_reclaim_lock)) {
|
|
|
|
skipped++;
|
2010-11-08 15:55:04 +07:00
|
|
|
xfs_perag_put(pag);
|
2010-09-27 08:09:51 +07:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
first_index = pag->pag_ici_reclaim_cursor;
|
|
|
|
} else
|
|
|
|
mutex_lock(&pag->pag_ici_reclaim_lock);
|
|
|
|
|
2010-09-24 15:40:15 +07:00
|
|
|
do {
|
2010-09-24 16:51:50 +07:00
|
|
|
struct xfs_inode *batch[XFS_LOOKUP_BATCH];
|
|
|
|
int i;
|
2010-09-24 15:40:15 +07:00
|
|
|
|
2010-12-17 13:29:43 +07:00
|
|
|
rcu_read_lock();
|
2010-09-24 16:51:50 +07:00
|
|
|
nr_found = radix_tree_gang_lookup_tag(
|
|
|
|
&pag->pag_ici_root,
|
|
|
|
(void **)batch, first_index,
|
|
|
|
XFS_LOOKUP_BATCH,
|
2010-09-24 15:40:15 +07:00
|
|
|
XFS_ICI_RECLAIM_TAG);
|
|
|
|
if (!nr_found) {
|
2011-05-06 09:54:04 +07:00
|
|
|
done = 1;
|
2010-12-17 13:29:43 +07:00
|
|
|
rcu_read_unlock();
|
2010-09-24 15:40:15 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-09-24 16:51:50 +07:00
|
|
|
* Grab the inodes before we drop the lock. if we found
|
|
|
|
* nothing, nr == 0 and the loop will be skipped.
|
2010-09-24 15:40:15 +07:00
|
|
|
*/
|
2010-09-24 16:51:50 +07:00
|
|
|
for (i = 0; i < nr_found; i++) {
|
|
|
|
struct xfs_inode *ip = batch[i];
|
|
|
|
|
|
|
|
if (done || xfs_reclaim_inode_grab(ip, flags))
|
|
|
|
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 13:29:43 +07: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 16:51:50 +07:00
|
|
|
*/
|
2010-12-17 13:29:43 +07:00
|
|
|
if (XFS_INO_TO_AGNO(mp, ip->i_ino) !=
|
|
|
|
pag->pag_agno)
|
|
|
|
continue;
|
2010-09-24 16:51:50 +07: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 15:40:15 +07:00
|
|
|
|
2010-09-24 16:51:50 +07:00
|
|
|
/* unlock now we've grabbed the inodes. */
|
2010-12-17 13:29:43 +07:00
|
|
|
rcu_read_unlock();
|
2010-09-24 16:51:50 +07:00
|
|
|
|
|
|
|
for (i = 0; i < nr_found; i++) {
|
|
|
|
if (!batch[i])
|
|
|
|
continue;
|
|
|
|
error = xfs_reclaim_inode(batch[i], pag, flags);
|
2014-06-25 11:58:08 +07:00
|
|
|
if (error && last_error != -EFSCORRUPTED)
|
2010-09-24 16:51:50 +07:00
|
|
|
last_error = error;
|
|
|
|
}
|
|
|
|
|
|
|
|
*nr_to_scan -= XFS_LOOKUP_BATCH;
|
2010-09-24 15:40:15 +07:00
|
|
|
|
2011-07-08 11:14:46 +07:00
|
|
|
cond_resched();
|
|
|
|
|
2010-09-24 16:51:50 +07:00
|
|
|
} while (nr_found && !done && *nr_to_scan > 0);
|
2010-09-24 15:40:15 +07:00
|
|
|
|
2010-09-27 08:09:51 +07:00
|
|
|
if (trylock && !done)
|
|
|
|
pag->pag_ici_reclaim_cursor = first_index;
|
|
|
|
else
|
|
|
|
pag->pag_ici_reclaim_cursor = 0;
|
|
|
|
mutex_unlock(&pag->pag_ici_reclaim_lock);
|
2010-09-24 15:40:15 +07:00
|
|
|
xfs_perag_put(pag);
|
|
|
|
}
|
2010-09-27 08:09:51 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* if we skipped any AG, and we still have scan count remaining, do
|
|
|
|
* another pass this time using blocking reclaim semantics (i.e
|
|
|
|
* waiting on the reclaim locks and ignoring the reclaim cursors). This
|
|
|
|
* ensure that when we get more reclaimers than AGs we block rather
|
|
|
|
* than spin trying to execute reclaim.
|
|
|
|
*/
|
2011-07-08 11:14:46 +07:00
|
|
|
if (skipped && (flags & SYNC_WAIT) && *nr_to_scan > 0) {
|
2010-09-27 08:09:51 +07:00
|
|
|
trylock = 0;
|
|
|
|
goto restart;
|
|
|
|
}
|
2014-06-22 12:04:54 +07:00
|
|
|
return last_error;
|
2010-09-24 15:40:15 +07:00
|
|
|
}
|
|
|
|
|
2008-10-30 13:37:37 +07:00
|
|
|
int
|
|
|
|
xfs_reclaim_inodes(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
int mode)
|
|
|
|
{
|
2010-09-24 15:40:15 +07:00
|
|
|
int nr_to_scan = INT_MAX;
|
|
|
|
|
|
|
|
return xfs_reclaim_inodes_ag(mp, mode, &nr_to_scan);
|
2010-04-29 06:55:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-07-08 11:14:46 +07:00
|
|
|
* Scan a certain number of inodes for reclaim.
|
2011-04-08 09:45:07 +07:00
|
|
|
*
|
|
|
|
* When called we make sure that there is a background (fast) inode reclaim in
|
2011-07-08 11:14:46 +07:00
|
|
|
* progress, while we will throttle the speed of reclaim via doing synchronous
|
2011-04-08 09:45:07 +07:00
|
|
|
* reclaim of inodes. That means if we come across dirty inodes, we wait for
|
|
|
|
* them to be cleaned, which we hope will not be very long due to the
|
|
|
|
* background walker having already kicked the IO off on those dirty inodes.
|
2010-04-29 06:55:50 +07:00
|
|
|
*/
|
2013-08-28 07:17:57 +07:00
|
|
|
long
|
2011-07-08 11:14:46 +07:00
|
|
|
xfs_reclaim_inodes_nr(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
int nr_to_scan)
|
2010-04-29 06:55:50 +07:00
|
|
|
{
|
2011-07-08 11:14:46 +07:00
|
|
|
/* kick background reclaimer and push the AIL */
|
2012-10-08 17:56:05 +07:00
|
|
|
xfs_reclaim_work_queue(mp);
|
2011-07-08 11:14:46 +07:00
|
|
|
xfs_ail_push_all(mp->m_ail);
|
2011-04-08 09:45:07 +07:00
|
|
|
|
2013-08-28 07:17:57 +07:00
|
|
|
return xfs_reclaim_inodes_ag(mp, SYNC_TRYLOCK | SYNC_WAIT, &nr_to_scan);
|
2011-07-08 11:14:46 +07:00
|
|
|
}
|
2010-04-29 06:55:50 +07:00
|
|
|
|
2011-07-08 11:14:46 +07: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 06:55:50 +07:00
|
|
|
|
2010-09-24 15:40:15 +07:00
|
|
|
while ((pag = xfs_perag_get_tag(mp, ag, XFS_ICI_RECLAIM_TAG))) {
|
|
|
|
ag = pag->pag_agno + 1;
|
2010-07-20 05:07:02 +07:00
|
|
|
reclaimable += pag->pag_ici_reclaimable;
|
|
|
|
xfs_perag_put(pag);
|
2010-04-29 06:55:50 +07:00
|
|
|
}
|
|
|
|
return reclaimable;
|
|
|
|
}
|
|
|
|
|
2012-11-08 00:21:13 +07:00
|
|
|
STATIC int
|
|
|
|
xfs_inode_match_id(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_eofblocks *eofb)
|
|
|
|
{
|
2013-08-16 01:08:02 +07:00
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&
|
|
|
|
!uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))
|
2012-11-06 21:50:45 +07:00
|
|
|
return 0;
|
2012-11-08 00:21:13 +07:00
|
|
|
|
2013-08-16 01:08:02 +07:00
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&
|
|
|
|
!gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))
|
2012-11-06 21:50:45 +07:00
|
|
|
return 0;
|
|
|
|
|
2013-08-16 01:08:02 +07:00
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&
|
2012-11-06 21:50:45 +07:00
|
|
|
xfs_get_projid(ip) != eofb->eof_prid)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
2012-11-08 00:21:13 +07:00
|
|
|
}
|
|
|
|
|
2014-07-24 16:44:28 +07:00
|
|
|
/*
|
|
|
|
* A union-based inode filtering algorithm. Process the inode if any of the
|
|
|
|
* criteria match. This is for global/internal scans only.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
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))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&
|
|
|
|
gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&
|
|
|
|
xfs_get_projid(ip) == eofb->eof_prid)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-06 21:50:42 +07:00
|
|
|
STATIC int
|
|
|
|
xfs_inode_free_eofblocks(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
int flags,
|
|
|
|
void *args)
|
|
|
|
{
|
2017-01-28 14:22:55 +07:00
|
|
|
int ret = 0;
|
2012-11-08 00:21:13 +07:00
|
|
|
struct xfs_eofblocks *eofb = args;
|
2014-07-24 16:44:28 +07:00
|
|
|
int match;
|
2014-07-24 16:40:22 +07:00
|
|
|
|
2012-11-06 21:50:42 +07: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.
|
|
|
|
*/
|
|
|
|
if (!(flags & SYNC_WAIT) &&
|
|
|
|
mapping_tagged(VFS_I(ip)->i_mapping, PAGECACHE_TAG_DIRTY))
|
|
|
|
return 0;
|
|
|
|
|
2012-11-08 00:21:14 +07:00
|
|
|
if (eofb) {
|
2014-07-24 16:44:28 +07:00
|
|
|
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)
|
2012-11-08 00:21:14 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* 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 0;
|
|
|
|
}
|
2012-11-08 00:21:13 +07:00
|
|
|
|
2017-01-28 14:22:55 +07: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 14:22:56 +07:00
|
|
|
if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
|
2017-01-28 14:22:55 +07:00
|
|
|
if (flags & SYNC_WAIT)
|
|
|
|
ret = -EAGAIN;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
ret = xfs_free_eofblocks(ip);
|
2017-01-28 14:22:56 +07:00
|
|
|
xfs_iunlock(ip, XFS_IOLOCK_EXCL);
|
2012-11-06 21:50:42 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-10-03 23:11:46 +07:00
|
|
|
static int
|
|
|
|
__xfs_icache_free_eofblocks(
|
2012-11-06 21:50:42 +07:00
|
|
|
struct xfs_mount *mp,
|
2016-10-03 23:11:46 +07:00
|
|
|
struct xfs_eofblocks *eofb,
|
|
|
|
int (*execute)(struct xfs_inode *ip, int flags,
|
|
|
|
void *args),
|
|
|
|
int tag)
|
2012-11-06 21:50:42 +07:00
|
|
|
{
|
2012-11-08 00:21:12 +07:00
|
|
|
int flags = SYNC_TRYLOCK;
|
|
|
|
|
|
|
|
if (eofb && (eofb->eof_flags & XFS_EOF_FLAGS_SYNC))
|
|
|
|
flags = SYNC_WAIT;
|
|
|
|
|
2016-10-03 23:11:46 +07:00
|
|
|
return xfs_inode_ag_iterator_tag(mp, execute, flags,
|
|
|
|
eofb, tag);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
xfs_icache_free_eofblocks(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_eofblocks *eofb)
|
|
|
|
{
|
|
|
|
return __xfs_icache_free_eofblocks(mp, eofb, xfs_inode_free_eofblocks,
|
|
|
|
XFS_ICI_EOFBLOCKS_TAG);
|
2012-11-06 21:50:42 +07:00
|
|
|
}
|
|
|
|
|
2014-07-24 16:49:28 +07:00
|
|
|
/*
|
|
|
|
* Run eofblocks scans on the quotas applicable to the inode. For inodes with
|
|
|
|
* multiple quotas, we don't know exactly which quota caused an allocation
|
|
|
|
* failure. We make a best effort by including each quota under low free space
|
|
|
|
* conditions (less than 1% free space) in the scan.
|
|
|
|
*/
|
2016-10-03 23:11:46 +07:00
|
|
|
static int
|
|
|
|
__xfs_inode_free_quota_eofblocks(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
int (*execute)(struct xfs_mount *mp,
|
|
|
|
struct xfs_eofblocks *eofb))
|
2014-07-24 16:49:28 +07:00
|
|
|
{
|
|
|
|
int scan = 0;
|
|
|
|
struct xfs_eofblocks eofb = {0};
|
|
|
|
struct xfs_dquot *dq;
|
|
|
|
|
|
|
|
/*
|
2017-01-28 14:22:56 +07:00
|
|
|
* Run a sync scan to increase effectiveness and use the union filter to
|
2014-07-24 16:49:28 +07:00
|
|
|
* cover all applicable quotas in a single scan.
|
|
|
|
*/
|
|
|
|
eofb.eof_flags = XFS_EOF_FLAGS_UNION|XFS_EOF_FLAGS_SYNC;
|
|
|
|
|
|
|
|
if (XFS_IS_UQUOTA_ENFORCED(ip->i_mount)) {
|
|
|
|
dq = xfs_inode_dquot(ip, XFS_DQ_USER);
|
|
|
|
if (dq && xfs_dquot_lowsp(dq)) {
|
|
|
|
eofb.eof_uid = VFS_I(ip)->i_uid;
|
|
|
|
eofb.eof_flags |= XFS_EOF_FLAGS_UID;
|
|
|
|
scan = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (XFS_IS_GQUOTA_ENFORCED(ip->i_mount)) {
|
|
|
|
dq = xfs_inode_dquot(ip, XFS_DQ_GROUP);
|
|
|
|
if (dq && xfs_dquot_lowsp(dq)) {
|
|
|
|
eofb.eof_gid = VFS_I(ip)->i_gid;
|
|
|
|
eofb.eof_flags |= XFS_EOF_FLAGS_GID;
|
|
|
|
scan = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (scan)
|
2016-10-03 23:11:46 +07:00
|
|
|
execute(ip->i_mount, &eofb);
|
2014-07-24 16:49:28 +07:00
|
|
|
|
|
|
|
return scan;
|
|
|
|
}
|
|
|
|
|
2016-10-03 23:11:46 +07:00
|
|
|
int
|
|
|
|
xfs_inode_free_quota_eofblocks(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
return __xfs_inode_free_quota_eofblocks(ip, xfs_icache_free_eofblocks);
|
|
|
|
}
|
|
|
|
|
2017-12-15 06:42:22 +07: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 23:11:46 +07:00
|
|
|
static void
|
2017-12-15 06:42:22 +07:00
|
|
|
__xfs_inode_set_blocks_tag(
|
2016-10-03 23:11:46 +07: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 21:50:38 +07:00
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
int tagged;
|
|
|
|
|
2016-09-19 08:09:48 +07: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 06:42:22 +07:00
|
|
|
if (ip->i_flags & xfs_iflag_for_tag(tag))
|
2016-09-19 08:09:48 +07:00
|
|
|
return;
|
|
|
|
spin_lock(&ip->i_flags_lock);
|
2017-12-15 06:42:22 +07:00
|
|
|
ip->i_flags |= xfs_iflag_for_tag(tag);
|
2016-09-19 08:09:48 +07:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
|
2012-11-06 21:50:38 +07:00
|
|
|
pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
|
|
|
|
spin_lock(&pag->pag_ici_lock);
|
|
|
|
|
2016-10-03 23:11:46 +07:00
|
|
|
tagged = radix_tree_tagged(&pag->pag_ici_root, tag);
|
2012-11-06 21:50:38 +07:00
|
|
|
radix_tree_tag_set(&pag->pag_ici_root,
|
2016-10-03 23:11:46 +07:00
|
|
|
XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino), tag);
|
2012-11-06 21:50:38 +07: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 23:11:46 +07:00
|
|
|
tag);
|
2012-11-06 21:50:38 +07:00
|
|
|
spin_unlock(&ip->i_mount->m_perag_lock);
|
2012-11-06 21:50:47 +07:00
|
|
|
|
|
|
|
/* kick off background trimming */
|
2016-10-03 23:11:46 +07:00
|
|
|
execute(ip->i_mount);
|
2012-11-06 21:50:38 +07:00
|
|
|
|
2016-10-03 23:11:46 +07:00
|
|
|
set_tp(ip->i_mount, pag->pag_agno, -1, _RET_IP_);
|
2012-11-06 21:50:38 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&pag->pag_ici_lock);
|
|
|
|
xfs_perag_put(pag);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2016-10-03 23:11:46 +07:00
|
|
|
xfs_inode_set_eofblocks_tag(
|
2012-11-06 21:50:38 +07:00
|
|
|
xfs_inode_t *ip)
|
2016-10-03 23:11:46 +07:00
|
|
|
{
|
|
|
|
trace_xfs_inode_set_eofblocks_tag(ip);
|
2017-12-15 06:42:22 +07:00
|
|
|
return __xfs_inode_set_blocks_tag(ip, xfs_queue_eofblocks,
|
2016-10-03 23:11:46 +07:00
|
|
|
trace_xfs_perag_set_eofblocks,
|
|
|
|
XFS_ICI_EOFBLOCKS_TAG);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2017-12-15 06:42:22 +07:00
|
|
|
__xfs_inode_clear_blocks_tag(
|
2016-10-03 23:11:46 +07: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 21:50:38 +07:00
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_perag *pag;
|
|
|
|
|
2016-09-19 08:09:48 +07:00
|
|
|
spin_lock(&ip->i_flags_lock);
|
2017-12-15 06:42:22 +07:00
|
|
|
ip->i_flags &= ~xfs_iflag_for_tag(tag);
|
2016-09-19 08:09:48 +07:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
|
2012-11-06 21:50:38 +07: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 23:11:46 +07:00
|
|
|
XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino), tag);
|
|
|
|
if (!radix_tree_tagged(&pag->pag_ici_root, tag)) {
|
2012-11-06 21:50:38 +07: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 23:11:46 +07:00
|
|
|
tag);
|
2012-11-06 21:50:38 +07:00
|
|
|
spin_unlock(&ip->i_mount->m_perag_lock);
|
2016-10-03 23:11:46 +07:00
|
|
|
clear_tp(ip->i_mount, pag->pag_agno, -1, _RET_IP_);
|
2012-11-06 21:50:38 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&pag->pag_ici_lock);
|
|
|
|
xfs_perag_put(pag);
|
|
|
|
}
|
|
|
|
|
2016-10-03 23:11:46 +07:00
|
|
|
void
|
|
|
|
xfs_inode_clear_eofblocks_tag(
|
|
|
|
xfs_inode_t *ip)
|
|
|
|
{
|
|
|
|
trace_xfs_inode_clear_eofblocks_tag(ip);
|
2017-12-15 06:42:22 +07:00
|
|
|
return __xfs_inode_clear_blocks_tag(ip,
|
2016-10-03 23:11:46 +07:00
|
|
|
trace_xfs_perag_clear_eofblocks, XFS_ICI_EOFBLOCKS_TAG);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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,
|
|
|
|
int flags,
|
|
|
|
void *args)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct xfs_eofblocks *eofb = args;
|
|
|
|
int match;
|
2016-11-08 08:53:33 +07:00
|
|
|
struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
|
2016-10-03 23:11:46 +07:00
|
|
|
|
2016-11-08 08:53:33 +07: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.
|
|
|
|
*/
|
|
|
|
if (!xfs_is_reflink_inode(ip) || !ifp->if_bytes) {
|
2016-10-03 23:11:46 +07:00
|
|
|
trace_xfs_inode_free_cowblocks_invalid(ip);
|
|
|
|
xfs_inode_clear_cowblocks_tag(ip);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 09:39:33 +07:00
|
|
|
if ((VFS_I(ip)->i_state & I_DIRTY_PAGES) ||
|
|
|
|
mapping_tagged(VFS_I(ip)->i_mapping, PAGECACHE_TAG_DIRTY) ||
|
2016-10-03 23:11:46 +07:00
|
|
|
mapping_tagged(VFS_I(ip)->i_mapping, PAGECACHE_TAG_WRITEBACK) ||
|
|
|
|
atomic_read(&VFS_I(ip)->i_dio_count))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (eofb) {
|
|
|
|
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 0;
|
|
|
|
|
|
|
|
/* 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 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free the CoW blocks */
|
2017-01-28 14:22:56 +07:00
|
|
|
xfs_ilock(ip, XFS_IOLOCK_EXCL);
|
|
|
|
xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
|
2016-10-03 23:11:46 +07:00
|
|
|
|
2017-03-08 07:45:58 +07:00
|
|
|
ret = xfs_reflink_cancel_cow_range(ip, 0, NULLFILEOFF, false);
|
2016-10-03 23:11:46 +07:00
|
|
|
|
2017-01-28 14:22:56 +07:00
|
|
|
xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
|
|
|
|
xfs_iunlock(ip, XFS_IOLOCK_EXCL);
|
2016-10-03 23:11:46 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
xfs_icache_free_cowblocks(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_eofblocks *eofb)
|
|
|
|
{
|
|
|
|
return __xfs_icache_free_eofblocks(mp, eofb, xfs_inode_free_cowblocks,
|
|
|
|
XFS_ICI_COWBLOCKS_TAG);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
xfs_inode_free_quota_cowblocks(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
return __xfs_inode_free_quota_eofblocks(ip, xfs_icache_free_cowblocks);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_inode_set_cowblocks_tag(
|
|
|
|
xfs_inode_t *ip)
|
|
|
|
{
|
2016-10-24 10:21:00 +07:00
|
|
|
trace_xfs_inode_set_cowblocks_tag(ip);
|
2017-12-15 06:42:22 +07:00
|
|
|
return __xfs_inode_set_blocks_tag(ip, xfs_queue_cowblocks,
|
2016-10-24 10:21:00 +07:00
|
|
|
trace_xfs_perag_set_cowblocks,
|
2016-10-03 23:11:46 +07:00
|
|
|
XFS_ICI_COWBLOCKS_TAG);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_inode_clear_cowblocks_tag(
|
|
|
|
xfs_inode_t *ip)
|
|
|
|
{
|
2016-10-24 10:21:00 +07:00
|
|
|
trace_xfs_inode_clear_cowblocks_tag(ip);
|
2017-12-15 06:42:22 +07:00
|
|
|
return __xfs_inode_clear_blocks_tag(ip,
|
2016-10-24 10:21:00 +07:00
|
|
|
trace_xfs_perag_clear_cowblocks, XFS_ICI_COWBLOCKS_TAG);
|
2016-10-03 23:11:46 +07:00
|
|
|
}
|