2018-06-06 02:42:14 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2006-06-09 04:48:12 +00:00
|
|
|
* Copyright (c) 2000-2006 Silicon Graphics, Inc.
|
2005-11-02 03:58:39 +00:00
|
|
|
* All Rights Reserved.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2017-12-11 11:35:19 +00:00
|
|
|
#include <linux/iversion.h>
|
2007-11-23 05:30:51 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs.h"
|
2005-11-02 03:38:42 +00:00
|
|
|
#include "xfs_fs.h"
|
2013-10-22 23:36:05 +00:00
|
|
|
#include "xfs_shared.h"
|
2013-10-22 23:50:10 +00:00
|
|
|
#include "xfs_format.h"
|
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_mount.h"
|
2016-08-03 01:15:38 +00:00
|
|
|
#include "xfs_defer.h"
|
2013-10-22 23:51:50 +00:00
|
|
|
#include "xfs_inode.h"
|
2013-08-12 10:49:45 +00:00
|
|
|
#include "xfs_dir2.h"
|
|
|
|
#include "xfs_attr.h"
|
2013-10-22 23:50:10 +00:00
|
|
|
#include "xfs_trans_space.h"
|
|
|
|
#include "xfs_trans.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_buf_item.h"
|
2005-11-02 03:38:42 +00:00
|
|
|
#include "xfs_inode_item.h"
|
|
|
|
#include "xfs_ialloc.h"
|
|
|
|
#include "xfs_bmap.h"
|
2013-08-12 10:49:42 +00:00
|
|
|
#include "xfs_bmap_util.h"
|
2017-10-31 19:04:49 +00:00
|
|
|
#include "xfs_errortag.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_error.h"
|
|
|
|
#include "xfs_quota.h"
|
2007-07-11 01:09:12 +00:00
|
|
|
#include "xfs_filestream.h"
|
2009-12-14 23:14:59 +00:00
|
|
|
#include "xfs_trace.h"
|
2012-10-08 10:56:11 +00:00
|
|
|
#include "xfs_icache.h"
|
2013-08-12 10:49:45 +00:00
|
|
|
#include "xfs_symlink.h"
|
2013-10-22 23:50:10 +00:00
|
|
|
#include "xfs_trans_priv.h"
|
|
|
|
#include "xfs_log.h"
|
2013-10-22 23:51:50 +00:00
|
|
|
#include "xfs_bmap_btree.h"
|
2016-10-03 16:11:38 +00:00
|
|
|
#include "xfs_reflink.h"
|
2021-06-02 00:48:24 +00:00
|
|
|
#include "xfs_ag.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
kmem_zone_t *xfs_inode_zone;
|
|
|
|
|
|
|
|
/*
|
2011-07-08 12:34:34 +00:00
|
|
|
* Used in xfs_itruncate_extents(). This is the maximum number of extents
|
2005-04-16 22:20:36 +00:00
|
|
|
* freed from a file in a single transaction.
|
|
|
|
*/
|
|
|
|
#define XFS_ITRUNC_MAX_EXTENTS 2
|
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
STATIC int xfs_iunlink(struct xfs_trans *, struct xfs_inode *);
|
2021-06-02 00:48:51 +00:00
|
|
|
STATIC int xfs_iunlink_remove(struct xfs_trans *tp, struct xfs_perag *pag,
|
|
|
|
struct xfs_inode *);
|
2013-12-18 00:22:41 +00:00
|
|
|
|
2012-04-23 05:59:02 +00:00
|
|
|
/*
|
|
|
|
* helper function to extract extent size hint from inode
|
|
|
|
*/
|
|
|
|
xfs_extlen_t
|
|
|
|
xfs_get_extsz_hint(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
2019-10-14 17:07:21 +00:00
|
|
|
/*
|
|
|
|
* No point in aligning allocations if we need to COW to actually
|
|
|
|
* write to them.
|
|
|
|
*/
|
|
|
|
if (xfs_is_always_cow_inode(ip))
|
|
|
|
return 0;
|
2021-03-29 18:11:44 +00:00
|
|
|
if ((ip->i_diflags & XFS_DIFLAG_EXTSIZE) && ip->i_extsize)
|
2021-03-29 18:11:41 +00:00
|
|
|
return ip->i_extsize;
|
2012-04-23 05:59:02 +00:00
|
|
|
if (XFS_IS_REALTIME_INODE(ip))
|
|
|
|
return ip->i_mount->m_sb.sb_rextsize;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-10-03 16:11:43 +00:00
|
|
|
/*
|
|
|
|
* Helper function to extract CoW extent size hint from inode.
|
|
|
|
* Between the extent size hint and the CoW extent size hint, we
|
2016-10-03 16:11:49 +00:00
|
|
|
* return the greater of the two. If the value is zero (automatic),
|
|
|
|
* use the default size.
|
2016-10-03 16:11:43 +00:00
|
|
|
*/
|
|
|
|
xfs_extlen_t
|
|
|
|
xfs_get_cowextsz_hint(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
xfs_extlen_t a, b;
|
|
|
|
|
|
|
|
a = 0;
|
2021-03-29 18:11:45 +00:00
|
|
|
if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
|
2021-03-29 18:11:42 +00:00
|
|
|
a = ip->i_cowextsize;
|
2016-10-03 16:11:43 +00:00
|
|
|
b = xfs_get_extsz_hint(ip);
|
|
|
|
|
2016-10-03 16:11:49 +00:00
|
|
|
a = max(a, b);
|
|
|
|
if (a == 0)
|
|
|
|
return XFS_DEFAULT_COWEXTSZ_HINT;
|
|
|
|
return a;
|
2016-10-03 16:11:43 +00:00
|
|
|
}
|
|
|
|
|
2012-10-08 10:56:10 +00:00
|
|
|
/*
|
2013-12-18 10:14:39 +00:00
|
|
|
* These two are wrapper routines around the xfs_ilock() routine used to
|
|
|
|
* centralize some grungy code. They are used in places that wish to lock the
|
|
|
|
* inode solely for reading the extents. The reason these places can't just
|
|
|
|
* call xfs_ilock(ip, XFS_ILOCK_SHARED) is that the inode lock also guards to
|
|
|
|
* bringing in of the extents from disk for a file in b-tree format. If the
|
|
|
|
* inode is in b-tree format, then we need to lock the inode exclusively until
|
|
|
|
* the extents are read in. Locking it exclusively all the time would limit
|
|
|
|
* our parallelism unnecessarily, though. What we do instead is check to see
|
|
|
|
* if the extents have been read in yet, and only lock the inode exclusively
|
|
|
|
* if they have not.
|
2012-10-08 10:56:10 +00:00
|
|
|
*
|
2013-12-18 10:14:39 +00:00
|
|
|
* The functions return a value which should be given to the corresponding
|
2013-12-06 20:30:08 +00:00
|
|
|
* xfs_iunlock() call.
|
2012-10-08 10:56:10 +00:00
|
|
|
*/
|
|
|
|
uint
|
2013-12-06 20:30:09 +00:00
|
|
|
xfs_ilock_data_map_shared(
|
|
|
|
struct xfs_inode *ip)
|
2012-10-08 10:56:10 +00:00
|
|
|
{
|
2013-12-06 20:30:09 +00:00
|
|
|
uint lock_mode = XFS_ILOCK_SHARED;
|
2012-10-08 10:56:10 +00:00
|
|
|
|
2021-04-13 18:15:12 +00:00
|
|
|
if (xfs_need_iread_extents(&ip->i_df))
|
2012-10-08 10:56:10 +00:00
|
|
|
lock_mode = XFS_ILOCK_EXCL;
|
|
|
|
xfs_ilock(ip, lock_mode);
|
|
|
|
return lock_mode;
|
|
|
|
}
|
|
|
|
|
2013-12-18 10:14:39 +00:00
|
|
|
uint
|
|
|
|
xfs_ilock_attr_map_shared(
|
|
|
|
struct xfs_inode *ip)
|
2012-10-08 10:56:10 +00:00
|
|
|
{
|
2013-12-18 10:14:39 +00:00
|
|
|
uint lock_mode = XFS_ILOCK_SHARED;
|
|
|
|
|
2021-04-13 18:15:12 +00:00
|
|
|
if (ip->i_afp && xfs_need_iread_extents(ip->i_afp))
|
2013-12-18 10:14:39 +00:00
|
|
|
lock_mode = XFS_ILOCK_EXCL;
|
|
|
|
xfs_ilock(ip, lock_mode);
|
|
|
|
return lock_mode;
|
2012-10-08 10:56:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-11-30 03:33:25 +00:00
|
|
|
* In addition to i_rwsem in the VFS inode, the xfs inode contains 2
|
|
|
|
* multi-reader locks: i_mmap_lock and the i_lock. This routine allows
|
|
|
|
* various combinations of the locks to be obtained.
|
2012-10-08 10:56:10 +00:00
|
|
|
*
|
2015-02-23 10:43:37 +00:00
|
|
|
* The 3 locks should always be ordered so that the IO lock is obtained first,
|
|
|
|
* the mmap lock second and the ilock last in order to prevent deadlock.
|
2012-10-08 10:56:10 +00:00
|
|
|
*
|
2015-02-23 10:43:37 +00:00
|
|
|
* Basic locking order:
|
|
|
|
*
|
2016-11-30 03:33:25 +00:00
|
|
|
* i_rwsem -> i_mmap_lock -> page_lock -> i_ilock
|
2015-02-23 10:43:37 +00:00
|
|
|
*
|
2020-06-09 04:33:54 +00:00
|
|
|
* mmap_lock locking order:
|
2015-02-23 10:43:37 +00:00
|
|
|
*
|
2020-06-09 04:33:54 +00:00
|
|
|
* i_rwsem -> page lock -> mmap_lock
|
|
|
|
* mmap_lock -> i_mmap_lock -> page_lock
|
2015-02-23 10:43:37 +00:00
|
|
|
*
|
2020-06-09 04:33:54 +00:00
|
|
|
* The difference in mmap_lock locking order mean that we cannot hold the
|
2015-02-23 10:43:37 +00:00
|
|
|
* i_mmap_lock over syscall based read(2)/write(2) based IO. These IO paths can
|
2020-06-09 04:33:54 +00:00
|
|
|
* fault in pages during copy in/out (for buffered IO) or require the mmap_lock
|
2015-02-23 10:43:37 +00:00
|
|
|
* in get_user_pages() to map the user pages into the kernel address space for
|
2016-11-30 03:33:25 +00:00
|
|
|
* direct IO. Similarly the i_rwsem cannot be taken inside a page fault because
|
2020-06-09 04:33:54 +00:00
|
|
|
* page faults already hold the mmap_lock.
|
2015-02-23 10:43:37 +00:00
|
|
|
*
|
|
|
|
* Hence to serialise fully against both syscall and mmap based IO, we need to
|
2016-11-30 03:33:25 +00:00
|
|
|
* take both the i_rwsem and the i_mmap_lock. These locks should *only* be both
|
2015-02-23 10:43:37 +00:00
|
|
|
* taken in places where we need to invalidate the page cache in a race
|
|
|
|
* free manner (e.g. truncate, hole punch and other extent manipulation
|
|
|
|
* functions).
|
2012-10-08 10:56:10 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_ilock(
|
|
|
|
xfs_inode_t *ip,
|
|
|
|
uint lock_flags)
|
|
|
|
{
|
|
|
|
trace_xfs_ilock(ip, lock_flags, _RET_IP_);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* You can't set both SHARED and EXCL for the same lock,
|
|
|
|
* and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
|
|
|
|
* and XFS_ILOCK_EXCL are valid values to set in lock_flags.
|
|
|
|
*/
|
|
|
|
ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
|
|
|
|
(XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
|
2015-02-23 10:43:37 +00:00
|
|
|
ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
|
|
|
|
(XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
|
2012-10-08 10:56:10 +00:00
|
|
|
ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
|
|
|
|
(XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
|
2012-10-08 10:56:10 +00:00
|
|
|
|
2016-11-30 03:33:25 +00:00
|
|
|
if (lock_flags & XFS_IOLOCK_EXCL) {
|
|
|
|
down_write_nested(&VFS_I(ip)->i_rwsem,
|
|
|
|
XFS_IOLOCK_DEP(lock_flags));
|
|
|
|
} else if (lock_flags & XFS_IOLOCK_SHARED) {
|
|
|
|
down_read_nested(&VFS_I(ip)->i_rwsem,
|
|
|
|
XFS_IOLOCK_DEP(lock_flags));
|
|
|
|
}
|
2012-10-08 10:56:10 +00:00
|
|
|
|
2015-02-23 10:43:37 +00:00
|
|
|
if (lock_flags & XFS_MMAPLOCK_EXCL)
|
|
|
|
mrupdate_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));
|
|
|
|
else if (lock_flags & XFS_MMAPLOCK_SHARED)
|
|
|
|
mraccess_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));
|
|
|
|
|
2012-10-08 10:56:10 +00:00
|
|
|
if (lock_flags & XFS_ILOCK_EXCL)
|
|
|
|
mrupdate_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
|
|
|
|
else if (lock_flags & XFS_ILOCK_SHARED)
|
|
|
|
mraccess_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is just like xfs_ilock(), except that the caller
|
|
|
|
* is guaranteed not to sleep. It returns 1 if it gets
|
|
|
|
* the requested locks and 0 otherwise. If the IO lock is
|
|
|
|
* obtained but the inode lock cannot be, then the IO lock
|
|
|
|
* is dropped before returning.
|
|
|
|
*
|
|
|
|
* ip -- the inode being locked
|
|
|
|
* lock_flags -- this parameter indicates the inode's locks to be
|
|
|
|
* to be locked. See the comment for xfs_ilock() for a list
|
|
|
|
* of valid values.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_ilock_nowait(
|
|
|
|
xfs_inode_t *ip,
|
|
|
|
uint lock_flags)
|
|
|
|
{
|
|
|
|
trace_xfs_ilock_nowait(ip, lock_flags, _RET_IP_);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* You can't set both SHARED and EXCL for the same lock,
|
|
|
|
* and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
|
|
|
|
* and XFS_ILOCK_EXCL are valid values to set in lock_flags.
|
|
|
|
*/
|
|
|
|
ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
|
|
|
|
(XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
|
2015-02-23 10:43:37 +00:00
|
|
|
ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
|
|
|
|
(XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
|
2012-10-08 10:56:10 +00:00
|
|
|
ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
|
|
|
|
(XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
|
2012-10-08 10:56:10 +00:00
|
|
|
|
|
|
|
if (lock_flags & XFS_IOLOCK_EXCL) {
|
2016-11-30 03:33:25 +00:00
|
|
|
if (!down_write_trylock(&VFS_I(ip)->i_rwsem))
|
2012-10-08 10:56:10 +00:00
|
|
|
goto out;
|
|
|
|
} else if (lock_flags & XFS_IOLOCK_SHARED) {
|
2016-11-30 03:33:25 +00:00
|
|
|
if (!down_read_trylock(&VFS_I(ip)->i_rwsem))
|
2012-10-08 10:56:10 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2015-02-23 10:43:37 +00:00
|
|
|
|
|
|
|
if (lock_flags & XFS_MMAPLOCK_EXCL) {
|
|
|
|
if (!mrtryupdate(&ip->i_mmaplock))
|
|
|
|
goto out_undo_iolock;
|
|
|
|
} else if (lock_flags & XFS_MMAPLOCK_SHARED) {
|
|
|
|
if (!mrtryaccess(&ip->i_mmaplock))
|
|
|
|
goto out_undo_iolock;
|
|
|
|
}
|
|
|
|
|
2012-10-08 10:56:10 +00:00
|
|
|
if (lock_flags & XFS_ILOCK_EXCL) {
|
|
|
|
if (!mrtryupdate(&ip->i_lock))
|
2015-02-23 10:43:37 +00:00
|
|
|
goto out_undo_mmaplock;
|
2012-10-08 10:56:10 +00:00
|
|
|
} else if (lock_flags & XFS_ILOCK_SHARED) {
|
|
|
|
if (!mrtryaccess(&ip->i_lock))
|
2015-02-23 10:43:37 +00:00
|
|
|
goto out_undo_mmaplock;
|
2012-10-08 10:56:10 +00:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
|
2015-02-23 10:43:37 +00:00
|
|
|
out_undo_mmaplock:
|
|
|
|
if (lock_flags & XFS_MMAPLOCK_EXCL)
|
|
|
|
mrunlock_excl(&ip->i_mmaplock);
|
|
|
|
else if (lock_flags & XFS_MMAPLOCK_SHARED)
|
|
|
|
mrunlock_shared(&ip->i_mmaplock);
|
|
|
|
out_undo_iolock:
|
2012-10-08 10:56:10 +00:00
|
|
|
if (lock_flags & XFS_IOLOCK_EXCL)
|
2016-11-30 03:33:25 +00:00
|
|
|
up_write(&VFS_I(ip)->i_rwsem);
|
2012-10-08 10:56:10 +00:00
|
|
|
else if (lock_flags & XFS_IOLOCK_SHARED)
|
2016-11-30 03:33:25 +00:00
|
|
|
up_read(&VFS_I(ip)->i_rwsem);
|
2015-02-23 10:43:37 +00:00
|
|
|
out:
|
2012-10-08 10:56:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xfs_iunlock() is used to drop the inode locks acquired with
|
|
|
|
* xfs_ilock() and xfs_ilock_nowait(). The caller must pass
|
|
|
|
* in the flags given to xfs_ilock() or xfs_ilock_nowait() so
|
|
|
|
* that we know which locks to drop.
|
|
|
|
*
|
|
|
|
* ip -- the inode being unlocked
|
|
|
|
* lock_flags -- this parameter indicates the inode's locks to be
|
|
|
|
* to be unlocked. See the comment for xfs_ilock() for a list
|
|
|
|
* of valid values for this parameter.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_iunlock(
|
|
|
|
xfs_inode_t *ip,
|
|
|
|
uint lock_flags)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* You can't set both SHARED and EXCL for the same lock,
|
|
|
|
* and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
|
|
|
|
* and XFS_ILOCK_EXCL are valid values to set in lock_flags.
|
|
|
|
*/
|
|
|
|
ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
|
|
|
|
(XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
|
2015-02-23 10:43:37 +00:00
|
|
|
ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
|
|
|
|
(XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
|
2012-10-08 10:56:10 +00:00
|
|
|
ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
|
|
|
|
(XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
|
2012-10-08 10:56:10 +00:00
|
|
|
ASSERT(lock_flags != 0);
|
|
|
|
|
|
|
|
if (lock_flags & XFS_IOLOCK_EXCL)
|
2016-11-30 03:33:25 +00:00
|
|
|
up_write(&VFS_I(ip)->i_rwsem);
|
2012-10-08 10:56:10 +00:00
|
|
|
else if (lock_flags & XFS_IOLOCK_SHARED)
|
2016-11-30 03:33:25 +00:00
|
|
|
up_read(&VFS_I(ip)->i_rwsem);
|
2012-10-08 10:56:10 +00:00
|
|
|
|
2015-02-23 10:43:37 +00:00
|
|
|
if (lock_flags & XFS_MMAPLOCK_EXCL)
|
|
|
|
mrunlock_excl(&ip->i_mmaplock);
|
|
|
|
else if (lock_flags & XFS_MMAPLOCK_SHARED)
|
|
|
|
mrunlock_shared(&ip->i_mmaplock);
|
|
|
|
|
2012-10-08 10:56:10 +00:00
|
|
|
if (lock_flags & XFS_ILOCK_EXCL)
|
|
|
|
mrunlock_excl(&ip->i_lock);
|
|
|
|
else if (lock_flags & XFS_ILOCK_SHARED)
|
|
|
|
mrunlock_shared(&ip->i_lock);
|
|
|
|
|
|
|
|
trace_xfs_iunlock(ip, lock_flags, _RET_IP_);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* give up write locks. the i/o lock cannot be held nested
|
|
|
|
* if it is being demoted.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_ilock_demote(
|
|
|
|
xfs_inode_t *ip,
|
|
|
|
uint lock_flags)
|
|
|
|
{
|
2015-02-23 10:43:37 +00:00
|
|
|
ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL));
|
|
|
|
ASSERT((lock_flags &
|
|
|
|
~(XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);
|
2012-10-08 10:56:10 +00:00
|
|
|
|
|
|
|
if (lock_flags & XFS_ILOCK_EXCL)
|
|
|
|
mrdemote(&ip->i_lock);
|
2015-02-23 10:43:37 +00:00
|
|
|
if (lock_flags & XFS_MMAPLOCK_EXCL)
|
|
|
|
mrdemote(&ip->i_mmaplock);
|
2012-10-08 10:56:10 +00:00
|
|
|
if (lock_flags & XFS_IOLOCK_EXCL)
|
2016-11-30 03:33:25 +00:00
|
|
|
downgrade_write(&VFS_I(ip)->i_rwsem);
|
2012-10-08 10:56:10 +00:00
|
|
|
|
|
|
|
trace_xfs_ilock_demote(ip, lock_flags, _RET_IP_);
|
|
|
|
}
|
|
|
|
|
2013-04-30 11:39:34 +00:00
|
|
|
#if defined(DEBUG) || defined(XFS_WARN)
|
2012-10-08 10:56:10 +00:00
|
|
|
int
|
|
|
|
xfs_isilocked(
|
|
|
|
xfs_inode_t *ip,
|
|
|
|
uint lock_flags)
|
|
|
|
{
|
|
|
|
if (lock_flags & (XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)) {
|
|
|
|
if (!(lock_flags & XFS_ILOCK_SHARED))
|
|
|
|
return !!ip->i_lock.mr_writer;
|
|
|
|
return rwsem_is_locked(&ip->i_lock.mr_lock);
|
|
|
|
}
|
|
|
|
|
2015-02-23 10:43:37 +00:00
|
|
|
if (lock_flags & (XFS_MMAPLOCK_EXCL|XFS_MMAPLOCK_SHARED)) {
|
|
|
|
if (!(lock_flags & XFS_MMAPLOCK_SHARED))
|
|
|
|
return !!ip->i_mmaplock.mr_writer;
|
|
|
|
return rwsem_is_locked(&ip->i_mmaplock.mr_lock);
|
|
|
|
}
|
|
|
|
|
2012-10-08 10:56:10 +00:00
|
|
|
if (lock_flags & (XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED)) {
|
|
|
|
if (!(lock_flags & XFS_IOLOCK_SHARED))
|
2016-11-30 03:33:25 +00:00
|
|
|
return !debug_locks ||
|
|
|
|
lockdep_is_held_type(&VFS_I(ip)->i_rwsem, 0);
|
|
|
|
return rwsem_is_locked(&VFS_I(ip)->i_rwsem);
|
2012-10-08 10:56:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-08-25 00:05:13 +00:00
|
|
|
/*
|
|
|
|
* xfs_lockdep_subclass_ok() is only used in an ASSERT, so is only called when
|
|
|
|
* DEBUG or XFS_WARN is set. And MAX_LOCKDEP_SUBCLASSES is then only defined
|
|
|
|
* when CONFIG_LOCKDEP is set. Hence the complex define below to avoid build
|
|
|
|
* errors and warnings.
|
|
|
|
*/
|
|
|
|
#if (defined(DEBUG) || defined(XFS_WARN)) && defined(CONFIG_LOCKDEP)
|
2015-08-19 23:27:49 +00:00
|
|
|
static bool
|
|
|
|
xfs_lockdep_subclass_ok(
|
|
|
|
int subclass)
|
|
|
|
{
|
|
|
|
return subclass < MAX_LOCKDEP_SUBCLASSES;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define xfs_lockdep_subclass_ok(subclass) (true)
|
|
|
|
#endif
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
/*
|
2015-02-23 10:43:37 +00:00
|
|
|
* Bump the subclass so xfs_lock_inodes() acquires each lock with a different
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
* value. This can be called for any type of inode lock combination, including
|
|
|
|
* parent locking. Care must be taken to ensure we don't overrun the subclass
|
|
|
|
* storage fields in the class mask we build.
|
2013-08-12 10:49:45 +00:00
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
xfs_lock_inumorder(int lock_mode, int subclass)
|
|
|
|
{
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
int class = 0;
|
|
|
|
|
|
|
|
ASSERT(!(lock_mode & (XFS_ILOCK_PARENT | XFS_ILOCK_RTBITMAP |
|
|
|
|
XFS_ILOCK_RTSUM)));
|
2015-08-19 23:27:49 +00:00
|
|
|
ASSERT(xfs_lockdep_subclass_ok(subclass));
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
|
2015-02-23 10:43:37 +00:00
|
|
|
if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)) {
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
ASSERT(subclass <= XFS_IOLOCK_MAX_SUBCLASS);
|
|
|
|
class += subclass << XFS_IOLOCK_SHIFT;
|
2015-02-23 10:43:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (lock_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) {
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
ASSERT(subclass <= XFS_MMAPLOCK_MAX_SUBCLASS);
|
|
|
|
class += subclass << XFS_MMAPLOCK_SHIFT;
|
2015-02-23 10:43:37 +00:00
|
|
|
}
|
|
|
|
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) {
|
|
|
|
ASSERT(subclass <= XFS_ILOCK_MAX_SUBCLASS);
|
|
|
|
class += subclass << XFS_ILOCK_SHIFT;
|
|
|
|
}
|
2013-08-12 10:49:45 +00:00
|
|
|
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
return (lock_mode & ~XFS_LOCK_SUBCLASS_MASK) | class;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-03-25 03:03:32 +00:00
|
|
|
* The following routine will lock n inodes in exclusive mode. We assume the
|
|
|
|
* caller calls us with the inodes in i_ino order.
|
2013-08-12 10:49:45 +00:00
|
|
|
*
|
2015-03-25 03:03:32 +00:00
|
|
|
* We need to detect deadlock where an inode that we lock is in the AIL and we
|
|
|
|
* start waiting for another inode that is locked by a thread in a long running
|
|
|
|
* transaction (such as truncate). This can result in deadlock since the long
|
|
|
|
* running trans might need to wait for the inode we just locked in order to
|
|
|
|
* push the tail and free space in the log.
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
*
|
|
|
|
* xfs_lock_inodes() can only be used to lock one type of lock at a time -
|
|
|
|
* the iolock, the mmaplock or the ilock, but not more than one at a time. If we
|
|
|
|
* lock more than one at a time, lockdep will report false positives saying we
|
|
|
|
* have violated locking orders.
|
2013-08-12 10:49:45 +00:00
|
|
|
*/
|
2016-06-01 07:38:15 +00:00
|
|
|
static void
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_lock_inodes(
|
2019-06-29 02:27:33 +00:00
|
|
|
struct xfs_inode **ips,
|
|
|
|
int inodes,
|
|
|
|
uint lock_mode)
|
2013-08-12 10:49:45 +00:00
|
|
|
{
|
2019-06-29 02:27:33 +00:00
|
|
|
int attempts = 0, i, j, try_lock;
|
|
|
|
struct xfs_log_item *lp;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
/*
|
|
|
|
* Currently supports between 2 and 5 inodes with exclusive locking. We
|
|
|
|
* support an arbitrary depth of locking here, but absolute limits on
|
2020-08-05 15:49:58 +00:00
|
|
|
* inodes depend on the type of locking and the limits placed by
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
* lockdep annotations in xfs_lock_inumorder. These are all checked by
|
|
|
|
* the asserts.
|
|
|
|
*/
|
2015-03-25 03:03:32 +00:00
|
|
|
ASSERT(ips && inodes >= 2 && inodes <= 5);
|
xfs: clean up inode lockdep annotations
Lockdep annotations are a maintenance nightmare. Locking has to be
modified to suit the limitations of the annotations, and we're
always having to fix the annotations because they are unable to
express the complexity of locking heirarchies correctly.
So, next up, we've got more issues with lockdep annotations for
inode locking w.r.t. XFS_LOCK_PARENT:
- lockdep classes are exclusive and can't be ORed together
to form new classes.
- IOLOCK needs multiple PARENT subclasses to express the
changes needed for the readdir locking rework needed to
stop the endless flow of lockdep false positives involving
readdir calling filldir under the ILOCK.
- there are only 8 unique lockdep subclasses available,
so we can't create a generic solution.
IOWs we need to treat the 3-bit space available to each lock type
differently:
- IOLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 IOLOCK subclasses
- at least 2 IOLOCK_PARENT subclasses
- MMAPLOCK uses xfs_lock_two_inodes(), so needs:
- at least 2 MMAPLOCK subclasses
- ILOCK uses xfs_lock_inodes with up to 5 inodes, so needs:
- at least 5 ILOCK subclasses
- one ILOCK_PARENT subclass
- one RTBITMAP subclass
- one RTSUM subclass
For the IOLOCK, split the space into two sets of subclasses.
For the MMAPLOCK, just use half the space for the one subclass to
match the non-parent lock classes of the IOLOCK.
For the ILOCK, use 0-4 as the ILOCK subclasses, 5-7 for the
remaining individual subclasses.
Because they are now all different, modify xfs_lock_inumorder() to
handle the nested subclasses, and to assert fail if passed an
invalid subclass. Further, annotate xfs_lock_inodes() to assert fail
if an invalid combination of lock primitives and inode counts are
passed that would result in a lockdep subclass annotation overflow.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:32:49 +00:00
|
|
|
ASSERT(lock_mode & (XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL |
|
|
|
|
XFS_ILOCK_EXCL));
|
|
|
|
ASSERT(!(lock_mode & (XFS_IOLOCK_SHARED | XFS_MMAPLOCK_SHARED |
|
|
|
|
XFS_ILOCK_SHARED)));
|
|
|
|
ASSERT(!(lock_mode & XFS_MMAPLOCK_EXCL) ||
|
|
|
|
inodes <= XFS_MMAPLOCK_MAX_SUBCLASS + 1);
|
|
|
|
ASSERT(!(lock_mode & XFS_ILOCK_EXCL) ||
|
|
|
|
inodes <= XFS_ILOCK_MAX_SUBCLASS + 1);
|
|
|
|
|
|
|
|
if (lock_mode & XFS_IOLOCK_EXCL) {
|
|
|
|
ASSERT(!(lock_mode & (XFS_MMAPLOCK_EXCL | XFS_ILOCK_EXCL)));
|
|
|
|
} else if (lock_mode & XFS_MMAPLOCK_EXCL)
|
|
|
|
ASSERT(!(lock_mode & XFS_ILOCK_EXCL));
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
try_lock = 0;
|
|
|
|
i = 0;
|
|
|
|
again:
|
|
|
|
for (; i < inodes; i++) {
|
|
|
|
ASSERT(ips[i]);
|
|
|
|
|
2015-03-25 03:03:32 +00:00
|
|
|
if (i && (ips[i] == ips[i - 1])) /* Already locked */
|
2013-08-12 10:49:45 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
2015-03-25 03:03:32 +00:00
|
|
|
* If try_lock is not set yet, make sure all locked inodes are
|
|
|
|
* not in the AIL. If any are, set try_lock to be used later.
|
2013-08-12 10:49:45 +00:00
|
|
|
*/
|
|
|
|
if (!try_lock) {
|
|
|
|
for (j = (i - 1); j >= 0 && !try_lock; j--) {
|
2019-06-29 02:27:33 +00:00
|
|
|
lp = &ips[j]->i_itemp->ili_item;
|
2018-05-09 14:47:34 +00:00
|
|
|
if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags))
|
2013-08-12 10:49:45 +00:00
|
|
|
try_lock++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If any of the previous locks we have locked is in the AIL,
|
|
|
|
* we must TRY to get the second and subsequent locks. If
|
|
|
|
* we can't get any, we must release all we have
|
|
|
|
* and try again.
|
|
|
|
*/
|
2015-03-25 03:03:32 +00:00
|
|
|
if (!try_lock) {
|
|
|
|
xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* try_lock means we have an inode locked that is in the AIL. */
|
|
|
|
ASSERT(i != 0);
|
|
|
|
if (xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i)))
|
|
|
|
continue;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2015-03-25 03:03:32 +00:00
|
|
|
/*
|
|
|
|
* Unlock all previous guys and try again. xfs_iunlock will try
|
|
|
|
* to push the tail if the inode is in the AIL.
|
|
|
|
*/
|
|
|
|
attempts++;
|
|
|
|
for (j = i - 1; j >= 0; j--) {
|
2013-08-12 10:49:45 +00:00
|
|
|
/*
|
2015-03-25 03:03:32 +00:00
|
|
|
* Check to see if we've already unlocked this one. Not
|
|
|
|
* the first one going back, and the inode ptr is the
|
|
|
|
* same.
|
2013-08-12 10:49:45 +00:00
|
|
|
*/
|
2015-03-25 03:03:32 +00:00
|
|
|
if (j != (i - 1) && ips[j] == ips[j + 1])
|
|
|
|
continue;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2015-03-25 03:03:32 +00:00
|
|
|
xfs_iunlock(ips[j], lock_mode);
|
|
|
|
}
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2015-03-25 03:03:32 +00:00
|
|
|
if ((attempts % 5) == 0) {
|
|
|
|
delay(1); /* Don't just spin the CPU */
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
2015-03-25 03:03:32 +00:00
|
|
|
i = 0;
|
|
|
|
try_lock = 0;
|
|
|
|
goto again;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-02-23 10:43:37 +00:00
|
|
|
* xfs_lock_two_inodes() can only be used to lock one type of lock at a time -
|
2018-01-26 23:27:33 +00:00
|
|
|
* the mmaplock or the ilock, but not more than one type at a time. If we lock
|
|
|
|
* more than one at a time, lockdep will report false positives saying we have
|
|
|
|
* violated locking orders. The iolock must be double-locked separately since
|
|
|
|
* we use i_rwsem for that. We now support taking one lock EXCL and the other
|
|
|
|
* SHARED.
|
2013-08-12 10:49:45 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_lock_two_inodes(
|
2018-01-26 23:27:33 +00:00
|
|
|
struct xfs_inode *ip0,
|
|
|
|
uint ip0_mode,
|
|
|
|
struct xfs_inode *ip1,
|
|
|
|
uint ip1_mode)
|
2013-08-12 10:49:45 +00:00
|
|
|
{
|
2018-01-26 23:27:33 +00:00
|
|
|
struct xfs_inode *temp;
|
|
|
|
uint mode_temp;
|
2013-08-12 10:49:45 +00:00
|
|
|
int attempts = 0;
|
2019-06-29 02:27:33 +00:00
|
|
|
struct xfs_log_item *lp;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2018-01-26 23:27:33 +00:00
|
|
|
ASSERT(hweight32(ip0_mode) == 1);
|
|
|
|
ASSERT(hweight32(ip1_mode) == 1);
|
|
|
|
ASSERT(!(ip0_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
|
|
|
|
ASSERT(!(ip1_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
|
|
|
|
ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
|
|
|
|
!(ip0_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
|
|
|
|
ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
|
|
|
|
!(ip1_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
|
|
|
|
ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
|
|
|
|
!(ip0_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
|
|
|
|
ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
|
|
|
|
!(ip1_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
|
2015-02-23 10:43:37 +00:00
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
ASSERT(ip0->i_ino != ip1->i_ino);
|
|
|
|
|
|
|
|
if (ip0->i_ino > ip1->i_ino) {
|
|
|
|
temp = ip0;
|
|
|
|
ip0 = ip1;
|
|
|
|
ip1 = temp;
|
2018-01-26 23:27:33 +00:00
|
|
|
mode_temp = ip0_mode;
|
|
|
|
ip0_mode = ip1_mode;
|
|
|
|
ip1_mode = mode_temp;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
again:
|
2018-01-26 23:27:33 +00:00
|
|
|
xfs_ilock(ip0, xfs_lock_inumorder(ip0_mode, 0));
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the first lock we have locked is in the AIL, we must TRY to get
|
|
|
|
* the second lock. If we can't get it, we must release the first one
|
|
|
|
* and try again.
|
|
|
|
*/
|
2019-06-29 02:27:33 +00:00
|
|
|
lp = &ip0->i_itemp->ili_item;
|
2018-05-09 14:47:34 +00:00
|
|
|
if (lp && test_bit(XFS_LI_IN_AIL, &lp->li_flags)) {
|
2018-01-26 23:27:33 +00:00
|
|
|
if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(ip1_mode, 1))) {
|
|
|
|
xfs_iunlock(ip0, ip0_mode);
|
2013-08-12 10:49:45 +00:00
|
|
|
if ((++attempts % 5) == 0)
|
|
|
|
delay(1); /* Don't just spin the CPU */
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
} else {
|
2018-01-26 23:27:33 +00:00
|
|
|
xfs_ilock(ip1, xfs_lock_inumorder(ip1_mode, 1));
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-29 18:11:46 +00:00
|
|
|
uint
|
|
|
|
xfs_ip2xflags(
|
|
|
|
struct xfs_inode *ip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
uint flags = 0;
|
|
|
|
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_ANY) {
|
|
|
|
if (ip->i_diflags & XFS_DIFLAG_REALTIME)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_REALTIME;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_PREALLOC)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_PREALLOC;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_IMMUTABLE)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_IMMUTABLE;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_APPEND)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_APPEND;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_SYNC)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_SYNC;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_NOATIME)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_NOATIME;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_NODUMP)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_NODUMP;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_RTINHERIT)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_RTINHERIT;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_PROJINHERIT)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_PROJINHERIT;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_NOSYMLINKS)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_NOSYMLINKS;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_EXTSIZE)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_EXTSIZE;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_EXTSZINHERIT)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_EXTSZINHERIT;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_NODEFRAG)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_NODEFRAG;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags & XFS_DIFLAG_FILESTREAM)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_FILESTREAM;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags2 & XFS_DIFLAG2_ANY) {
|
|
|
|
if (ip->i_diflags2 & XFS_DIFLAG2_DAX)
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_DAX;
|
2021-03-29 18:11:46 +00:00
|
|
|
if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
|
2016-10-03 16:11:43 +00:00
|
|
|
flags |= FS_XFLAG_COWEXTSIZE;
|
2016-01-04 05:44:15 +00:00
|
|
|
}
|
|
|
|
|
2021-03-29 18:11:46 +00:00
|
|
|
if (XFS_IFORK_Q(ip))
|
2016-01-04 05:44:15 +00:00
|
|
|
flags |= FS_XFLAG_HASATTR;
|
2005-04-16 22:20:36 +00:00
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
/*
|
|
|
|
* Lookups up an inode from "name". If ci_name is not NULL, then a CI match
|
|
|
|
* is allowed, otherwise it has to be an exact match. If a CI match is found,
|
|
|
|
* ci_name->name will point to a the actual name (caller must free) or
|
|
|
|
* will be set to NULL if an exact match is found.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_lookup(
|
|
|
|
xfs_inode_t *dp,
|
|
|
|
struct xfs_name *name,
|
|
|
|
xfs_inode_t **ipp,
|
|
|
|
struct xfs_name *ci_name)
|
|
|
|
{
|
|
|
|
xfs_ino_t inum;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
trace_xfs_lookup(dp, name);
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(dp->i_mount))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EIO;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
|
|
|
|
if (error)
|
xfs: stop holding ILOCK over filldir callbacks
The recent change to the readdir locking made in 40194ec ("xfs:
reinstate the ilock in xfs_readdir") for CXFS directory sanity was
probably the wrong thing to do. Deep in the readdir code we
can take page faults in the filldir callback, and so taking a page
fault while holding an inode ilock creates a new set of locking
issues that lockdep warns all over the place about.
The locking order for regular inodes w.r.t. page faults is io_lock
-> pagefault -> mmap_sem -> ilock. The directory readdir code now
triggers ilock -> page fault -> mmap_sem. While we cannot deadlock
at this point, it inverts all the locking patterns that lockdep
normally sees on XFS inodes, and so triggers lockdep. We worked
around this with commit 93a8614 ("xfs: fix directory inode iolock
lockdep false positive"), but that then just moved the lockdep
warning to deeper in the page fault path and triggered on security
inode locks. Fixing the shmem issue there just moved the lockdep
reports somewhere else, and now we are getting false positives from
filesystem freezing annotations getting confused.
Further, if we enter memory reclaim in a readdir path, we now get
lockdep warning about potential deadlocks because the ilock is held
when we enter reclaim. This, again, is different to a regular file
in that we never allow memory reclaim to run while holding the ilock
for regular files. Hence lockdep now throws
ilock->kmalloc->reclaim->ilock warnings.
Basically, the problem is that the ilock is being used to protect
the directory data and the inode metadata, whereas for a regular
file the iolock protects the data and the ilock protects the
metadata. From the VFS perspective, the i_mutex serialises all
accesses to the directory data, and so not holding the ilock for
readdir doesn't matter. The issue is that CXFS doesn't access
directory data via the VFS, so it has no "data serialisaton"
mechanism. Hence we need to hold the IOLOCK in the correct places to
provide this low level directory data access serialisation.
The ilock can then be used just when the extent list needs to be
read, just like we do for regular files. The directory modification
code can take the iolock exclusive when the ilock is also taken,
and this then ensures that readdir is correct excluded while
modifications are in progress.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:33:00 +00:00
|
|
|
goto out_unlock;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
|
|
|
|
if (error)
|
|
|
|
goto out_free_name;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_free_name:
|
|
|
|
if (ci_name)
|
|
|
|
kmem_free(ci_name->name);
|
xfs: stop holding ILOCK over filldir callbacks
The recent change to the readdir locking made in 40194ec ("xfs:
reinstate the ilock in xfs_readdir") for CXFS directory sanity was
probably the wrong thing to do. Deep in the readdir code we
can take page faults in the filldir callback, and so taking a page
fault while holding an inode ilock creates a new set of locking
issues that lockdep warns all over the place about.
The locking order for regular inodes w.r.t. page faults is io_lock
-> pagefault -> mmap_sem -> ilock. The directory readdir code now
triggers ilock -> page fault -> mmap_sem. While we cannot deadlock
at this point, it inverts all the locking patterns that lockdep
normally sees on XFS inodes, and so triggers lockdep. We worked
around this with commit 93a8614 ("xfs: fix directory inode iolock
lockdep false positive"), but that then just moved the lockdep
warning to deeper in the page fault path and triggered on security
inode locks. Fixing the shmem issue there just moved the lockdep
reports somewhere else, and now we are getting false positives from
filesystem freezing annotations getting confused.
Further, if we enter memory reclaim in a readdir path, we now get
lockdep warning about potential deadlocks because the ilock is held
when we enter reclaim. This, again, is different to a regular file
in that we never allow memory reclaim to run while holding the ilock
for regular files. Hence lockdep now throws
ilock->kmalloc->reclaim->ilock warnings.
Basically, the problem is that the ilock is being used to protect
the directory data and the inode metadata, whereas for a regular
file the iolock protects the data and the ilock protects the
metadata. From the VFS perspective, the i_mutex serialises all
accesses to the directory data, and so not holding the ilock for
readdir doesn't matter. The issue is that CXFS doesn't access
directory data via the VFS, so it has no "data serialisaton"
mechanism. Hence we need to hold the IOLOCK in the correct places to
provide this low level directory data access serialisation.
The ilock can then be used just when the extent list needs to be
read, just like we do for regular files. The directory modification
code can take the iolock exclusive when the ilock is also taken,
and this then ensures that readdir is correct excluded while
modifications are in progress.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-08-19 00:33:00 +00:00
|
|
|
out_unlock:
|
2013-08-12 10:49:45 +00:00
|
|
|
*ipp = NULL;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2020-09-13 17:16:40 +00:00
|
|
|
/* Propagate di_flags from a parent inode to a child inode. */
|
|
|
|
static void
|
|
|
|
xfs_inode_inherit_flags(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
const struct xfs_inode *pip)
|
|
|
|
{
|
|
|
|
unsigned int di_flags = 0;
|
xfs: validate extsz hints against rt extent size when rtinherit is set
The RTINHERIT bit can be set on a directory so that newly created
regular files will have the REALTIME bit set to store their data on the
realtime volume. If an extent size hint (and EXTSZINHERIT) are set on
the directory, the hint will also be copied into the new file.
As pointed out in previous patches, for realtime files we require the
extent size hint be an integer multiple of the realtime extent, but we
don't perform the same validation on a directory with both RTINHERIT and
EXTSZINHERIT set, even though the only use-case of that combination is
to propagate extent size hints into new realtime files. This leads to
inode corruption errors when the bad values are propagated.
Because there may be existing filesystems with such a configuration, we
cannot simply amend the inode verifier to trip on these directories and
call it a day because that will cause previously "working" filesystems
to start throwing errors abruptly. Note that it's valid to have
directories with rtinherit set even if there is no realtime volume, in
which case the problem does not manifest because rtinherit is ignored if
there's no realtime device; and it's possible that someone set the flag,
crashed, repaired the filesystem (which clears the hint on the realtime
file) and continued.
Therefore, mitigate this issue in several ways: First, if we try to
write out an inode with both rtinherit/extszinherit set and an unaligned
extent size hint, turn off the hint to correct the error. Second, if
someone tries to misconfigure a directory via the fssetxattr ioctl, fail
the ioctl. Third, reverify both extent size hint values when we
propagate heritable inode attributes from parent to child, to prevent
misconfigurations from spreading.
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
2021-05-12 19:51:26 +00:00
|
|
|
xfs_failaddr_t failaddr;
|
2020-09-13 17:16:40 +00:00
|
|
|
umode_t mode = VFS_I(ip)->i_mode;
|
|
|
|
|
|
|
|
if (S_ISDIR(mode)) {
|
2021-03-29 18:11:44 +00:00
|
|
|
if (pip->i_diflags & XFS_DIFLAG_RTINHERIT)
|
2020-09-13 17:16:40 +00:00
|
|
|
di_flags |= XFS_DIFLAG_RTINHERIT;
|
2021-03-29 18:11:44 +00:00
|
|
|
if (pip->i_diflags & XFS_DIFLAG_EXTSZINHERIT) {
|
2020-09-13 17:16:40 +00:00
|
|
|
di_flags |= XFS_DIFLAG_EXTSZINHERIT;
|
2021-03-29 18:11:41 +00:00
|
|
|
ip->i_extsize = pip->i_extsize;
|
2020-09-13 17:16:40 +00:00
|
|
|
}
|
2021-03-29 18:11:44 +00:00
|
|
|
if (pip->i_diflags & XFS_DIFLAG_PROJINHERIT)
|
2020-09-13 17:16:40 +00:00
|
|
|
di_flags |= XFS_DIFLAG_PROJINHERIT;
|
|
|
|
} else if (S_ISREG(mode)) {
|
2021-03-29 18:11:44 +00:00
|
|
|
if ((pip->i_diflags & XFS_DIFLAG_RTINHERIT) &&
|
2020-09-13 17:16:41 +00:00
|
|
|
xfs_sb_version_hasrealtime(&ip->i_mount->m_sb))
|
2020-09-13 17:16:40 +00:00
|
|
|
di_flags |= XFS_DIFLAG_REALTIME;
|
2021-03-29 18:11:44 +00:00
|
|
|
if (pip->i_diflags & XFS_DIFLAG_EXTSZINHERIT) {
|
2020-09-13 17:16:40 +00:00
|
|
|
di_flags |= XFS_DIFLAG_EXTSIZE;
|
2021-03-29 18:11:41 +00:00
|
|
|
ip->i_extsize = pip->i_extsize;
|
2020-09-13 17:16:40 +00:00
|
|
|
}
|
|
|
|
}
|
2021-03-29 18:11:44 +00:00
|
|
|
if ((pip->i_diflags & XFS_DIFLAG_NOATIME) &&
|
2020-09-13 17:16:40 +00:00
|
|
|
xfs_inherit_noatime)
|
|
|
|
di_flags |= XFS_DIFLAG_NOATIME;
|
2021-03-29 18:11:44 +00:00
|
|
|
if ((pip->i_diflags & XFS_DIFLAG_NODUMP) &&
|
2020-09-13 17:16:40 +00:00
|
|
|
xfs_inherit_nodump)
|
|
|
|
di_flags |= XFS_DIFLAG_NODUMP;
|
2021-03-29 18:11:44 +00:00
|
|
|
if ((pip->i_diflags & XFS_DIFLAG_SYNC) &&
|
2020-09-13 17:16:40 +00:00
|
|
|
xfs_inherit_sync)
|
|
|
|
di_flags |= XFS_DIFLAG_SYNC;
|
2021-03-29 18:11:44 +00:00
|
|
|
if ((pip->i_diflags & XFS_DIFLAG_NOSYMLINKS) &&
|
2020-09-13 17:16:40 +00:00
|
|
|
xfs_inherit_nosymlinks)
|
|
|
|
di_flags |= XFS_DIFLAG_NOSYMLINKS;
|
2021-03-29 18:11:44 +00:00
|
|
|
if ((pip->i_diflags & XFS_DIFLAG_NODEFRAG) &&
|
2020-09-13 17:16:40 +00:00
|
|
|
xfs_inherit_nodefrag)
|
|
|
|
di_flags |= XFS_DIFLAG_NODEFRAG;
|
2021-03-29 18:11:44 +00:00
|
|
|
if (pip->i_diflags & XFS_DIFLAG_FILESTREAM)
|
2020-09-13 17:16:40 +00:00
|
|
|
di_flags |= XFS_DIFLAG_FILESTREAM;
|
|
|
|
|
2021-03-29 18:11:44 +00:00
|
|
|
ip->i_diflags |= di_flags;
|
xfs: validate extsz hints against rt extent size when rtinherit is set
The RTINHERIT bit can be set on a directory so that newly created
regular files will have the REALTIME bit set to store their data on the
realtime volume. If an extent size hint (and EXTSZINHERIT) are set on
the directory, the hint will also be copied into the new file.
As pointed out in previous patches, for realtime files we require the
extent size hint be an integer multiple of the realtime extent, but we
don't perform the same validation on a directory with both RTINHERIT and
EXTSZINHERIT set, even though the only use-case of that combination is
to propagate extent size hints into new realtime files. This leads to
inode corruption errors when the bad values are propagated.
Because there may be existing filesystems with such a configuration, we
cannot simply amend the inode verifier to trip on these directories and
call it a day because that will cause previously "working" filesystems
to start throwing errors abruptly. Note that it's valid to have
directories with rtinherit set even if there is no realtime volume, in
which case the problem does not manifest because rtinherit is ignored if
there's no realtime device; and it's possible that someone set the flag,
crashed, repaired the filesystem (which clears the hint on the realtime
file) and continued.
Therefore, mitigate this issue in several ways: First, if we try to
write out an inode with both rtinherit/extszinherit set and an unaligned
extent size hint, turn off the hint to correct the error. Second, if
someone tries to misconfigure a directory via the fssetxattr ioctl, fail
the ioctl. Third, reverify both extent size hint values when we
propagate heritable inode attributes from parent to child, to prevent
misconfigurations from spreading.
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
2021-05-12 19:51:26 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Inode verifiers on older kernels only check that the extent size
|
|
|
|
* hint is an integer multiple of the rt extent size on realtime files.
|
|
|
|
* They did not check the hint alignment on a directory with both
|
|
|
|
* rtinherit and extszinherit flags set. If the misaligned hint is
|
|
|
|
* propagated from a directory into a new realtime file, new file
|
|
|
|
* allocations will fail due to math errors in the rt allocator and/or
|
|
|
|
* trip the verifiers. Validate the hint settings in the new file so
|
|
|
|
* that we don't let broken hints propagate.
|
|
|
|
*/
|
|
|
|
failaddr = xfs_inode_validate_extsize(ip->i_mount, ip->i_extsize,
|
|
|
|
VFS_I(ip)->i_mode, ip->i_diflags);
|
|
|
|
if (failaddr) {
|
|
|
|
ip->i_diflags &= ~(XFS_DIFLAG_EXTSIZE |
|
|
|
|
XFS_DIFLAG_EXTSZINHERIT);
|
|
|
|
ip->i_extsize = 0;
|
|
|
|
}
|
2020-09-13 17:16:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Propagate di_flags2 from a parent inode to a child inode. */
|
|
|
|
static void
|
|
|
|
xfs_inode_inherit_flags2(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
const struct xfs_inode *pip)
|
|
|
|
{
|
xfs: validate extsz hints against rt extent size when rtinherit is set
The RTINHERIT bit can be set on a directory so that newly created
regular files will have the REALTIME bit set to store their data on the
realtime volume. If an extent size hint (and EXTSZINHERIT) are set on
the directory, the hint will also be copied into the new file.
As pointed out in previous patches, for realtime files we require the
extent size hint be an integer multiple of the realtime extent, but we
don't perform the same validation on a directory with both RTINHERIT and
EXTSZINHERIT set, even though the only use-case of that combination is
to propagate extent size hints into new realtime files. This leads to
inode corruption errors when the bad values are propagated.
Because there may be existing filesystems with such a configuration, we
cannot simply amend the inode verifier to trip on these directories and
call it a day because that will cause previously "working" filesystems
to start throwing errors abruptly. Note that it's valid to have
directories with rtinherit set even if there is no realtime volume, in
which case the problem does not manifest because rtinherit is ignored if
there's no realtime device; and it's possible that someone set the flag,
crashed, repaired the filesystem (which clears the hint on the realtime
file) and continued.
Therefore, mitigate this issue in several ways: First, if we try to
write out an inode with both rtinherit/extszinherit set and an unaligned
extent size hint, turn off the hint to correct the error. Second, if
someone tries to misconfigure a directory via the fssetxattr ioctl, fail
the ioctl. Third, reverify both extent size hint values when we
propagate heritable inode attributes from parent to child, to prevent
misconfigurations from spreading.
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
2021-05-12 19:51:26 +00:00
|
|
|
xfs_failaddr_t failaddr;
|
|
|
|
|
2021-03-29 18:11:45 +00:00
|
|
|
if (pip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE) {
|
|
|
|
ip->i_diflags2 |= XFS_DIFLAG2_COWEXTSIZE;
|
2021-03-29 18:11:42 +00:00
|
|
|
ip->i_cowextsize = pip->i_cowextsize;
|
2020-09-13 17:16:40 +00:00
|
|
|
}
|
2021-03-29 18:11:45 +00:00
|
|
|
if (pip->i_diflags2 & XFS_DIFLAG2_DAX)
|
|
|
|
ip->i_diflags2 |= XFS_DIFLAG2_DAX;
|
xfs: validate extsz hints against rt extent size when rtinherit is set
The RTINHERIT bit can be set on a directory so that newly created
regular files will have the REALTIME bit set to store their data on the
realtime volume. If an extent size hint (and EXTSZINHERIT) are set on
the directory, the hint will also be copied into the new file.
As pointed out in previous patches, for realtime files we require the
extent size hint be an integer multiple of the realtime extent, but we
don't perform the same validation on a directory with both RTINHERIT and
EXTSZINHERIT set, even though the only use-case of that combination is
to propagate extent size hints into new realtime files. This leads to
inode corruption errors when the bad values are propagated.
Because there may be existing filesystems with such a configuration, we
cannot simply amend the inode verifier to trip on these directories and
call it a day because that will cause previously "working" filesystems
to start throwing errors abruptly. Note that it's valid to have
directories with rtinherit set even if there is no realtime volume, in
which case the problem does not manifest because rtinherit is ignored if
there's no realtime device; and it's possible that someone set the flag,
crashed, repaired the filesystem (which clears the hint on the realtime
file) and continued.
Therefore, mitigate this issue in several ways: First, if we try to
write out an inode with both rtinherit/extszinherit set and an unaligned
extent size hint, turn off the hint to correct the error. Second, if
someone tries to misconfigure a directory via the fssetxattr ioctl, fail
the ioctl. Third, reverify both extent size hint values when we
propagate heritable inode attributes from parent to child, to prevent
misconfigurations from spreading.
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
2021-05-12 19:51:26 +00:00
|
|
|
|
|
|
|
/* Don't let invalid cowextsize hints propagate. */
|
|
|
|
failaddr = xfs_inode_validate_cowextsize(ip->i_mount, ip->i_cowextsize,
|
|
|
|
VFS_I(ip)->i_mode, ip->i_diflags, ip->i_diflags2);
|
|
|
|
if (failaddr) {
|
|
|
|
ip->i_diflags2 &= ~XFS_DIFLAG2_COWEXTSIZE;
|
|
|
|
ip->i_cowextsize = 0;
|
|
|
|
}
|
2020-09-13 17:16:40 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2020-12-09 18:05:15 +00:00
|
|
|
* Initialise a newly allocated inode and return the in-core inode to the
|
|
|
|
* caller locked exclusively.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2021-06-02 00:48:24 +00:00
|
|
|
int
|
2020-12-09 18:05:15 +00:00
|
|
|
xfs_init_new_inode(
|
2021-01-21 13:19:58 +00:00
|
|
|
struct user_namespace *mnt_userns,
|
2020-12-09 18:05:15 +00:00
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_inode *pip,
|
|
|
|
xfs_ino_t ino,
|
|
|
|
umode_t mode,
|
|
|
|
xfs_nlink_t nlink,
|
|
|
|
dev_t rdev,
|
|
|
|
prid_t prid,
|
xfs: initialise attr fork on inode create
When we allocate a new inode, we often need to add an attribute to
the inode as part of the create. This can happen as a result of
needing to add default ACLs or security labels before the inode is
made visible to userspace.
This is highly inefficient right now. We do the create transaction
to allocate the inode, then we do an "add attr fork" transaction to
modify the just created empty inode to set the inode fork offset to
allow attributes to be stored, then we go and do the attribute
creation.
This means 3 transactions instead of 1 to allocate an inode, and
this greatly increases the load on the CIL commit code, resulting in
excessive contention on the CIL spin locks and performance
degradation:
18.99% [kernel] [k] __pv_queued_spin_lock_slowpath
3.57% [kernel] [k] do_raw_spin_lock
2.51% [kernel] [k] __raw_callee_save___pv_queued_spin_unlock
2.48% [kernel] [k] memcpy
2.34% [kernel] [k] xfs_log_commit_cil
The typical profile resulting from running fsmark on a selinux enabled
filesytem is adds this overhead to the create path:
- 15.30% xfs_init_security
- 15.23% security_inode_init_security
- 13.05% xfs_initxattrs
- 12.94% xfs_attr_set
- 6.75% xfs_bmap_add_attrfork
- 5.51% xfs_trans_commit
- 5.48% __xfs_trans_commit
- 5.35% xfs_log_commit_cil
- 3.86% _raw_spin_lock
- do_raw_spin_lock
__pv_queued_spin_lock_slowpath
- 0.70% xfs_trans_alloc
0.52% xfs_trans_reserve
- 5.41% xfs_attr_set_args
- 5.39% xfs_attr_set_shortform.constprop.0
- 4.46% xfs_trans_commit
- 4.46% __xfs_trans_commit
- 4.33% xfs_log_commit_cil
- 2.74% _raw_spin_lock
- do_raw_spin_lock
__pv_queued_spin_lock_slowpath
0.60% xfs_inode_item_format
0.90% xfs_attr_try_sf_addname
- 1.99% selinux_inode_init_security
- 1.02% security_sid_to_context_force
- 1.00% security_sid_to_context_core
- 0.92% sidtab_entry_to_string
- 0.90% sidtab_sid2str_get
0.59% sidtab_sid2str_put.part.0
- 0.82% selinux_determine_inode_label
- 0.77% security_transition_sid
0.70% security_compute_sid.part.0
And fsmark creation rate performance drops by ~25%. The key point to
note here is that half the additional overhead comes from adding the
attribute fork to the newly created inode. That's crazy, considering
we can do this same thing at inode create time with a couple of
lines of code and no extra overhead.
So, if we know we are going to add an attribute immediately after
creating the inode, let's just initialise the attribute fork inside
the create transaction and chop that whole chunk of code out of
the create fast path. This completely removes the performance
drop caused by enabling SELinux, and the profile looks like:
- 8.99% xfs_init_security
- 9.00% security_inode_init_security
- 6.43% xfs_initxattrs
- 6.37% xfs_attr_set
- 5.45% xfs_attr_set_args
- 5.42% xfs_attr_set_shortform.constprop.0
- 4.51% xfs_trans_commit
- 4.54% __xfs_trans_commit
- 4.59% xfs_log_commit_cil
- 2.67% _raw_spin_lock
- 3.28% do_raw_spin_lock
3.08% __pv_queued_spin_lock_slowpath
0.66% xfs_inode_item_format
- 0.90% xfs_attr_try_sf_addname
- 0.60% xfs_trans_alloc
- 2.35% selinux_inode_init_security
- 1.25% security_sid_to_context_force
- 1.21% security_sid_to_context_core
- 1.19% sidtab_entry_to_string
- 1.20% sidtab_sid2str_get
- 0.86% sidtab_sid2str_put.part.0
- 0.62% _raw_spin_lock_irqsave
- 0.77% do_raw_spin_lock
__pv_queued_spin_lock_slowpath
- 0.84% selinux_determine_inode_label
- 0.83% security_transition_sid
0.86% security_compute_sid.part.0
Which indicates the XFS overhead of creating the selinux xattr has
been halved. This doesn't fix the CIL lock contention problem, just
means it's not a limiting factor for this workload. Lock contention
in the security subsystems is going to be an issue soon, though...
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
[djwong: fix compilation error when CONFIG_SECURITY=n]
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Gao Xiang <hsiangkao@redhat.com>
2021-03-22 16:52:03 +00:00
|
|
|
bool init_xattrs,
|
2020-12-09 18:05:15 +00:00
|
|
|
struct xfs_inode **ipp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2021-01-23 00:48:18 +00:00
|
|
|
struct inode *dir = pip ? VFS_I(pip) : NULL;
|
2020-12-09 18:05:15 +00:00
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
struct xfs_inode *ip;
|
|
|
|
unsigned int flags;
|
|
|
|
int error;
|
|
|
|
struct timespec64 tv;
|
|
|
|
struct inode *inode;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-04-18 00:17:35 +00:00
|
|
|
/*
|
|
|
|
* Protect against obviously corrupt allocation btree records. Later
|
|
|
|
* xfs_iget checks will catch re-allocation of other active in-memory
|
|
|
|
* and on-disk inodes. If we don't catch reallocating the parent inode
|
|
|
|
* here we will deadlock in xfs_iget() so we have to do these checks
|
|
|
|
* first.
|
|
|
|
*/
|
|
|
|
if ((pip && ino == pip->i_ino) || !xfs_verify_dir_ino(mp, ino)) {
|
|
|
|
xfs_alert(mp, "Allocated a known in-use inode 0x%llx!", ino);
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2020-12-09 18:05:15 +00:00
|
|
|
* Get the in-core inode with the lock held exclusively to prevent
|
|
|
|
* others from looking at until we're done.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2020-12-09 18:05:15 +00:00
|
|
|
error = xfs_iget(mp, tp, ino, XFS_IGET_CREATE, XFS_ILOCK_EXCL, &ip);
|
2008-10-30 06:36:14 +00:00
|
|
|
if (error)
|
2005-04-16 22:20:36 +00:00
|
|
|
return error;
|
2020-12-09 18:05:15 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ASSERT(ip != NULL);
|
2016-02-09 05:54:58 +00:00
|
|
|
inode = VFS_I(ip);
|
2016-02-09 05:54:58 +00:00
|
|
|
set_nlink(inode, nlink);
|
2017-10-19 18:07:09 +00:00
|
|
|
inode->i_rdev = rdev;
|
2021-03-29 18:11:39 +00:00
|
|
|
ip->i_projid = prid;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-01-23 00:48:18 +00:00
|
|
|
if (dir && !(dir->i_mode & S_ISGID) &&
|
|
|
|
(mp->m_flags & XFS_MOUNT_GRPID)) {
|
2021-03-20 12:26:24 +00:00
|
|
|
inode_fsuid_set(inode, mnt_userns);
|
2021-01-23 00:48:18 +00:00
|
|
|
inode->i_gid = dir->i_gid;
|
|
|
|
inode->i_mode = mode;
|
2020-02-21 16:31:26 +00:00
|
|
|
} else {
|
idmapped-mounts-v5.12
-----BEGIN PGP SIGNATURE-----
iHUEABYKAB0WIQRAhzRXHqcMeLMyaSiRxhvAZXjcogUCYCegywAKCRCRxhvAZXjc
ouJ6AQDlf+7jCQlQdeKKoN9QDFfMzG1ooemat36EpRRTONaGuAD8D9A4sUsG4+5f
4IU5Lj9oY4DEmF8HenbWK2ZHsesL2Qg=
=yPaw
-----END PGP SIGNATURE-----
Merge tag 'idmapped-mounts-v5.12' of git://git.kernel.org/pub/scm/linux/kernel/git/brauner/linux
Pull idmapped mounts from Christian Brauner:
"This introduces idmapped mounts which has been in the making for some
time. Simply put, different mounts can expose the same file or
directory with different ownership. This initial implementation comes
with ports for fat, ext4 and with Christoph's port for xfs with more
filesystems being actively worked on by independent people and
maintainers.
Idmapping mounts handle a wide range of long standing use-cases. Here
are just a few:
- Idmapped mounts make it possible to easily share files between
multiple users or multiple machines especially in complex
scenarios. For example, idmapped mounts will be used in the
implementation of portable home directories in
systemd-homed.service(8) where they allow users to move their home
directory to an external storage device and use it on multiple
computers where they are assigned different uids and gids. This
effectively makes it possible to assign random uids and gids at
login time.
- It is possible to share files from the host with unprivileged
containers without having to change ownership permanently through
chown(2).
- It is possible to idmap a container's rootfs and without having to
mangle every file. For example, Chromebooks use it to share the
user's Download folder with their unprivileged containers in their
Linux subsystem.
- It is possible to share files between containers with
non-overlapping idmappings.
- Filesystem that lack a proper concept of ownership such as fat can
use idmapped mounts to implement discretionary access (DAC)
permission checking.
- They allow users to efficiently changing ownership on a per-mount
basis without having to (recursively) chown(2) all files. In
contrast to chown (2) changing ownership of large sets of files is
instantenous with idmapped mounts. This is especially useful when
ownership of a whole root filesystem of a virtual machine or
container is changed. With idmapped mounts a single syscall
mount_setattr syscall will be sufficient to change the ownership of
all files.
- Idmapped mounts always take the current ownership into account as
idmappings specify what a given uid or gid is supposed to be mapped
to. This contrasts with the chown(2) syscall which cannot by itself
take the current ownership of the files it changes into account. It
simply changes the ownership to the specified uid and gid. This is
especially problematic when recursively chown(2)ing a large set of
files which is commong with the aforementioned portable home
directory and container and vm scenario.
- Idmapped mounts allow to change ownership locally, restricting it
to specific mounts, and temporarily as the ownership changes only
apply as long as the mount exists.
Several userspace projects have either already put up patches and
pull-requests for this feature or will do so should you decide to pull
this:
- systemd: In a wide variety of scenarios but especially right away
in their implementation of portable home directories.
https://systemd.io/HOME_DIRECTORY/
- container runtimes: containerd, runC, LXD:To share data between
host and unprivileged containers, unprivileged and privileged
containers, etc. The pull request for idmapped mounts support in
containerd, the default Kubernetes runtime is already up for quite
a while now: https://github.com/containerd/containerd/pull/4734
- The virtio-fs developers and several users have expressed interest
in using this feature with virtual machines once virtio-fs is
ported.
- ChromeOS: Sharing host-directories with unprivileged containers.
I've tightly synced with all those projects and all of those listed
here have also expressed their need/desire for this feature on the
mailing list. For more info on how people use this there's a bunch of
talks about this too. Here's just two recent ones:
https://www.cncf.io/wp-content/uploads/2020/12/Rootless-Containers-in-Gitpod.pdf
https://fosdem.org/2021/schedule/event/containers_idmap/
This comes with an extensive xfstests suite covering both ext4 and
xfs:
https://git.kernel.org/brauner/xfstests-dev/h/idmapped_mounts
It covers truncation, creation, opening, xattrs, vfscaps, setid
execution, setgid inheritance and more both with idmapped and
non-idmapped mounts. It already helped to discover an unrelated xfs
setgid inheritance bug which has since been fixed in mainline. It will
be sent for inclusion with the xfstests project should you decide to
merge this.
In order to support per-mount idmappings vfsmounts are marked with
user namespaces. The idmapping of the user namespace will be used to
map the ids of vfs objects when they are accessed through that mount.
By default all vfsmounts are marked with the initial user namespace.
The initial user namespace is used to indicate that a mount is not
idmapped. All operations behave as before and this is verified in the
testsuite.
Based on prior discussions we want to attach the whole user namespace
and not just a dedicated idmapping struct. This allows us to reuse all
the helpers that already exist for dealing with idmappings instead of
introducing a whole new range of helpers. In addition, if we decide in
the future that we are confident enough to enable unprivileged users
to setup idmapped mounts the permission checking can take into account
whether the caller is privileged in the user namespace the mount is
currently marked with.
The user namespace the mount will be marked with can be specified by
passing a file descriptor refering to the user namespace as an
argument to the new mount_setattr() syscall together with the new
MOUNT_ATTR_IDMAP flag. The system call follows the openat2() pattern
of extensibility.
The following conditions must be met in order to create an idmapped
mount:
- The caller must currently have the CAP_SYS_ADMIN capability in the
user namespace the underlying filesystem has been mounted in.
- The underlying filesystem must support idmapped mounts.
- The mount must not already be idmapped. This also implies that the
idmapping of a mount cannot be altered once it has been idmapped.
- The mount must be a detached/anonymous mount, i.e. it must have
been created by calling open_tree() with the OPEN_TREE_CLONE flag
and it must not already have been visible in the filesystem.
The last two points guarantee easier semantics for userspace and the
kernel and make the implementation significantly simpler.
By default vfsmounts are marked with the initial user namespace and no
behavioral or performance changes are observed.
The manpage with a detailed description can be found here:
https://git.kernel.org/brauner/man-pages/c/1d7b902e2875a1ff342e036a9f866a995640aea8
In order to support idmapped mounts, filesystems need to be changed
and mark themselves with the FS_ALLOW_IDMAP flag in fs_flags. The
patches to convert individual filesystem are not very large or
complicated overall as can be seen from the included fat, ext4, and
xfs ports. Patches for other filesystems are actively worked on and
will be sent out separately. The xfstestsuite can be used to verify
that port has been done correctly.
The mount_setattr() syscall is motivated independent of the idmapped
mounts patches and it's been around since July 2019. One of the most
valuable features of the new mount api is the ability to perform
mounts based on file descriptors only.
Together with the lookup restrictions available in the openat2()
RESOLVE_* flag namespace which we added in v5.6 this is the first time
we are close to hardened and race-free (e.g. symlinks) mounting and
path resolution.
While userspace has started porting to the new mount api to mount
proper filesystems and create new bind-mounts it is currently not
possible to change mount options of an already existing bind mount in
the new mount api since the mount_setattr() syscall is missing.
With the addition of the mount_setattr() syscall we remove this last
restriction and userspace can now fully port to the new mount api,
covering every use-case the old mount api could. We also add the
crucial ability to recursively change mount options for a whole mount
tree, both removing and adding mount options at the same time. This
syscall has been requested multiple times by various people and
projects.
There is a simple tool available at
https://github.com/brauner/mount-idmapped
that allows to create idmapped mounts so people can play with this
patch series. I'll add support for the regular mount binary should you
decide to pull this in the following weeks:
Here's an example to a simple idmapped mount of another user's home
directory:
u1001@f2-vm:/$ sudo ./mount --idmap both:1000:1001:1 /home/ubuntu/ /mnt
u1001@f2-vm:/$ ls -al /home/ubuntu/
total 28
drwxr-xr-x 2 ubuntu ubuntu 4096 Oct 28 22:07 .
drwxr-xr-x 4 root root 4096 Oct 28 04:00 ..
-rw------- 1 ubuntu ubuntu 3154 Oct 28 22:12 .bash_history
-rw-r--r-- 1 ubuntu ubuntu 220 Feb 25 2020 .bash_logout
-rw-r--r-- 1 ubuntu ubuntu 3771 Feb 25 2020 .bashrc
-rw-r--r-- 1 ubuntu ubuntu 807 Feb 25 2020 .profile
-rw-r--r-- 1 ubuntu ubuntu 0 Oct 16 16:11 .sudo_as_admin_successful
-rw------- 1 ubuntu ubuntu 1144 Oct 28 00:43 .viminfo
u1001@f2-vm:/$ ls -al /mnt/
total 28
drwxr-xr-x 2 u1001 u1001 4096 Oct 28 22:07 .
drwxr-xr-x 29 root root 4096 Oct 28 22:01 ..
-rw------- 1 u1001 u1001 3154 Oct 28 22:12 .bash_history
-rw-r--r-- 1 u1001 u1001 220 Feb 25 2020 .bash_logout
-rw-r--r-- 1 u1001 u1001 3771 Feb 25 2020 .bashrc
-rw-r--r-- 1 u1001 u1001 807 Feb 25 2020 .profile
-rw-r--r-- 1 u1001 u1001 0 Oct 16 16:11 .sudo_as_admin_successful
-rw------- 1 u1001 u1001 1144 Oct 28 00:43 .viminfo
u1001@f2-vm:/$ touch /mnt/my-file
u1001@f2-vm:/$ setfacl -m u:1001:rwx /mnt/my-file
u1001@f2-vm:/$ sudo setcap -n 1001 cap_net_raw+ep /mnt/my-file
u1001@f2-vm:/$ ls -al /mnt/my-file
-rw-rwxr--+ 1 u1001 u1001 0 Oct 28 22:14 /mnt/my-file
u1001@f2-vm:/$ ls -al /home/ubuntu/my-file
-rw-rwxr--+ 1 ubuntu ubuntu 0 Oct 28 22:14 /home/ubuntu/my-file
u1001@f2-vm:/$ getfacl /mnt/my-file
getfacl: Removing leading '/' from absolute path names
# file: mnt/my-file
# owner: u1001
# group: u1001
user::rw-
user:u1001:rwx
group::rw-
mask::rwx
other::r--
u1001@f2-vm:/$ getfacl /home/ubuntu/my-file
getfacl: Removing leading '/' from absolute path names
# file: home/ubuntu/my-file
# owner: ubuntu
# group: ubuntu
user::rw-
user:ubuntu:rwx
group::rw-
mask::rwx
other::r--"
* tag 'idmapped-mounts-v5.12' of git://git.kernel.org/pub/scm/linux/kernel/git/brauner/linux: (41 commits)
xfs: remove the possibly unused mp variable in xfs_file_compat_ioctl
xfs: support idmapped mounts
ext4: support idmapped mounts
fat: handle idmapped mounts
tests: add mount_setattr() selftests
fs: introduce MOUNT_ATTR_IDMAP
fs: add mount_setattr()
fs: add attr_flags_to_mnt_flags helper
fs: split out functions to hold writers
namespace: only take read lock in do_reconfigure_mnt()
mount: make {lock,unlock}_mount_hash() static
namespace: take lock_mount_hash() directly when changing flags
nfs: do not export idmapped mounts
overlayfs: do not mount on top of idmapped mounts
ecryptfs: do not mount on top of idmapped mounts
ima: handle idmapped mounts
apparmor: handle idmapped mounts
fs: make helpers idmap mount aware
exec: handle idmapped mounts
would_dump: handle idmapped mounts
...
2021-02-23 21:39:45 +00:00
|
|
|
inode_init_owner(mnt_userns, inode, dir, mode);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the group ID of the new file does not match the effective group
|
|
|
|
* ID or one of the supplementary group IDs, the S_ISGID bit is cleared
|
|
|
|
* (and only if the irix_sgid_inherit compatibility variable is set).
|
|
|
|
*/
|
2020-02-21 16:31:27 +00:00
|
|
|
if (irix_sgid_inherit &&
|
2021-01-21 13:19:58 +00:00
|
|
|
(inode->i_mode & S_ISGID) &&
|
|
|
|
!in_group_p(i_gid_into_mnt(mnt_userns, inode)))
|
2016-02-09 05:54:58 +00:00
|
|
|
inode->i_mode &= ~S_ISGID;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-03-29 18:11:40 +00:00
|
|
|
ip->i_disk_size = 0;
|
2020-05-18 17:27:22 +00:00
|
|
|
ip->i_df.if_nextents = 0;
|
2021-03-29 18:11:40 +00:00
|
|
|
ASSERT(ip->i_nblocks == 0);
|
2008-08-13 06:44:15 +00:00
|
|
|
|
2016-09-14 14:48:06 +00:00
|
|
|
tv = current_time(inode);
|
2016-02-09 05:54:58 +00:00
|
|
|
inode->i_mtime = tv;
|
|
|
|
inode->i_atime = tv;
|
|
|
|
inode->i_ctime = tv;
|
2008-08-13 06:44:15 +00:00
|
|
|
|
2021-03-29 18:11:41 +00:00
|
|
|
ip->i_extsize = 0;
|
2021-03-29 18:11:44 +00:00
|
|
|
ip->i_diflags = 0;
|
2013-04-03 05:11:17 +00:00
|
|
|
|
2020-03-18 15:15:11 +00:00
|
|
|
if (xfs_sb_version_has_v3inode(&mp->m_sb)) {
|
2017-12-11 11:35:19 +00:00
|
|
|
inode_set_iversion(inode, 1);
|
2021-03-29 18:11:42 +00:00
|
|
|
ip->i_cowextsize = 0;
|
2021-03-29 18:11:45 +00:00
|
|
|
ip->i_crtime = tv;
|
2013-04-03 05:11:17 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
flags = XFS_ILOG_CORE;
|
|
|
|
switch (mode & S_IFMT) {
|
|
|
|
case S_IFIFO:
|
|
|
|
case S_IFCHR:
|
|
|
|
case S_IFBLK:
|
|
|
|
case S_IFSOCK:
|
2020-05-18 17:28:05 +00:00
|
|
|
ip->i_df.if_format = XFS_DINODE_FMT_DEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
flags |= XFS_ILOG_DEV;
|
|
|
|
break;
|
|
|
|
case S_IFREG:
|
|
|
|
case S_IFDIR:
|
2021-03-29 18:11:44 +00:00
|
|
|
if (pip && (pip->i_diflags & XFS_DIFLAG_ANY))
|
2020-09-13 17:16:40 +00:00
|
|
|
xfs_inode_inherit_flags(ip, pip);
|
2021-03-29 18:11:45 +00:00
|
|
|
if (pip && (pip->i_diflags2 & XFS_DIFLAG2_ANY))
|
2020-09-13 17:16:40 +00:00
|
|
|
xfs_inode_inherit_flags2(ip, pip);
|
2021-04-20 22:54:36 +00:00
|
|
|
fallthrough;
|
2005-04-16 22:20:36 +00:00
|
|
|
case S_IFLNK:
|
2020-05-18 17:28:05 +00:00
|
|
|
ip->i_df.if_format = XFS_DINODE_FMT_EXTENTS;
|
2018-07-17 23:51:50 +00:00
|
|
|
ip->i_df.if_bytes = 0;
|
2017-11-03 17:34:46 +00:00
|
|
|
ip->i_df.if_u1.if_root = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ASSERT(0);
|
|
|
|
}
|
|
|
|
|
xfs: initialise attr fork on inode create
When we allocate a new inode, we often need to add an attribute to
the inode as part of the create. This can happen as a result of
needing to add default ACLs or security labels before the inode is
made visible to userspace.
This is highly inefficient right now. We do the create transaction
to allocate the inode, then we do an "add attr fork" transaction to
modify the just created empty inode to set the inode fork offset to
allow attributes to be stored, then we go and do the attribute
creation.
This means 3 transactions instead of 1 to allocate an inode, and
this greatly increases the load on the CIL commit code, resulting in
excessive contention on the CIL spin locks and performance
degradation:
18.99% [kernel] [k] __pv_queued_spin_lock_slowpath
3.57% [kernel] [k] do_raw_spin_lock
2.51% [kernel] [k] __raw_callee_save___pv_queued_spin_unlock
2.48% [kernel] [k] memcpy
2.34% [kernel] [k] xfs_log_commit_cil
The typical profile resulting from running fsmark on a selinux enabled
filesytem is adds this overhead to the create path:
- 15.30% xfs_init_security
- 15.23% security_inode_init_security
- 13.05% xfs_initxattrs
- 12.94% xfs_attr_set
- 6.75% xfs_bmap_add_attrfork
- 5.51% xfs_trans_commit
- 5.48% __xfs_trans_commit
- 5.35% xfs_log_commit_cil
- 3.86% _raw_spin_lock
- do_raw_spin_lock
__pv_queued_spin_lock_slowpath
- 0.70% xfs_trans_alloc
0.52% xfs_trans_reserve
- 5.41% xfs_attr_set_args
- 5.39% xfs_attr_set_shortform.constprop.0
- 4.46% xfs_trans_commit
- 4.46% __xfs_trans_commit
- 4.33% xfs_log_commit_cil
- 2.74% _raw_spin_lock
- do_raw_spin_lock
__pv_queued_spin_lock_slowpath
0.60% xfs_inode_item_format
0.90% xfs_attr_try_sf_addname
- 1.99% selinux_inode_init_security
- 1.02% security_sid_to_context_force
- 1.00% security_sid_to_context_core
- 0.92% sidtab_entry_to_string
- 0.90% sidtab_sid2str_get
0.59% sidtab_sid2str_put.part.0
- 0.82% selinux_determine_inode_label
- 0.77% security_transition_sid
0.70% security_compute_sid.part.0
And fsmark creation rate performance drops by ~25%. The key point to
note here is that half the additional overhead comes from adding the
attribute fork to the newly created inode. That's crazy, considering
we can do this same thing at inode create time with a couple of
lines of code and no extra overhead.
So, if we know we are going to add an attribute immediately after
creating the inode, let's just initialise the attribute fork inside
the create transaction and chop that whole chunk of code out of
the create fast path. This completely removes the performance
drop caused by enabling SELinux, and the profile looks like:
- 8.99% xfs_init_security
- 9.00% security_inode_init_security
- 6.43% xfs_initxattrs
- 6.37% xfs_attr_set
- 5.45% xfs_attr_set_args
- 5.42% xfs_attr_set_shortform.constprop.0
- 4.51% xfs_trans_commit
- 4.54% __xfs_trans_commit
- 4.59% xfs_log_commit_cil
- 2.67% _raw_spin_lock
- 3.28% do_raw_spin_lock
3.08% __pv_queued_spin_lock_slowpath
0.66% xfs_inode_item_format
- 0.90% xfs_attr_try_sf_addname
- 0.60% xfs_trans_alloc
- 2.35% selinux_inode_init_security
- 1.25% security_sid_to_context_force
- 1.21% security_sid_to_context_core
- 1.19% sidtab_entry_to_string
- 1.20% sidtab_sid2str_get
- 0.86% sidtab_sid2str_put.part.0
- 0.62% _raw_spin_lock_irqsave
- 0.77% do_raw_spin_lock
__pv_queued_spin_lock_slowpath
- 0.84% selinux_determine_inode_label
- 0.83% security_transition_sid
0.86% security_compute_sid.part.0
Which indicates the XFS overhead of creating the selinux xattr has
been halved. This doesn't fix the CIL lock contention problem, just
means it's not a limiting factor for this workload. Lock contention
in the security subsystems is going to be an issue soon, though...
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
[djwong: fix compilation error when CONFIG_SECURITY=n]
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Gao Xiang <hsiangkao@redhat.com>
2021-03-22 16:52:03 +00:00
|
|
|
/*
|
|
|
|
* If we need to create attributes immediately after allocating the
|
|
|
|
* inode, initialise an empty attribute fork right now. We use the
|
|
|
|
* default fork offset for attributes here as we don't know exactly what
|
|
|
|
* size or how many attributes we might be adding. We can do this
|
|
|
|
* safely here because we know the data fork is completely empty and
|
|
|
|
* this saves us from needing to run a separate transaction to set the
|
|
|
|
* fork offset in the immediate future.
|
|
|
|
*/
|
2021-04-06 14:01:00 +00:00
|
|
|
if (init_xattrs && xfs_sb_version_hasattr(&mp->m_sb)) {
|
2021-03-29 18:11:44 +00:00
|
|
|
ip->i_forkoff = xfs_default_attroffset(ip) >> 3;
|
xfs: initialise attr fork on inode create
When we allocate a new inode, we often need to add an attribute to
the inode as part of the create. This can happen as a result of
needing to add default ACLs or security labels before the inode is
made visible to userspace.
This is highly inefficient right now. We do the create transaction
to allocate the inode, then we do an "add attr fork" transaction to
modify the just created empty inode to set the inode fork offset to
allow attributes to be stored, then we go and do the attribute
creation.
This means 3 transactions instead of 1 to allocate an inode, and
this greatly increases the load on the CIL commit code, resulting in
excessive contention on the CIL spin locks and performance
degradation:
18.99% [kernel] [k] __pv_queued_spin_lock_slowpath
3.57% [kernel] [k] do_raw_spin_lock
2.51% [kernel] [k] __raw_callee_save___pv_queued_spin_unlock
2.48% [kernel] [k] memcpy
2.34% [kernel] [k] xfs_log_commit_cil
The typical profile resulting from running fsmark on a selinux enabled
filesytem is adds this overhead to the create path:
- 15.30% xfs_init_security
- 15.23% security_inode_init_security
- 13.05% xfs_initxattrs
- 12.94% xfs_attr_set
- 6.75% xfs_bmap_add_attrfork
- 5.51% xfs_trans_commit
- 5.48% __xfs_trans_commit
- 5.35% xfs_log_commit_cil
- 3.86% _raw_spin_lock
- do_raw_spin_lock
__pv_queued_spin_lock_slowpath
- 0.70% xfs_trans_alloc
0.52% xfs_trans_reserve
- 5.41% xfs_attr_set_args
- 5.39% xfs_attr_set_shortform.constprop.0
- 4.46% xfs_trans_commit
- 4.46% __xfs_trans_commit
- 4.33% xfs_log_commit_cil
- 2.74% _raw_spin_lock
- do_raw_spin_lock
__pv_queued_spin_lock_slowpath
0.60% xfs_inode_item_format
0.90% xfs_attr_try_sf_addname
- 1.99% selinux_inode_init_security
- 1.02% security_sid_to_context_force
- 1.00% security_sid_to_context_core
- 0.92% sidtab_entry_to_string
- 0.90% sidtab_sid2str_get
0.59% sidtab_sid2str_put.part.0
- 0.82% selinux_determine_inode_label
- 0.77% security_transition_sid
0.70% security_compute_sid.part.0
And fsmark creation rate performance drops by ~25%. The key point to
note here is that half the additional overhead comes from adding the
attribute fork to the newly created inode. That's crazy, considering
we can do this same thing at inode create time with a couple of
lines of code and no extra overhead.
So, if we know we are going to add an attribute immediately after
creating the inode, let's just initialise the attribute fork inside
the create transaction and chop that whole chunk of code out of
the create fast path. This completely removes the performance
drop caused by enabling SELinux, and the profile looks like:
- 8.99% xfs_init_security
- 9.00% security_inode_init_security
- 6.43% xfs_initxattrs
- 6.37% xfs_attr_set
- 5.45% xfs_attr_set_args
- 5.42% xfs_attr_set_shortform.constprop.0
- 4.51% xfs_trans_commit
- 4.54% __xfs_trans_commit
- 4.59% xfs_log_commit_cil
- 2.67% _raw_spin_lock
- 3.28% do_raw_spin_lock
3.08% __pv_queued_spin_lock_slowpath
0.66% xfs_inode_item_format
- 0.90% xfs_attr_try_sf_addname
- 0.60% xfs_trans_alloc
- 2.35% selinux_inode_init_security
- 1.25% security_sid_to_context_force
- 1.21% security_sid_to_context_core
- 1.19% sidtab_entry_to_string
- 1.20% sidtab_sid2str_get
- 0.86% sidtab_sid2str_put.part.0
- 0.62% _raw_spin_lock_irqsave
- 0.77% do_raw_spin_lock
__pv_queued_spin_lock_slowpath
- 0.84% selinux_determine_inode_label
- 0.83% security_transition_sid
0.86% security_compute_sid.part.0
Which indicates the XFS overhead of creating the selinux xattr has
been halved. This doesn't fix the CIL lock contention problem, just
means it's not a limiting factor for this workload. Lock contention
in the security subsystems is going to be an issue soon, though...
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
[djwong: fix compilation error when CONFIG_SECURITY=n]
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Gao Xiang <hsiangkao@redhat.com>
2021-03-22 16:52:03 +00:00
|
|
|
ip->i_afp = xfs_ifork_alloc(XFS_DINODE_FMT_EXTENTS, 0);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Log the new values stuffed into the inode.
|
|
|
|
*/
|
2011-09-19 15:00:54 +00:00
|
|
|
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_trans_log_inode(tp, ip, flags);
|
|
|
|
|
2015-02-23 11:38:08 +00:00
|
|
|
/* now that we have an i_mode we can setup the inode structure */
|
2008-08-13 06:23:13 +00:00
|
|
|
xfs_setup_inode(ip);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
*ipp = ip;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:47 +00:00
|
|
|
/*
|
2016-02-09 05:54:58 +00:00
|
|
|
* Decrement the link count on an inode & log the change. If this causes the
|
|
|
|
* link count to go to zero, move the inode to AGI unlinked list so that it can
|
|
|
|
* be freed when the last active reference goes away via xfs_inactive().
|
2013-08-12 10:49:47 +00:00
|
|
|
*/
|
2016-06-01 07:38:15 +00:00
|
|
|
static int /* error */
|
2013-08-12 10:49:47 +00:00
|
|
|
xfs_droplink(
|
|
|
|
xfs_trans_t *tp,
|
|
|
|
xfs_inode_t *ip)
|
|
|
|
{
|
|
|
|
xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
|
|
|
|
|
|
|
|
drop_nlink(VFS_I(ip));
|
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
if (VFS_I(ip)->i_nlink)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return xfs_iunlink(tp, ip);
|
2013-08-12 10:49:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Increment the link count on an inode & log the change.
|
|
|
|
*/
|
2019-05-02 03:26:30 +00:00
|
|
|
static void
|
2013-08-12 10:49:47 +00:00
|
|
|
xfs_bumplink(
|
|
|
|
xfs_trans_t *tp,
|
|
|
|
xfs_inode_t *ip)
|
|
|
|
{
|
|
|
|
xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
|
|
|
|
|
|
|
|
inc_nlink(VFS_I(ip));
|
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
int
|
|
|
|
xfs_create(
|
2021-01-21 13:19:58 +00:00
|
|
|
struct user_namespace *mnt_userns,
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_inode_t *dp,
|
|
|
|
struct xfs_name *name,
|
|
|
|
umode_t mode,
|
2017-10-19 18:07:09 +00:00
|
|
|
dev_t rdev,
|
xfs: initialise attr fork on inode create
When we allocate a new inode, we often need to add an attribute to
the inode as part of the create. This can happen as a result of
needing to add default ACLs or security labels before the inode is
made visible to userspace.
This is highly inefficient right now. We do the create transaction
to allocate the inode, then we do an "add attr fork" transaction to
modify the just created empty inode to set the inode fork offset to
allow attributes to be stored, then we go and do the attribute
creation.
This means 3 transactions instead of 1 to allocate an inode, and
this greatly increases the load on the CIL commit code, resulting in
excessive contention on the CIL spin locks and performance
degradation:
18.99% [kernel] [k] __pv_queued_spin_lock_slowpath
3.57% [kernel] [k] do_raw_spin_lock
2.51% [kernel] [k] __raw_callee_save___pv_queued_spin_unlock
2.48% [kernel] [k] memcpy
2.34% [kernel] [k] xfs_log_commit_cil
The typical profile resulting from running fsmark on a selinux enabled
filesytem is adds this overhead to the create path:
- 15.30% xfs_init_security
- 15.23% security_inode_init_security
- 13.05% xfs_initxattrs
- 12.94% xfs_attr_set
- 6.75% xfs_bmap_add_attrfork
- 5.51% xfs_trans_commit
- 5.48% __xfs_trans_commit
- 5.35% xfs_log_commit_cil
- 3.86% _raw_spin_lock
- do_raw_spin_lock
__pv_queued_spin_lock_slowpath
- 0.70% xfs_trans_alloc
0.52% xfs_trans_reserve
- 5.41% xfs_attr_set_args
- 5.39% xfs_attr_set_shortform.constprop.0
- 4.46% xfs_trans_commit
- 4.46% __xfs_trans_commit
- 4.33% xfs_log_commit_cil
- 2.74% _raw_spin_lock
- do_raw_spin_lock
__pv_queued_spin_lock_slowpath
0.60% xfs_inode_item_format
0.90% xfs_attr_try_sf_addname
- 1.99% selinux_inode_init_security
- 1.02% security_sid_to_context_force
- 1.00% security_sid_to_context_core
- 0.92% sidtab_entry_to_string
- 0.90% sidtab_sid2str_get
0.59% sidtab_sid2str_put.part.0
- 0.82% selinux_determine_inode_label
- 0.77% security_transition_sid
0.70% security_compute_sid.part.0
And fsmark creation rate performance drops by ~25%. The key point to
note here is that half the additional overhead comes from adding the
attribute fork to the newly created inode. That's crazy, considering
we can do this same thing at inode create time with a couple of
lines of code and no extra overhead.
So, if we know we are going to add an attribute immediately after
creating the inode, let's just initialise the attribute fork inside
the create transaction and chop that whole chunk of code out of
the create fast path. This completely removes the performance
drop caused by enabling SELinux, and the profile looks like:
- 8.99% xfs_init_security
- 9.00% security_inode_init_security
- 6.43% xfs_initxattrs
- 6.37% xfs_attr_set
- 5.45% xfs_attr_set_args
- 5.42% xfs_attr_set_shortform.constprop.0
- 4.51% xfs_trans_commit
- 4.54% __xfs_trans_commit
- 4.59% xfs_log_commit_cil
- 2.67% _raw_spin_lock
- 3.28% do_raw_spin_lock
3.08% __pv_queued_spin_lock_slowpath
0.66% xfs_inode_item_format
- 0.90% xfs_attr_try_sf_addname
- 0.60% xfs_trans_alloc
- 2.35% selinux_inode_init_security
- 1.25% security_sid_to_context_force
- 1.21% security_sid_to_context_core
- 1.19% sidtab_entry_to_string
- 1.20% sidtab_sid2str_get
- 0.86% sidtab_sid2str_put.part.0
- 0.62% _raw_spin_lock_irqsave
- 0.77% do_raw_spin_lock
__pv_queued_spin_lock_slowpath
- 0.84% selinux_determine_inode_label
- 0.83% security_transition_sid
0.86% security_compute_sid.part.0
Which indicates the XFS overhead of creating the selinux xattr has
been halved. This doesn't fix the CIL lock contention problem, just
means it's not a limiting factor for this workload. Lock contention
in the security subsystems is going to be an issue soon, though...
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
[djwong: fix compilation error when CONFIG_SECURITY=n]
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Gao Xiang <hsiangkao@redhat.com>
2021-03-22 16:52:03 +00:00
|
|
|
bool init_xattrs,
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_inode_t **ipp)
|
|
|
|
{
|
|
|
|
int is_dir = S_ISDIR(mode);
|
|
|
|
struct xfs_mount *mp = dp->i_mount;
|
|
|
|
struct xfs_inode *ip = NULL;
|
|
|
|
struct xfs_trans *tp = NULL;
|
|
|
|
int error;
|
|
|
|
bool unlock_dp_on_error = false;
|
|
|
|
prid_t prid;
|
|
|
|
struct xfs_dquot *udqp = NULL;
|
|
|
|
struct xfs_dquot *gdqp = NULL;
|
|
|
|
struct xfs_dquot *pdqp = NULL;
|
2014-11-28 03:00:16 +00:00
|
|
|
struct xfs_trans_res *tres;
|
2013-08-12 10:49:45 +00:00
|
|
|
uint resblks;
|
2021-06-02 00:48:24 +00:00
|
|
|
xfs_ino_t ino;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
trace_xfs_create(dp, name);
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EIO;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2013-12-18 00:22:39 +00:00
|
|
|
prid = xfs_get_initial_prid(dp);
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure that we have allocated dquot(s) on disk.
|
|
|
|
*/
|
2021-03-20 12:26:22 +00:00
|
|
|
error = xfs_qm_vop_dqalloc(dp, mapped_fsuid(mnt_userns),
|
|
|
|
mapped_fsgid(mnt_userns), prid,
|
2021-03-02 17:32:52 +00:00
|
|
|
XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
|
|
|
|
&udqp, &gdqp, &pdqp);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
if (is_dir) {
|
|
|
|
resblks = XFS_MKDIR_SPACE_RES(mp, name->len);
|
2014-11-28 03:00:16 +00:00
|
|
|
tres = &M_RES(mp)->tr_mkdir;
|
2013-08-12 10:49:45 +00:00
|
|
|
} else {
|
|
|
|
resblks = XFS_CREATE_SPACE_RES(mp, name->len);
|
2014-11-28 03:00:16 +00:00
|
|
|
tres = &M_RES(mp)->tr_create;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initially assume that the file does not exist and
|
|
|
|
* reserve the resources for that case. If that is not
|
|
|
|
* the case we'll drop the one we have and get a more
|
|
|
|
* appropriate transaction later.
|
|
|
|
*/
|
2021-01-27 20:07:57 +00:00
|
|
|
error = xfs_trans_alloc_icreate(mp, tres, udqp, gdqp, pdqp, resblks,
|
|
|
|
&tp);
|
2014-06-25 04:58:08 +00:00
|
|
|
if (error == -ENOSPC) {
|
2013-08-12 10:49:45 +00:00
|
|
|
/* flush outstanding delalloc blocks and retry */
|
|
|
|
xfs_flush_inodes(mp);
|
2021-01-27 20:07:57 +00:00
|
|
|
error = xfs_trans_alloc_icreate(mp, tres, udqp, gdqp, pdqp,
|
|
|
|
resblks, &tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
2015-06-04 03:47:56 +00:00
|
|
|
if (error)
|
2021-01-27 20:07:57 +00:00
|
|
|
goto out_release_dquots;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2016-11-30 03:33:25 +00:00
|
|
|
xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
|
2013-08-12 10:49:45 +00:00
|
|
|
unlock_dp_on_error = true;
|
|
|
|
|
2021-01-23 00:48:12 +00:00
|
|
|
error = xfs_iext_count_may_overflow(dp, XFS_DATA_FORK,
|
|
|
|
XFS_IEXT_DIR_MANIP_CNT(mp));
|
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
/*
|
|
|
|
* A newly created regular or special file just has one directory
|
|
|
|
* entry pointing to them, but a directory also the "." entry
|
|
|
|
* pointing to itself.
|
|
|
|
*/
|
2021-06-02 00:48:24 +00:00
|
|
|
error = xfs_dialloc(&tp, dp->i_ino, mode, &ino);
|
|
|
|
if (!error)
|
|
|
|
error = xfs_init_new_inode(mnt_userns, tp, dp, ino, mode,
|
|
|
|
is_dir ? 2 : 1, rdev, prid, init_xattrs, &ip);
|
2015-07-29 01:52:08 +00:00
|
|
|
if (error)
|
2015-06-04 03:47:56 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Now we join the directory inode to the transaction. We do not do it
|
2021-06-02 00:48:24 +00:00
|
|
|
* earlier because xfs_dialloc might commit the previous transaction
|
2013-08-12 10:49:45 +00:00
|
|
|
* (and release all the locks). An error from here on will result in
|
|
|
|
* the transaction cancel unlocking dp so don't do it explicitly in the
|
|
|
|
* error path.
|
|
|
|
*/
|
2016-11-30 03:33:25 +00:00
|
|
|
xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
|
2013-08-12 10:49:45 +00:00
|
|
|
unlock_dp_on_error = false;
|
|
|
|
|
2018-07-12 05:26:21 +00:00
|
|
|
error = xfs_dir_createname(tp, dp, name, ip->i_ino,
|
2020-03-27 15:28:39 +00:00
|
|
|
resblks - XFS_IALLOC_SPACE_RES(mp));
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error) {
|
2014-06-25 04:58:08 +00:00
|
|
|
ASSERT(error != -ENOSPC);
|
2015-06-04 03:47:56 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
|
|
|
|
xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
|
|
|
|
|
|
|
|
if (is_dir) {
|
|
|
|
error = xfs_dir_init(tp, ip, dp);
|
|
|
|
if (error)
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2019-05-02 03:26:30 +00:00
|
|
|
xfs_bumplink(tp, dp);
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a synchronous mount, make sure that the
|
|
|
|
* create transaction goes to disk before returning to
|
|
|
|
* the user.
|
|
|
|
*/
|
|
|
|
if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
|
|
|
|
xfs_trans_set_sync(tp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attach the dquot(s) to the inodes and modify them incore.
|
|
|
|
* These ids of the inode couldn't have changed since the new
|
|
|
|
* inode has been locked ever since it was created.
|
|
|
|
*/
|
|
|
|
xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
|
|
|
|
|
2015-06-04 03:48:08 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
|
|
|
goto out_release_inode;
|
|
|
|
|
|
|
|
xfs_qm_dqrele(udqp);
|
|
|
|
xfs_qm_dqrele(gdqp);
|
|
|
|
xfs_qm_dqrele(pdqp);
|
|
|
|
|
|
|
|
*ipp = ip;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_trans_cancel:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
out_release_inode:
|
|
|
|
/*
|
2015-02-23 11:38:08 +00:00
|
|
|
* Wait until after the current transaction is aborted to finish the
|
|
|
|
* setup of the inode and release the inode. This prevents recursive
|
|
|
|
* transactions and deadlocks from xfs_inactive.
|
2013-08-12 10:49:45 +00:00
|
|
|
*/
|
2015-02-23 11:38:08 +00:00
|
|
|
if (ip) {
|
|
|
|
xfs_finish_inode_setup(ip);
|
2018-07-25 19:52:32 +00:00
|
|
|
xfs_irele(ip);
|
2015-02-23 11:38:08 +00:00
|
|
|
}
|
2021-01-27 20:07:57 +00:00
|
|
|
out_release_dquots:
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_qm_dqrele(udqp);
|
|
|
|
xfs_qm_dqrele(gdqp);
|
|
|
|
xfs_qm_dqrele(pdqp);
|
|
|
|
|
|
|
|
if (unlock_dp_on_error)
|
2016-11-30 03:33:25 +00:00
|
|
|
xfs_iunlock(dp, XFS_ILOCK_EXCL);
|
2013-08-12 10:49:45 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2013-12-18 00:22:40 +00:00
|
|
|
int
|
|
|
|
xfs_create_tmpfile(
|
2021-01-21 13:19:58 +00:00
|
|
|
struct user_namespace *mnt_userns,
|
2013-12-18 00:22:40 +00:00
|
|
|
struct xfs_inode *dp,
|
2014-04-16 22:15:30 +00:00
|
|
|
umode_t mode,
|
|
|
|
struct xfs_inode **ipp)
|
2013-12-18 00:22:40 +00:00
|
|
|
{
|
|
|
|
struct xfs_mount *mp = dp->i_mount;
|
|
|
|
struct xfs_inode *ip = NULL;
|
|
|
|
struct xfs_trans *tp = NULL;
|
|
|
|
int error;
|
|
|
|
prid_t prid;
|
|
|
|
struct xfs_dquot *udqp = NULL;
|
|
|
|
struct xfs_dquot *gdqp = NULL;
|
|
|
|
struct xfs_dquot *pdqp = NULL;
|
|
|
|
struct xfs_trans_res *tres;
|
|
|
|
uint resblks;
|
2021-06-02 00:48:24 +00:00
|
|
|
xfs_ino_t ino;
|
2013-12-18 00:22:40 +00:00
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EIO;
|
2013-12-18 00:22:40 +00:00
|
|
|
|
|
|
|
prid = xfs_get_initial_prid(dp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure that we have allocated dquot(s) on disk.
|
|
|
|
*/
|
2021-03-20 12:26:22 +00:00
|
|
|
error = xfs_qm_vop_dqalloc(dp, mapped_fsuid(mnt_userns),
|
|
|
|
mapped_fsgid(mnt_userns), prid,
|
2021-03-02 17:32:52 +00:00
|
|
|
XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
|
|
|
|
&udqp, &gdqp, &pdqp);
|
2013-12-18 00:22:40 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
resblks = XFS_IALLOC_SPACE_RES(mp);
|
|
|
|
tres = &M_RES(mp)->tr_create_tmpfile;
|
2016-04-05 23:19:55 +00:00
|
|
|
|
2021-01-27 20:07:57 +00:00
|
|
|
error = xfs_trans_alloc_icreate(mp, tres, udqp, gdqp, pdqp, resblks,
|
|
|
|
&tp);
|
2013-12-18 00:22:40 +00:00
|
|
|
if (error)
|
2021-01-27 20:07:57 +00:00
|
|
|
goto out_release_dquots;
|
2013-12-18 00:22:40 +00:00
|
|
|
|
2021-06-02 00:48:24 +00:00
|
|
|
error = xfs_dialloc(&tp, dp->i_ino, mode, &ino);
|
|
|
|
if (!error)
|
|
|
|
error = xfs_init_new_inode(mnt_userns, tp, dp, ino, mode,
|
|
|
|
0, 0, prid, false, &ip);
|
2015-07-29 01:52:08 +00:00
|
|
|
if (error)
|
2015-06-04 03:47:56 +00:00
|
|
|
goto out_trans_cancel;
|
2013-12-18 00:22:40 +00:00
|
|
|
|
|
|
|
if (mp->m_flags & XFS_MOUNT_WSYNC)
|
|
|
|
xfs_trans_set_sync(tp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attach the dquot(s) to the inodes and modify them incore.
|
|
|
|
* These ids of the inode couldn't have changed since the new
|
|
|
|
* inode has been locked ever since it was created.
|
|
|
|
*/
|
|
|
|
xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
|
|
|
|
|
|
|
|
error = xfs_iunlink(tp, ip);
|
|
|
|
if (error)
|
2015-06-04 03:47:56 +00:00
|
|
|
goto out_trans_cancel;
|
2013-12-18 00:22:40 +00:00
|
|
|
|
2015-06-04 03:48:08 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
2013-12-18 00:22:40 +00:00
|
|
|
if (error)
|
|
|
|
goto out_release_inode;
|
|
|
|
|
|
|
|
xfs_qm_dqrele(udqp);
|
|
|
|
xfs_qm_dqrele(gdqp);
|
|
|
|
xfs_qm_dqrele(pdqp);
|
|
|
|
|
2014-04-16 22:15:30 +00:00
|
|
|
*ipp = ip;
|
2013-12-18 00:22:40 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_trans_cancel:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2013-12-18 00:22:40 +00:00
|
|
|
out_release_inode:
|
|
|
|
/*
|
2015-02-23 11:38:08 +00:00
|
|
|
* Wait until after the current transaction is aborted to finish the
|
|
|
|
* setup of the inode and release the inode. This prevents recursive
|
|
|
|
* transactions and deadlocks from xfs_inactive.
|
2013-12-18 00:22:40 +00:00
|
|
|
*/
|
2015-02-23 11:38:08 +00:00
|
|
|
if (ip) {
|
|
|
|
xfs_finish_inode_setup(ip);
|
2018-07-25 19:52:32 +00:00
|
|
|
xfs_irele(ip);
|
2015-02-23 11:38:08 +00:00
|
|
|
}
|
2021-01-27 20:07:57 +00:00
|
|
|
out_release_dquots:
|
2013-12-18 00:22:40 +00:00
|
|
|
xfs_qm_dqrele(udqp);
|
|
|
|
xfs_qm_dqrele(gdqp);
|
|
|
|
xfs_qm_dqrele(pdqp);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
int
|
|
|
|
xfs_link(
|
|
|
|
xfs_inode_t *tdp,
|
|
|
|
xfs_inode_t *sip,
|
|
|
|
struct xfs_name *target_name)
|
|
|
|
{
|
|
|
|
xfs_mount_t *mp = tdp->i_mount;
|
|
|
|
xfs_trans_t *tp;
|
|
|
|
int error;
|
|
|
|
int resblks;
|
|
|
|
|
|
|
|
trace_xfs_link(tdp, target_name);
|
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
ASSERT(!S_ISDIR(VFS_I(sip)->i_mode));
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EIO;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2018-05-04 22:30:21 +00:00
|
|
|
error = xfs_qm_dqattach(sip);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
|
|
|
goto std_return;
|
|
|
|
|
2018-05-04 22:30:21 +00:00
|
|
|
error = xfs_qm_dqattach(tdp);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
|
|
|
goto std_return;
|
|
|
|
|
|
|
|
resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
|
2016-04-05 23:19:55 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, resblks, 0, 0, &tp);
|
2014-06-25 04:58:08 +00:00
|
|
|
if (error == -ENOSPC) {
|
2013-08-12 10:49:45 +00:00
|
|
|
resblks = 0;
|
2016-04-05 23:19:55 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, 0, 0, 0, &tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
2015-06-04 03:47:56 +00:00
|
|
|
if (error)
|
2016-04-05 23:19:55 +00:00
|
|
|
goto std_return;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2018-01-26 23:27:33 +00:00
|
|
|
xfs_lock_two_inodes(sip, XFS_ILOCK_EXCL, tdp, XFS_ILOCK_EXCL);
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
|
2016-11-30 03:33:25 +00:00
|
|
|
xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-01-23 00:48:12 +00:00
|
|
|
error = xfs_iext_count_may_overflow(tdp, XFS_DATA_FORK,
|
|
|
|
XFS_IEXT_DIR_MANIP_CNT(mp));
|
|
|
|
if (error)
|
|
|
|
goto error_return;
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
/*
|
|
|
|
* If we are using project inheritance, we only allow hard link
|
|
|
|
* creation in our tree when the project IDs are the same; else
|
|
|
|
* the tree quota mechanism could be circumvented.
|
|
|
|
*/
|
2021-03-29 18:11:44 +00:00
|
|
|
if (unlikely((tdp->i_diflags & XFS_DIFLAG_PROJINHERIT) &&
|
2021-03-29 18:11:39 +00:00
|
|
|
tdp->i_projid != sip->i_projid)) {
|
2014-06-25 04:58:08 +00:00
|
|
|
error = -EXDEV;
|
2013-08-12 10:49:45 +00:00
|
|
|
goto error_return;
|
|
|
|
}
|
|
|
|
|
2014-09-09 01:57:52 +00:00
|
|
|
if (!resblks) {
|
|
|
|
error = xfs_dir_canenter(tp, tdp, target_name);
|
|
|
|
if (error)
|
|
|
|
goto error_return;
|
|
|
|
}
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
/*
|
|
|
|
* Handle initial link state of O_TMPFILE inode
|
|
|
|
*/
|
|
|
|
if (VFS_I(sip)->i_nlink == 0) {
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_perag *pag;
|
|
|
|
|
|
|
|
pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, sip->i_ino));
|
|
|
|
error = xfs_iunlink_remove(tp, pag, sip);
|
|
|
|
xfs_perag_put(pag);
|
2013-12-18 00:22:41 +00:00
|
|
|
if (error)
|
2015-06-04 03:47:56 +00:00
|
|
|
goto error_return;
|
2013-12-18 00:22:41 +00:00
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
|
2018-07-12 05:26:21 +00:00
|
|
|
resblks);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
2015-06-04 03:47:56 +00:00
|
|
|
goto error_return;
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
|
|
|
|
xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
|
|
|
|
|
2019-05-02 03:26:30 +00:00
|
|
|
xfs_bumplink(tp, sip);
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a synchronous mount, make sure that the
|
|
|
|
* link transaction goes to disk before returning to
|
|
|
|
* the user.
|
|
|
|
*/
|
xfs: eliminate committed arg from xfs_bmap_finish
Calls to xfs_bmap_finish() and xfs_trans_ijoin(), and the
associated comments were replicated several times across
the attribute code, all dealing with what to do if the
transaction was or wasn't committed.
And in that replicated code, an ASSERT() test of an
uninitialized variable occurs in several locations:
error = xfs_attr_thing(&args);
if (!error) {
error = xfs_bmap_finish(&args.trans, args.flist,
&committed);
}
if (error) {
ASSERT(committed);
If the first xfs_attr_thing() failed, we'd skip the xfs_bmap_finish,
never set "committed", and then test it in the ASSERT.
Fix this up by moving the committed state internal to xfs_bmap_finish,
and add a new inode argument. If an inode is passed in, it is passed
through to __xfs_trans_roll() and joined to the transaction there if
the transaction was committed.
xfs_qm_dqalloc() was a little unique in that it called bjoin rather
than ijoin, but as Dave points out we can detect the committed state
but checking whether (*tpp != tp).
Addresses-Coverity-Id: 102360
Addresses-Coverity-Id: 102361
Addresses-Coverity-Id: 102363
Addresses-Coverity-Id: 102364
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-01-11 00:34:01 +00:00
|
|
|
if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_trans_set_sync(tp);
|
|
|
|
|
2015-06-04 03:48:08 +00:00
|
|
|
return xfs_trans_commit(tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
error_return:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
std_return:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-12-14 23:42:59 +00:00
|
|
|
/* Clear the reflink flag and the cowblocks tag if possible. */
|
|
|
|
static void
|
|
|
|
xfs_itruncate_clear_reflink_flags(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
struct xfs_ifork *dfork;
|
|
|
|
struct xfs_ifork *cfork;
|
|
|
|
|
|
|
|
if (!xfs_is_reflink_inode(ip))
|
|
|
|
return;
|
|
|
|
dfork = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
|
|
|
|
cfork = XFS_IFORK_PTR(ip, XFS_COW_FORK);
|
|
|
|
if (dfork->if_bytes == 0 && cfork->if_bytes == 0)
|
2021-03-29 18:11:45 +00:00
|
|
|
ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
|
2017-12-14 23:42:59 +00:00
|
|
|
if (cfork->if_bytes == 0)
|
|
|
|
xfs_inode_clear_cowblocks_tag(ip);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2011-07-08 12:34:34 +00:00
|
|
|
* Free up the underlying blocks past new_size. The new size must be smaller
|
|
|
|
* than the current size. This routine can be used both for the attribute and
|
|
|
|
* data fork, and does not modify the inode size, which is left to the caller.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-04-17 06:50:04 +00:00
|
|
|
* The transaction passed to this routine must have made a permanent log
|
|
|
|
* reservation of at least XFS_ITRUNCATE_LOG_RES. This routine may commit the
|
|
|
|
* given transaction and start new ones, so make sure everything involved in
|
|
|
|
* the transaction is tidy before calling here. Some transaction will be
|
|
|
|
* returned to the caller to be committed. The incoming transaction must
|
|
|
|
* already include the inode, and both inode locks must be held exclusively.
|
|
|
|
* The inode must also be "held" within the transaction. On return the inode
|
|
|
|
* will be "held" within the returned transaction. This routine does NOT
|
|
|
|
* require any disk space to be reserved for it within the transaction.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-04-17 06:50:04 +00:00
|
|
|
* If we get an error, we must return with the inode locked and linked into the
|
|
|
|
* current transaction. This keeps things simple for the higher level code,
|
|
|
|
* because it always knows that the inode is locked and held in the transaction
|
|
|
|
* that returns to it whether errors occur or not. We don't mark the inode
|
|
|
|
* dirty on error so that transactions can be easily aborted if possible.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
int
|
2018-05-10 16:35:42 +00:00
|
|
|
xfs_itruncate_extents_flags(
|
2011-07-08 12:34:34 +00:00
|
|
|
struct xfs_trans **tpp,
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
int whichfork,
|
2018-05-09 15:45:04 +00:00
|
|
|
xfs_fsize_t new_size,
|
2018-05-10 16:35:42 +00:00
|
|
|
int flags)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-07-08 12:34:34 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_trans *tp = *tpp;
|
|
|
|
xfs_fileoff_t first_unmap_block;
|
|
|
|
xfs_filblks_t unmap_len;
|
|
|
|
int error = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-07-04 15:13:31 +00:00
|
|
|
ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
|
|
|
|
ASSERT(!atomic_read(&VFS_I(ip)->i_count) ||
|
|
|
|
xfs_isilocked(ip, XFS_IOLOCK_EXCL));
|
2011-12-18 20:00:11 +00:00
|
|
|
ASSERT(new_size <= XFS_ISIZE(ip));
|
2011-07-08 12:34:34 +00:00
|
|
|
ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
|
2005-04-16 22:20:36 +00:00
|
|
|
ASSERT(ip->i_itemp != NULL);
|
2010-06-24 01:36:58 +00:00
|
|
|
ASSERT(ip->i_itemp->ili_lock_flags == 0);
|
2011-07-08 12:34:34 +00:00
|
|
|
ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-12-18 20:00:04 +00:00
|
|
|
trace_xfs_itruncate_extents_start(ip, new_size);
|
|
|
|
|
2018-05-10 16:35:42 +00:00
|
|
|
flags |= xfs_bmapi_aflag(whichfork);
|
2018-05-09 15:45:04 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Since it is possible for space to become allocated beyond
|
|
|
|
* the end of the file (in a crash where the space is allocated
|
|
|
|
* but the inode size is not yet updated), simply remove any
|
|
|
|
* blocks which show up between the new EOF and the maximum
|
2020-01-02 21:20:13 +00:00
|
|
|
* possible file size.
|
|
|
|
*
|
|
|
|
* We have to free all the blocks to the bmbt maximum offset, even if
|
|
|
|
* the page cache can't scale that far.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2011-07-08 12:34:34 +00:00
|
|
|
first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
|
2020-12-04 21:28:35 +00:00
|
|
|
if (!xfs_verify_fileoff(mp, first_unmap_block)) {
|
2020-01-02 21:20:13 +00:00
|
|
|
WARN_ON_ONCE(first_unmap_block > XFS_MAX_FILEOFF);
|
2011-07-08 12:34:34 +00:00
|
|
|
return 0;
|
2020-01-02 21:20:13 +00:00
|
|
|
}
|
2011-07-08 12:34:34 +00:00
|
|
|
|
2020-01-02 21:20:13 +00:00
|
|
|
unmap_len = XFS_MAX_FILEOFF - first_unmap_block + 1;
|
|
|
|
while (unmap_len > 0) {
|
2018-07-24 20:43:07 +00:00
|
|
|
ASSERT(tp->t_firstblock == NULLFSBLOCK);
|
2020-01-02 21:20:13 +00:00
|
|
|
error = __xfs_bunmapi(tp, ip, first_unmap_block, &unmap_len,
|
|
|
|
flags, XFS_ITRUNC_MAX_EXTENTS);
|
2011-07-08 12:34:34 +00:00
|
|
|
if (error)
|
2018-09-29 03:41:58 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-09-16 03:44:46 +00:00
|
|
|
/* free the just unmapped extents */
|
2018-07-24 20:43:15 +00:00
|
|
|
error = xfs_defer_finish(&tp);
|
2011-07-08 12:34:34 +00:00
|
|
|
if (error)
|
2018-08-01 14:20:33 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2011-07-08 12:34:34 +00:00
|
|
|
|
2018-04-10 15:28:33 +00:00
|
|
|
if (whichfork == XFS_DATA_FORK) {
|
|
|
|
/* Remove all pending CoW reservations. */
|
|
|
|
error = xfs_reflink_cancel_cow_blocks(ip, &tp,
|
2020-01-02 21:20:13 +00:00
|
|
|
first_unmap_block, XFS_MAX_FILEOFF, true);
|
2018-04-10 15:28:33 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2016-10-03 16:11:38 +00:00
|
|
|
|
2018-04-10 15:28:33 +00:00
|
|
|
xfs_itruncate_clear_reflink_flags(ip);
|
|
|
|
}
|
2016-10-03 16:11:38 +00:00
|
|
|
|
2011-12-18 20:00:04 +00:00
|
|
|
/*
|
|
|
|
* Always re-log the inode so that our permanent transaction can keep
|
|
|
|
* on rolling it forward in the log.
|
|
|
|
*/
|
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
|
|
|
|
trace_xfs_itruncate_extents_end(ip, new_size);
|
|
|
|
|
2011-07-08 12:34:34 +00:00
|
|
|
out:
|
|
|
|
*tpp = tp;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
int
|
|
|
|
xfs_release(
|
|
|
|
xfs_inode_t *ip)
|
|
|
|
{
|
|
|
|
xfs_mount_t *mp = ip->i_mount;
|
2021-03-23 23:59:31 +00:00
|
|
|
int error = 0;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
if (!S_ISREG(VFS_I(ip)->i_mode) || (VFS_I(ip)->i_mode == 0))
|
2013-08-12 10:49:45 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* If this is a read-only mount, don't do this (would generate I/O) */
|
|
|
|
if (mp->m_flags & XFS_MOUNT_RDONLY)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!XFS_FORCED_SHUTDOWN(mp)) {
|
|
|
|
int truncated;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we previously truncated this file and removed old data
|
|
|
|
* in the process, we want to initiate "early" writeout on
|
|
|
|
* the last close. This is an attempt to combat the notorious
|
|
|
|
* NULL files problem which is particularly noticeable from a
|
|
|
|
* truncate down, buffered (re-)write (delalloc), followed by
|
|
|
|
* a crash. What we are effectively doing here is
|
|
|
|
* significantly reducing the time window where we'd otherwise
|
|
|
|
* be exposed to that problem.
|
|
|
|
*/
|
|
|
|
truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
|
|
|
|
if (truncated) {
|
|
|
|
xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
|
2014-08-04 03:22:49 +00:00
|
|
|
if (ip->i_delayed_blks > 0) {
|
2014-06-25 04:58:08 +00:00
|
|
|
error = filemap_flush(VFS_I(ip)->i_mapping);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
if (VFS_I(ip)->i_nlink == 0)
|
2013-08-12 10:49:45 +00:00
|
|
|
return 0;
|
|
|
|
|
2021-03-23 23:59:31 +00:00
|
|
|
/*
|
|
|
|
* If we can't get the iolock just skip truncating the blocks past EOF
|
|
|
|
* because we could deadlock with the mmap_lock otherwise. We'll get
|
|
|
|
* another chance to drop them once the last reference to the inode is
|
|
|
|
* dropped, so we'll never leak blocks permanently.
|
|
|
|
*/
|
|
|
|
if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL))
|
|
|
|
return 0;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-03-23 23:59:31 +00:00
|
|
|
if (xfs_can_free_eofblocks(ip, false)) {
|
2017-01-28 07:22:55 +00:00
|
|
|
/*
|
|
|
|
* Check if the inode is being opened, written and closed
|
|
|
|
* frequently and we have delayed allocation blocks outstanding
|
|
|
|
* (e.g. streaming writes from the NFS server), truncating the
|
|
|
|
* blocks past EOF will cause fragmentation to occur.
|
|
|
|
*
|
|
|
|
* In this case don't do the truncation, but we have to be
|
|
|
|
* careful how we detect this case. Blocks beyond EOF show up as
|
|
|
|
* i_delayed_blks even when the inode is clean, so we need to
|
|
|
|
* truncate them away first before checking for a dirty release.
|
|
|
|
* Hence on the first dirty close we will still remove the
|
|
|
|
* speculative allocation, but after that we will leave it in
|
|
|
|
* place.
|
|
|
|
*/
|
|
|
|
if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
|
2021-03-23 23:59:31 +00:00
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
error = xfs_free_eofblocks(ip);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/* delalloc blocks after truncation means it really is dirty */
|
|
|
|
if (ip->i_delayed_blks)
|
|
|
|
xfs_iflags_set(ip, XFS_IDIRTY_RELEASE);
|
|
|
|
}
|
2021-03-23 23:59:31 +00:00
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
xfs_iunlock(ip, XFS_IOLOCK_EXCL);
|
|
|
|
return error;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
2013-09-20 15:06:10 +00:00
|
|
|
/*
|
|
|
|
* xfs_inactive_truncate
|
|
|
|
*
|
|
|
|
* Called to perform a truncate when an inode becomes unlinked.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_inactive_truncate(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
int error;
|
|
|
|
|
2016-04-05 23:19:55 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
|
2013-09-20 15:06:10 +00:00
|
|
|
if (error) {
|
|
|
|
ASSERT(XFS_FORCED_SHUTDOWN(mp));
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ijoin(tp, ip, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Log the inode size first to prevent stale data exposure in the event
|
|
|
|
* of a system crash before the truncate completes. See the related
|
2016-05-26 12:46:43 +00:00
|
|
|
* comment in xfs_vn_setattr_size() for details.
|
2013-09-20 15:06:10 +00:00
|
|
|
*/
|
2021-03-29 18:11:40 +00:00
|
|
|
ip->i_disk_size = 0;
|
2013-09-20 15:06:10 +00:00
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
|
|
|
|
error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
|
|
|
|
if (error)
|
|
|
|
goto error_trans_cancel;
|
|
|
|
|
2020-05-18 17:27:22 +00:00
|
|
|
ASSERT(ip->i_df.if_nextents == 0);
|
2013-09-20 15:06:10 +00:00
|
|
|
|
2015-06-04 03:48:08 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
2013-09-20 15:06:10 +00:00
|
|
|
if (error)
|
|
|
|
goto error_unlock;
|
|
|
|
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_trans_cancel:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2013-09-20 15:06:10 +00:00
|
|
|
error_unlock:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2013-09-20 15:06:11 +00:00
|
|
|
/*
|
|
|
|
* xfs_inactive_ifree()
|
|
|
|
*
|
|
|
|
* Perform the inode free when an inode is unlinked.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_inactive_ifree(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
int error;
|
|
|
|
|
2014-04-24 06:00:52 +00:00
|
|
|
/*
|
2017-01-25 15:49:35 +00:00
|
|
|
* We try to use a per-AG reservation for any block needed by the finobt
|
|
|
|
* tree, but as the finobt feature predates the per-AG reservation
|
|
|
|
* support a degraded file system might not have enough space for the
|
|
|
|
* reservation at mount time. In that case try to dip into the reserved
|
|
|
|
* pool and pray.
|
2014-04-24 06:00:52 +00:00
|
|
|
*
|
|
|
|
* Send a warning if the reservation does happen to fail, as the inode
|
|
|
|
* now remains allocated and sits on the unlinked list until the fs is
|
|
|
|
* repaired.
|
|
|
|
*/
|
2019-02-14 17:33:15 +00:00
|
|
|
if (unlikely(mp->m_finobt_nores)) {
|
2017-01-25 15:49:35 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree,
|
|
|
|
XFS_IFREE_SPACE_RES(mp), 0, XFS_TRANS_RESERVE,
|
|
|
|
&tp);
|
|
|
|
} else {
|
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree, 0, 0, 0, &tp);
|
|
|
|
}
|
2013-09-20 15:06:11 +00:00
|
|
|
if (error) {
|
2014-06-25 04:58:08 +00:00
|
|
|
if (error == -ENOSPC) {
|
2014-04-24 06:00:52 +00:00
|
|
|
xfs_warn_ratelimited(mp,
|
|
|
|
"Failed to remove inode(s) from unlinked list. "
|
|
|
|
"Please free space, unmount and run xfs_repair.");
|
|
|
|
} else {
|
|
|
|
ASSERT(XFS_FORCED_SHUTDOWN(mp));
|
|
|
|
}
|
2013-09-20 15:06:11 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
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-29 21:48:45 +00:00
|
|
|
/*
|
|
|
|
* We do not hold the inode locked across the entire rolling transaction
|
|
|
|
* here. We only need to hold it for the first transaction that
|
|
|
|
* xfs_ifree() builds, which may mark the inode XFS_ISTALE if the
|
|
|
|
* underlying cluster buffer is freed. Relogging an XFS_ISTALE inode
|
|
|
|
* here breaks the relationship between cluster buffer invalidation and
|
|
|
|
* stale inode invalidation on cluster buffer item journal commit
|
|
|
|
* completion, and can result in leaving dirty stale inodes hanging
|
|
|
|
* around in memory.
|
|
|
|
*
|
|
|
|
* We have no need for serialising this inode operation against other
|
|
|
|
* operations - we freed the inode and hence reallocation is required
|
|
|
|
* and that will serialise on reallocating the space the deferops need
|
|
|
|
* to free. Hence we can unlock the inode on the first commit of
|
|
|
|
* the transaction rather than roll it right through the deferops. This
|
|
|
|
* avoids relogging the XFS_ISTALE inode.
|
|
|
|
*
|
|
|
|
* We check that xfs_ifree() hasn't grown an internal transaction roll
|
|
|
|
* by asserting that the inode is still locked when it returns.
|
|
|
|
*/
|
2013-09-20 15:06:11 +00:00
|
|
|
xfs_ilock(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-29 21:48:45 +00:00
|
|
|
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
|
2013-09-20 15:06:11 +00:00
|
|
|
|
2018-07-12 05:26:07 +00:00
|
|
|
error = xfs_ifree(tp, ip);
|
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-29 21:48:45 +00:00
|
|
|
ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
|
2013-09-20 15:06:11 +00:00
|
|
|
if (error) {
|
|
|
|
/*
|
|
|
|
* If we fail to free the inode, shut down. The cancel
|
|
|
|
* might do that, we need to make sure. Otherwise the
|
|
|
|
* inode might be lost for a long time or forever.
|
|
|
|
*/
|
|
|
|
if (!XFS_FORCED_SHUTDOWN(mp)) {
|
|
|
|
xfs_notice(mp, "%s: xfs_ifree returned error %d",
|
|
|
|
__func__, error);
|
|
|
|
xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
|
|
|
|
}
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2013-09-20 15:06:11 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Credit the quota account(s). The inode is gone.
|
|
|
|
*/
|
|
|
|
xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
|
|
|
|
|
|
|
|
/*
|
2015-08-19 00:01:40 +00:00
|
|
|
* Just ignore errors at this point. There is nothing we can do except
|
|
|
|
* to try to keep going. Make sure it's not a silent error.
|
2013-09-20 15:06:11 +00:00
|
|
|
*/
|
2015-06-04 03:48:08 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
2013-09-20 15:06:11 +00:00
|
|
|
if (error)
|
|
|
|
xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
|
|
|
|
__func__, error);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-08-06 18:05:39 +00:00
|
|
|
/*
|
|
|
|
* Returns true if we need to update the on-disk metadata before we can free
|
|
|
|
* the memory used by this inode. Updates include freeing post-eof
|
|
|
|
* preallocations; freeing COW staging extents; and marking the inode free in
|
|
|
|
* the inobt if it is on the unlinked list.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
xfs_inode_needs_inactive(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_ifork *cow_ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the inode is already free, then there can be nothing
|
|
|
|
* to clean up here.
|
|
|
|
*/
|
|
|
|
if (VFS_I(ip)->i_mode == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* If this is a read-only mount, don't do this (would generate I/O) */
|
|
|
|
if (mp->m_flags & XFS_MOUNT_RDONLY)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* If the log isn't running, push inodes straight to reclaim. */
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp) || (mp->m_flags & XFS_MOUNT_NORECOVERY))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Metadata inodes require explicit resource cleanup. */
|
|
|
|
if (xfs_is_metadata_inode(ip))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Want to clean out the cow blocks if there are any. */
|
|
|
|
if (cow_ifp && cow_ifp->if_bytes > 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* Unlinked files must be freed. */
|
|
|
|
if (VFS_I(ip)->i_nlink == 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This file isn't being freed, so check if there are post-eof blocks
|
|
|
|
* to free. @force is true because we are evicting an inode from the
|
|
|
|
* cache. Post-eof blocks must be freed, lest we end up with broken
|
|
|
|
* free space accounting.
|
|
|
|
*
|
|
|
|
* Note: don't bother with iolock here since lockdep complains about
|
|
|
|
* acquiring it in reclaim context. We have the only reference to the
|
|
|
|
* inode at this point anyways.
|
|
|
|
*/
|
|
|
|
return xfs_can_free_eofblocks(ip, true);
|
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
/*
|
|
|
|
* xfs_inactive
|
|
|
|
*
|
|
|
|
* This is called when the vnode reference count for the vnode
|
|
|
|
* goes to zero. If the file has been unlinked, then it must
|
|
|
|
* now be truncated. Also, we clear all of the read-ahead state
|
|
|
|
* kept for the inode here since the file is now closed.
|
|
|
|
*/
|
2013-09-20 15:06:12 +00:00
|
|
|
void
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_inactive(
|
|
|
|
xfs_inode_t *ip)
|
|
|
|
{
|
2013-08-12 10:49:59 +00:00
|
|
|
struct xfs_mount *mp;
|
|
|
|
int error;
|
|
|
|
int truncate = 0;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the inode is already free, then there can be nothing
|
|
|
|
* to clean up here.
|
|
|
|
*/
|
2016-02-09 05:54:58 +00:00
|
|
|
if (VFS_I(ip)->i_mode == 0) {
|
2013-08-12 10:49:45 +00:00
|
|
|
ASSERT(ip->i_df.if_broot_bytes == 0);
|
2021-05-31 18:31:57 +00:00
|
|
|
goto out;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mp = ip->i_mount;
|
2016-10-03 16:11:29 +00:00
|
|
|
ASSERT(!xfs_iflags_test(ip, XFS_IRECOVERY));
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/* If this is a read-only mount, don't do this (would generate I/O) */
|
|
|
|
if (mp->m_flags & XFS_MOUNT_RDONLY)
|
2021-05-31 18:31:57 +00:00
|
|
|
goto out;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-03-22 16:51:54 +00:00
|
|
|
/* Metadata inodes require explicit resource cleanup. */
|
|
|
|
if (xfs_is_metadata_inode(ip))
|
2021-05-31 18:31:57 +00:00
|
|
|
goto out;
|
2021-03-22 16:51:54 +00:00
|
|
|
|
2018-03-07 01:08:31 +00:00
|
|
|
/* Try to clean out the cow blocks if there are any. */
|
2018-07-17 23:51:51 +00:00
|
|
|
if (xfs_inode_has_cow_data(ip))
|
2018-03-07 01:08:31 +00:00
|
|
|
xfs_reflink_cancel_cow_range(ip, 0, NULLFILEOFF, true);
|
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
if (VFS_I(ip)->i_nlink != 0) {
|
2013-08-12 10:49:45 +00:00
|
|
|
/*
|
|
|
|
* force is true because we are evicting an inode from the
|
|
|
|
* cache. Post-eof blocks must be freed, lest we end up with
|
|
|
|
* broken free space accounting.
|
2017-04-11 17:50:05 +00:00
|
|
|
*
|
|
|
|
* Note: don't bother with iolock here since lockdep complains
|
|
|
|
* about acquiring it in reclaim context. We have the only
|
|
|
|
* reference to the inode at this point anyways.
|
2013-08-12 10:49:45 +00:00
|
|
|
*/
|
2017-04-11 17:50:05 +00:00
|
|
|
if (xfs_can_free_eofblocks(ip, true))
|
2017-01-28 07:22:55 +00:00
|
|
|
xfs_free_eofblocks(ip);
|
2013-09-20 15:06:12 +00:00
|
|
|
|
2021-05-31 18:31:57 +00:00
|
|
|
goto out;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
if (S_ISREG(VFS_I(ip)->i_mode) &&
|
2021-03-29 18:11:40 +00:00
|
|
|
(ip->i_disk_size != 0 || XFS_ISIZE(ip) != 0 ||
|
2020-05-18 17:27:22 +00:00
|
|
|
ip->i_df.if_nextents > 0 || ip->i_delayed_blks > 0))
|
2013-08-12 10:49:45 +00:00
|
|
|
truncate = 1;
|
|
|
|
|
2018-05-04 22:30:21 +00:00
|
|
|
error = xfs_qm_dqattach(ip);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
2021-05-31 18:31:57 +00:00
|
|
|
goto out;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
if (S_ISLNK(VFS_I(ip)->i_mode))
|
2013-09-20 15:06:09 +00:00
|
|
|
error = xfs_inactive_symlink(ip);
|
2013-09-20 15:06:10 +00:00
|
|
|
else if (truncate)
|
|
|
|
error = xfs_inactive_truncate(ip);
|
|
|
|
if (error)
|
2021-05-31 18:31:57 +00:00
|
|
|
goto out;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are attributes associated with the file then blow them away
|
|
|
|
* now. The code calls a routine that recursively deconstructs the
|
2015-05-28 21:40:08 +00:00
|
|
|
* attribute fork. If also blows away the in-core attribute fork.
|
2013-08-12 10:49:45 +00:00
|
|
|
*/
|
2015-05-28 21:40:08 +00:00
|
|
|
if (XFS_IFORK_Q(ip)) {
|
2013-08-12 10:49:45 +00:00
|
|
|
error = xfs_attr_inactive(ip);
|
|
|
|
if (error)
|
2021-05-31 18:31:57 +00:00
|
|
|
goto out;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
2015-05-28 21:40:08 +00:00
|
|
|
ASSERT(!ip->i_afp);
|
2021-03-29 18:11:44 +00:00
|
|
|
ASSERT(ip->i_forkoff == 0);
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Free the inode.
|
|
|
|
*/
|
2021-05-31 18:31:57 +00:00
|
|
|
xfs_inactive_ifree(ip);
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-05-31 18:31:57 +00:00
|
|
|
out:
|
2013-08-12 10:49:45 +00:00
|
|
|
/*
|
2021-05-31 18:31:57 +00:00
|
|
|
* We're done making metadata updates for this inode, so we can release
|
|
|
|
* the attached dquots.
|
2013-08-12 10:49:45 +00:00
|
|
|
*/
|
|
|
|
xfs_qm_dqdetach(ip);
|
|
|
|
}
|
|
|
|
|
2019-02-07 18:37:16 +00:00
|
|
|
/*
|
|
|
|
* In-Core Unlinked List Lookups
|
|
|
|
* =============================
|
|
|
|
*
|
|
|
|
* Every inode is supposed to be reachable from some other piece of metadata
|
|
|
|
* with the exception of the root directory. Inodes with a connection to a
|
|
|
|
* file descriptor but not linked from anywhere in the on-disk directory tree
|
|
|
|
* are collectively known as unlinked inodes, though the filesystem itself
|
|
|
|
* maintains links to these inodes so that on-disk metadata are consistent.
|
|
|
|
*
|
|
|
|
* XFS implements a per-AG on-disk hash table of unlinked inodes. The AGI
|
|
|
|
* header contains a number of buckets that point to an inode, and each inode
|
|
|
|
* record has a pointer to the next inode in the hash chain. This
|
|
|
|
* singly-linked list causes scaling problems in the iunlink remove function
|
|
|
|
* because we must walk that list to find the inode that points to the inode
|
|
|
|
* being removed from the unlinked hash bucket list.
|
|
|
|
*
|
|
|
|
* What if we modelled the unlinked list as a collection of records capturing
|
|
|
|
* "X.next_unlinked = Y" relations? If we indexed those records on Y, we'd
|
|
|
|
* have a fast way to look up unlinked list predecessors, which avoids the
|
|
|
|
* slow list walk. That's exactly what we do here (in-core) with a per-AG
|
|
|
|
* rhashtable.
|
|
|
|
*
|
|
|
|
* Because this is a backref cache, we ignore operational failures since the
|
|
|
|
* iunlink code can fall back to the slow bucket walk. The only errors that
|
|
|
|
* should bubble out are for obviously incorrect situations.
|
|
|
|
*
|
|
|
|
* All users of the backref cache MUST hold the AGI buffer lock to serialize
|
|
|
|
* access or have otherwise provided for concurrency control.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Capture a "X.next_unlinked = Y" relationship. */
|
|
|
|
struct xfs_iunlink {
|
|
|
|
struct rhash_head iu_rhash_head;
|
|
|
|
xfs_agino_t iu_agino; /* X */
|
|
|
|
xfs_agino_t iu_next_unlinked; /* Y */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Unlinked list predecessor lookup hashtable construction */
|
|
|
|
static int
|
|
|
|
xfs_iunlink_obj_cmpfn(
|
|
|
|
struct rhashtable_compare_arg *arg,
|
|
|
|
const void *obj)
|
|
|
|
{
|
|
|
|
const xfs_agino_t *key = arg->key;
|
|
|
|
const struct xfs_iunlink *iu = obj;
|
|
|
|
|
|
|
|
if (iu->iu_next_unlinked != *key)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct rhashtable_params xfs_iunlink_hash_params = {
|
|
|
|
.min_size = XFS_AGI_UNLINKED_BUCKETS,
|
|
|
|
.key_len = sizeof(xfs_agino_t),
|
|
|
|
.key_offset = offsetof(struct xfs_iunlink,
|
|
|
|
iu_next_unlinked),
|
|
|
|
.head_offset = offsetof(struct xfs_iunlink, iu_rhash_head),
|
|
|
|
.automatic_shrinking = true,
|
|
|
|
.obj_cmpfn = xfs_iunlink_obj_cmpfn,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return X, where X.next_unlinked == @agino. Returns NULLAGINO if no such
|
|
|
|
* relation is found.
|
|
|
|
*/
|
|
|
|
static xfs_agino_t
|
|
|
|
xfs_iunlink_lookup_backref(
|
|
|
|
struct xfs_perag *pag,
|
|
|
|
xfs_agino_t agino)
|
|
|
|
{
|
|
|
|
struct xfs_iunlink *iu;
|
|
|
|
|
|
|
|
iu = rhashtable_lookup_fast(&pag->pagi_unlinked_hash, &agino,
|
|
|
|
xfs_iunlink_hash_params);
|
|
|
|
return iu ? iu->iu_agino : NULLAGINO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Take ownership of an iunlink cache entry and insert it into the hash table.
|
|
|
|
* If successful, the entry will be owned by the cache; if not, it is freed.
|
|
|
|
* Either way, the caller does not own @iu after this call.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_iunlink_insert_backref(
|
|
|
|
struct xfs_perag *pag,
|
|
|
|
struct xfs_iunlink *iu)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = rhashtable_insert_fast(&pag->pagi_unlinked_hash,
|
|
|
|
&iu->iu_rhash_head, xfs_iunlink_hash_params);
|
|
|
|
/*
|
|
|
|
* Fail loudly if there already was an entry because that's a sign of
|
|
|
|
* corruption of in-memory data. Also fail loudly if we see an error
|
|
|
|
* code we didn't anticipate from the rhashtable code. Currently we
|
|
|
|
* only anticipate ENOMEM.
|
|
|
|
*/
|
|
|
|
if (error) {
|
|
|
|
WARN(error != -ENOMEM, "iunlink cache insert error %d", error);
|
|
|
|
kmem_free(iu);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Absorb any runtime errors that aren't a result of corruption because
|
|
|
|
* this is a cache and we can always fall back to bucket list scanning.
|
|
|
|
*/
|
|
|
|
if (error != 0 && error != -EEXIST)
|
|
|
|
error = 0;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remember that @prev_agino.next_unlinked = @this_agino. */
|
|
|
|
static int
|
|
|
|
xfs_iunlink_add_backref(
|
|
|
|
struct xfs_perag *pag,
|
|
|
|
xfs_agino_t prev_agino,
|
|
|
|
xfs_agino_t this_agino)
|
|
|
|
{
|
|
|
|
struct xfs_iunlink *iu;
|
|
|
|
|
|
|
|
if (XFS_TEST_ERROR(false, pag->pag_mount, XFS_ERRTAG_IUNLINK_FALLBACK))
|
|
|
|
return 0;
|
|
|
|
|
2019-08-26 19:06:22 +00:00
|
|
|
iu = kmem_zalloc(sizeof(*iu), KM_NOFS);
|
2019-02-07 18:37:16 +00:00
|
|
|
iu->iu_agino = prev_agino;
|
|
|
|
iu->iu_next_unlinked = this_agino;
|
|
|
|
|
|
|
|
return xfs_iunlink_insert_backref(pag, iu);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Replace X.next_unlinked = @agino with X.next_unlinked = @next_unlinked.
|
|
|
|
* If @next_unlinked is NULLAGINO, we drop the backref and exit. If there
|
|
|
|
* wasn't any such entry then we don't bother.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_iunlink_change_backref(
|
|
|
|
struct xfs_perag *pag,
|
|
|
|
xfs_agino_t agino,
|
|
|
|
xfs_agino_t next_unlinked)
|
|
|
|
{
|
|
|
|
struct xfs_iunlink *iu;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* Look up the old entry; if there wasn't one then exit. */
|
|
|
|
iu = rhashtable_lookup_fast(&pag->pagi_unlinked_hash, &agino,
|
|
|
|
xfs_iunlink_hash_params);
|
|
|
|
if (!iu)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove the entry. This shouldn't ever return an error, but if we
|
|
|
|
* couldn't remove the old entry we don't want to add it again to the
|
|
|
|
* hash table, and if the entry disappeared on us then someone's
|
|
|
|
* violated the locking rules and we need to fail loudly. Either way
|
|
|
|
* we cannot remove the inode because internal state is or would have
|
|
|
|
* been corrupt.
|
|
|
|
*/
|
|
|
|
error = rhashtable_remove_fast(&pag->pagi_unlinked_hash,
|
|
|
|
&iu->iu_rhash_head, xfs_iunlink_hash_params);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/* If there is no new next entry just free our item and return. */
|
|
|
|
if (next_unlinked == NULLAGINO) {
|
|
|
|
kmem_free(iu);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update the entry and re-add it to the hash table. */
|
|
|
|
iu->iu_next_unlinked = next_unlinked;
|
|
|
|
return xfs_iunlink_insert_backref(pag, iu);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set up the in-core predecessor structures. */
|
|
|
|
int
|
|
|
|
xfs_iunlink_init(
|
|
|
|
struct xfs_perag *pag)
|
|
|
|
{
|
|
|
|
return rhashtable_init(&pag->pagi_unlinked_hash,
|
|
|
|
&xfs_iunlink_hash_params);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free the in-core predecessor structures. */
|
|
|
|
static void
|
|
|
|
xfs_iunlink_free_item(
|
|
|
|
void *ptr,
|
|
|
|
void *arg)
|
|
|
|
{
|
|
|
|
struct xfs_iunlink *iu = ptr;
|
|
|
|
bool *freed_anything = arg;
|
|
|
|
|
|
|
|
*freed_anything = true;
|
|
|
|
kmem_free(iu);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_iunlink_destroy(
|
|
|
|
struct xfs_perag *pag)
|
|
|
|
{
|
|
|
|
bool freed_anything = false;
|
|
|
|
|
|
|
|
rhashtable_free_and_destroy(&pag->pagi_unlinked_hash,
|
|
|
|
xfs_iunlink_free_item, &freed_anything);
|
|
|
|
|
|
|
|
ASSERT(freed_anything == false || XFS_FORCED_SHUTDOWN(pag->pag_mount));
|
|
|
|
}
|
|
|
|
|
2019-02-07 18:37:14 +00:00
|
|
|
/*
|
|
|
|
* Point the AGI unlinked bucket at an inode and log the results. The caller
|
|
|
|
* is responsible for validating the old value.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_iunlink_update_bucket(
|
|
|
|
struct xfs_trans *tp,
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_perag *pag,
|
2019-02-07 18:37:14 +00:00
|
|
|
struct xfs_buf *agibp,
|
|
|
|
unsigned int bucket_index,
|
|
|
|
xfs_agino_t new_agino)
|
|
|
|
{
|
2020-03-10 15:57:29 +00:00
|
|
|
struct xfs_agi *agi = agibp->b_addr;
|
2019-02-07 18:37:14 +00:00
|
|
|
xfs_agino_t old_value;
|
|
|
|
int offset;
|
|
|
|
|
2021-06-02 00:48:51 +00:00
|
|
|
ASSERT(xfs_verify_agino_or_null(tp->t_mountp, pag->pag_agno, new_agino));
|
2019-02-07 18:37:14 +00:00
|
|
|
|
|
|
|
old_value = be32_to_cpu(agi->agi_unlinked[bucket_index]);
|
2021-06-02 00:48:51 +00:00
|
|
|
trace_xfs_iunlink_update_bucket(tp->t_mountp, pag->pag_agno, bucket_index,
|
2019-02-07 18:37:14 +00:00
|
|
|
old_value, new_agino);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We should never find the head of the list already set to the value
|
|
|
|
* passed in because either we're adding or removing ourselves from the
|
|
|
|
* head of the list.
|
|
|
|
*/
|
2019-11-02 16:40:53 +00:00
|
|
|
if (old_value == new_agino) {
|
2020-03-11 17:37:54 +00:00
|
|
|
xfs_buf_mark_corrupt(agibp);
|
2019-02-07 18:37:14 +00:00
|
|
|
return -EFSCORRUPTED;
|
2019-11-02 16:40:53 +00:00
|
|
|
}
|
2019-02-07 18:37:14 +00:00
|
|
|
|
|
|
|
agi->agi_unlinked[bucket_index] = cpu_to_be32(new_agino);
|
|
|
|
offset = offsetof(struct xfs_agi, agi_unlinked) +
|
|
|
|
(sizeof(xfs_agino_t) * bucket_index);
|
|
|
|
xfs_trans_log_buf(tp, agibp, offset, offset + sizeof(xfs_agino_t) - 1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-02-07 18:37:15 +00:00
|
|
|
/* Set an on-disk inode's next_unlinked pointer. */
|
|
|
|
STATIC void
|
|
|
|
xfs_iunlink_update_dinode(
|
|
|
|
struct xfs_trans *tp,
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_perag *pag,
|
2019-02-07 18:37:15 +00:00
|
|
|
xfs_agino_t agino,
|
|
|
|
struct xfs_buf *ibp,
|
|
|
|
struct xfs_dinode *dip,
|
|
|
|
struct xfs_imap *imap,
|
|
|
|
xfs_agino_t next_agino)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
int offset;
|
|
|
|
|
2021-06-02 00:48:51 +00:00
|
|
|
ASSERT(xfs_verify_agino_or_null(mp, pag->pag_agno, next_agino));
|
2019-02-07 18:37:15 +00:00
|
|
|
|
2021-06-02 00:48:51 +00:00
|
|
|
trace_xfs_iunlink_update_dinode(mp, pag->pag_agno, agino,
|
2019-02-07 18:37:15 +00:00
|
|
|
be32_to_cpu(dip->di_next_unlinked), next_agino);
|
|
|
|
|
|
|
|
dip->di_next_unlinked = cpu_to_be32(next_agino);
|
|
|
|
offset = imap->im_boffset +
|
|
|
|
offsetof(struct xfs_dinode, di_next_unlinked);
|
|
|
|
|
|
|
|
/* need to recalc the inode CRC if appropriate */
|
|
|
|
xfs_dinode_calc_crc(mp, dip);
|
|
|
|
xfs_trans_inode_buf(tp, ibp);
|
|
|
|
xfs_trans_log_buf(tp, ibp, offset, offset + sizeof(xfs_agino_t) - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set an in-core inode's unlinked pointer and return the old value. */
|
|
|
|
STATIC int
|
|
|
|
xfs_iunlink_update_inode(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_inode *ip,
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_perag *pag,
|
2019-02-07 18:37:15 +00:00
|
|
|
xfs_agino_t next_agino,
|
|
|
|
xfs_agino_t *old_next_agino)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
struct xfs_dinode *dip;
|
|
|
|
struct xfs_buf *ibp;
|
|
|
|
xfs_agino_t old_value;
|
|
|
|
int error;
|
|
|
|
|
2021-06-02 00:48:51 +00:00
|
|
|
ASSERT(xfs_verify_agino_or_null(mp, pag->pag_agno, next_agino));
|
2019-02-07 18:37:15 +00:00
|
|
|
|
2021-03-29 18:11:37 +00:00
|
|
|
error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &ibp);
|
2019-02-07 18:37:15 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
2021-03-29 18:11:37 +00:00
|
|
|
dip = xfs_buf_offset(ibp, ip->i_imap.im_boffset);
|
2019-02-07 18:37:15 +00:00
|
|
|
|
|
|
|
/* Make sure the old pointer isn't garbage. */
|
|
|
|
old_value = be32_to_cpu(dip->di_next_unlinked);
|
2021-06-02 00:48:51 +00:00
|
|
|
if (!xfs_verify_agino_or_null(mp, pag->pag_agno, old_value)) {
|
2019-11-02 16:40:53 +00:00
|
|
|
xfs_inode_verifier_error(ip, -EFSCORRUPTED, __func__, dip,
|
|
|
|
sizeof(*dip), __this_address);
|
2019-02-07 18:37:15 +00:00
|
|
|
error = -EFSCORRUPTED;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we're updating a linked list, we should never find that the
|
|
|
|
* current pointer is the same as the new value, unless we're
|
|
|
|
* terminating the list.
|
|
|
|
*/
|
|
|
|
*old_next_agino = old_value;
|
|
|
|
if (old_value == next_agino) {
|
2019-11-02 16:40:53 +00:00
|
|
|
if (next_agino != NULLAGINO) {
|
|
|
|
xfs_inode_verifier_error(ip, -EFSCORRUPTED, __func__,
|
|
|
|
dip, sizeof(*dip), __this_address);
|
2019-02-07 18:37:15 +00:00
|
|
|
error = -EFSCORRUPTED;
|
2019-11-02 16:40:53 +00:00
|
|
|
}
|
2019-02-07 18:37:15 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ok, update the new pointer. */
|
2021-06-02 00:48:51 +00:00
|
|
|
xfs_iunlink_update_dinode(tp, pag, XFS_INO_TO_AGINO(mp, ip->i_ino),
|
2019-02-07 18:37:15 +00:00
|
|
|
ibp, dip, &ip->i_imap, next_agino);
|
|
|
|
return 0;
|
|
|
|
out:
|
|
|
|
xfs_trans_brelse(tp, ibp);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
xfs: don't ever put nlink > 0 inodes on the unlinked list
When XFS creates an O_TMPFILE file, the inode is created with nlink = 1,
put on the unlinked list, and then the VFS sets nlink = 0 in d_tmpfile.
If we crash before anything logs the inode (it's dirty incore but the
vfs doesn't tell us it's dirty so we never log that change), the iunlink
processing part of recovery will then explode with a pile of:
XFS: Assertion failed: VFS_I(ip)->i_nlink == 0, file:
fs/xfs/xfs_log_recover.c, line: 5072
Worse yet, since nlink is nonzero, the inodes also don't get cleaned up
and they just leak until the next xfs_repair run.
Therefore, change xfs_iunlink to require that inodes being put on the
unlinked list have nlink == 0, change the tmpfile callers to instantiate
nodes that way, and set the nlink to 1 just prior to calling d_tmpfile.
Fix the comment for xfs_iunlink while we're at it.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2019-02-13 19:15:17 +00:00
|
|
|
* This is called when the inode's link count has gone to 0 or we are creating
|
|
|
|
* a tmpfile via O_TMPFILE. The inode @ip must have nlink == 0.
|
2016-02-09 05:54:58 +00:00
|
|
|
*
|
|
|
|
* We place the on-disk inode on a list in the AGI. It will be pulled from this
|
|
|
|
* list when the inode is freed.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2016-02-09 05:54:58 +00:00
|
|
|
STATIC int
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_iunlink(
|
2019-02-07 18:37:13 +00:00
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_inode *ip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2019-02-07 18:37:13 +00:00
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_perag *pag;
|
2019-02-07 18:37:13 +00:00
|
|
|
struct xfs_agi *agi;
|
|
|
|
struct xfs_buf *agibp;
|
2019-02-07 18:37:14 +00:00
|
|
|
xfs_agino_t next_agino;
|
2019-02-07 18:37:13 +00:00
|
|
|
xfs_agino_t agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
|
|
|
|
short bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
|
|
|
|
int error;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
xfs: don't ever put nlink > 0 inodes on the unlinked list
When XFS creates an O_TMPFILE file, the inode is created with nlink = 1,
put on the unlinked list, and then the VFS sets nlink = 0 in d_tmpfile.
If we crash before anything logs the inode (it's dirty incore but the
vfs doesn't tell us it's dirty so we never log that change), the iunlink
processing part of recovery will then explode with a pile of:
XFS: Assertion failed: VFS_I(ip)->i_nlink == 0, file:
fs/xfs/xfs_log_recover.c, line: 5072
Worse yet, since nlink is nonzero, the inodes also don't get cleaned up
and they just leak until the next xfs_repair run.
Therefore, change xfs_iunlink to require that inodes being put on the
unlinked list have nlink == 0, change the tmpfile callers to instantiate
nodes that way, and set the nlink to 1 just prior to calling d_tmpfile.
Fix the comment for xfs_iunlink while we're at it.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2019-02-13 19:15:17 +00:00
|
|
|
ASSERT(VFS_I(ip)->i_nlink == 0);
|
2016-02-09 05:54:58 +00:00
|
|
|
ASSERT(VFS_I(ip)->i_mode != 0);
|
2019-02-07 18:37:16 +00:00
|
|
|
trace_xfs_iunlink(ip);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-06-02 00:48:51 +00:00
|
|
|
pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
|
|
|
|
|
2019-02-07 18:37:13 +00:00
|
|
|
/* Get the agi buffer first. It ensures lock ordering on the list. */
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_read_agi(mp, tp, pag->pag_agno, &agibp);
|
2007-10-11 07:44:18 +00:00
|
|
|
if (error)
|
2021-06-02 00:48:51 +00:00
|
|
|
goto out;
|
2020-03-10 15:57:29 +00:00
|
|
|
agi = agibp->b_addr;
|
2008-11-28 03:23:37 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2019-02-07 18:37:14 +00:00
|
|
|
* Get the index into the agi hash table for the list this inode will
|
|
|
|
* go on. Make sure the pointer isn't garbage and that this inode
|
|
|
|
* isn't already on the list.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2019-02-07 18:37:14 +00:00
|
|
|
next_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
|
|
|
|
if (next_agino == agino ||
|
2021-06-02 00:48:51 +00:00
|
|
|
!xfs_verify_agino_or_null(mp, pag->pag_agno, next_agino)) {
|
2020-03-11 17:37:54 +00:00
|
|
|
xfs_buf_mark_corrupt(agibp);
|
2021-06-02 00:48:51 +00:00
|
|
|
error = -EFSCORRUPTED;
|
|
|
|
goto out;
|
2019-11-02 16:40:53 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-02-07 18:37:14 +00:00
|
|
|
if (next_agino != NULLAGINO) {
|
2019-02-07 18:37:16 +00:00
|
|
|
xfs_agino_t old_agino;
|
2019-02-07 18:37:15 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2019-02-07 18:37:15 +00:00
|
|
|
* There is already another inode in the bucket, so point this
|
|
|
|
* inode to the current head of the list.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_iunlink_update_inode(tp, ip, pag, next_agino,
|
2019-02-07 18:37:15 +00:00
|
|
|
&old_agino);
|
2007-11-23 05:27:51 +00:00
|
|
|
if (error)
|
2021-06-02 00:48:51 +00:00
|
|
|
goto out;
|
2019-02-07 18:37:15 +00:00
|
|
|
ASSERT(old_agino == NULLAGINO);
|
2019-02-07 18:37:16 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* agino has been unlinked, add a backref from the next inode
|
|
|
|
* back to agino.
|
|
|
|
*/
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_iunlink_add_backref(pag, agino, next_agino);
|
2019-02-07 18:37:16 +00:00
|
|
|
if (error)
|
2021-06-02 00:48:51 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2019-02-07 18:37:14 +00:00
|
|
|
/* Point the head of the list to point to this inode. */
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_iunlink_update_bucket(tp, pag, agibp, bucket_index, agino);
|
|
|
|
out:
|
|
|
|
xfs_perag_put(pag);
|
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2019-02-07 18:37:15 +00:00
|
|
|
/* Return the imap, dinode pointer, and buffer for an inode. */
|
|
|
|
STATIC int
|
|
|
|
xfs_iunlink_map_ino(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
xfs_agnumber_t agno,
|
|
|
|
xfs_agino_t agino,
|
|
|
|
struct xfs_imap *imap,
|
|
|
|
struct xfs_dinode **dipp,
|
|
|
|
struct xfs_buf **bpp)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
imap->im_blkno = 0;
|
|
|
|
error = xfs_imap(mp, tp, XFS_AGINO_TO_INO(mp, agno, agino), imap, 0);
|
|
|
|
if (error) {
|
|
|
|
xfs_warn(mp, "%s: xfs_imap returned error %d.",
|
|
|
|
__func__, error);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2021-03-29 18:11:37 +00:00
|
|
|
error = xfs_imap_to_bp(mp, tp, imap, bpp);
|
2019-02-07 18:37:15 +00:00
|
|
|
if (error) {
|
|
|
|
xfs_warn(mp, "%s: xfs_imap_to_bp returned error %d.",
|
|
|
|
__func__, error);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2021-03-29 18:11:37 +00:00
|
|
|
*dipp = xfs_buf_offset(*bpp, imap->im_boffset);
|
2019-02-07 18:37:15 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Walk the unlinked chain from @head_agino until we find the inode that
|
|
|
|
* points to @target_agino. Return the inode number, map, dinode pointer,
|
|
|
|
* and inode cluster buffer of that inode as @agino, @imap, @dipp, and @bpp.
|
|
|
|
*
|
|
|
|
* @tp, @pag, @head_agino, and @target_agino are input parameters.
|
|
|
|
* @agino, @imap, @dipp, and @bpp are all output parameters.
|
|
|
|
*
|
|
|
|
* Do not call this function if @target_agino is the head of the list.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_iunlink_map_prev(
|
|
|
|
struct xfs_trans *tp,
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_perag *pag,
|
2019-02-07 18:37:15 +00:00
|
|
|
xfs_agino_t head_agino,
|
|
|
|
xfs_agino_t target_agino,
|
|
|
|
xfs_agino_t *agino,
|
|
|
|
struct xfs_imap *imap,
|
|
|
|
struct xfs_dinode **dipp,
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_buf **bpp)
|
2019-02-07 18:37:15 +00:00
|
|
|
{
|
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
xfs_agino_t next_agino;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
ASSERT(head_agino != target_agino);
|
|
|
|
*bpp = NULL;
|
|
|
|
|
2019-02-07 18:37:16 +00:00
|
|
|
/* See if our backref cache can find it faster. */
|
|
|
|
*agino = xfs_iunlink_lookup_backref(pag, target_agino);
|
|
|
|
if (*agino != NULLAGINO) {
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_iunlink_map_ino(tp, pag->pag_agno, *agino, imap,
|
|
|
|
dipp, bpp);
|
2019-02-07 18:37:16 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
if (be32_to_cpu((*dipp)->di_next_unlinked) == target_agino)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we get here the cache contents were corrupt, so drop the
|
|
|
|
* buffer and fall back to walking the bucket list.
|
|
|
|
*/
|
|
|
|
xfs_trans_brelse(tp, *bpp);
|
|
|
|
*bpp = NULL;
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
}
|
|
|
|
|
2021-06-02 00:48:51 +00:00
|
|
|
trace_xfs_iunlink_map_prev_fallback(mp, pag->pag_agno);
|
2019-02-07 18:37:16 +00:00
|
|
|
|
|
|
|
/* Otherwise, walk the entire bucket until we find it. */
|
2019-02-07 18:37:15 +00:00
|
|
|
next_agino = head_agino;
|
|
|
|
while (next_agino != target_agino) {
|
|
|
|
xfs_agino_t unlinked_agino;
|
|
|
|
|
|
|
|
if (*bpp)
|
|
|
|
xfs_trans_brelse(tp, *bpp);
|
|
|
|
|
|
|
|
*agino = next_agino;
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_iunlink_map_ino(tp, pag->pag_agno, next_agino, imap,
|
|
|
|
dipp, bpp);
|
2019-02-07 18:37:15 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
unlinked_agino = be32_to_cpu((*dipp)->di_next_unlinked);
|
|
|
|
/*
|
|
|
|
* Make sure this pointer is valid and isn't an obvious
|
|
|
|
* infinite loop.
|
|
|
|
*/
|
2021-06-02 00:48:51 +00:00
|
|
|
if (!xfs_verify_agino(mp, pag->pag_agno, unlinked_agino) ||
|
2019-02-07 18:37:15 +00:00
|
|
|
next_agino == unlinked_agino) {
|
|
|
|
XFS_CORRUPTION_ERROR(__func__,
|
|
|
|
XFS_ERRLEVEL_LOW, mp,
|
|
|
|
*dipp, sizeof(**dipp));
|
|
|
|
error = -EFSCORRUPTED;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
next_agino = unlinked_agino;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Pull the on-disk inode from the AGI unlinked list.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_iunlink_remove(
|
2019-02-07 18:37:13 +00:00
|
|
|
struct xfs_trans *tp,
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_perag *pag,
|
2019-02-07 18:37:13 +00:00
|
|
|
struct xfs_inode *ip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2019-02-07 18:37:13 +00:00
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
struct xfs_agi *agi;
|
|
|
|
struct xfs_buf *agibp;
|
|
|
|
struct xfs_buf *last_ibp;
|
|
|
|
struct xfs_dinode *last_dip = NULL;
|
|
|
|
xfs_agino_t agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
|
|
|
|
xfs_agino_t next_agino;
|
2019-02-07 18:37:15 +00:00
|
|
|
xfs_agino_t head_agino;
|
2019-02-07 18:37:13 +00:00
|
|
|
short bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
|
|
|
|
int error;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-02-07 18:37:16 +00:00
|
|
|
trace_xfs_iunlink_remove(ip);
|
|
|
|
|
2019-02-07 18:37:13 +00:00
|
|
|
/* Get the agi buffer first. It ensures lock ordering on the list. */
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_read_agi(mp, tp, pag->pag_agno, &agibp);
|
2008-11-28 03:23:37 +00:00
|
|
|
if (error)
|
2005-04-16 22:20:36 +00:00
|
|
|
return error;
|
2020-03-10 15:57:29 +00:00
|
|
|
agi = agibp->b_addr;
|
2008-11-28 03:23:37 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2019-02-07 18:37:14 +00:00
|
|
|
* Get the index into the agi hash table for the list this inode will
|
|
|
|
* go on. Make sure the head pointer isn't garbage.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2019-02-07 18:37:15 +00:00
|
|
|
head_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
|
2021-06-02 00:48:51 +00:00
|
|
|
if (!xfs_verify_agino(mp, pag->pag_agno, head_agino)) {
|
2018-06-04 18:27:51 +00:00
|
|
|
XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
|
|
|
|
agi, sizeof(*agi));
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-02-07 18:37:15 +00:00
|
|
|
/*
|
|
|
|
* Set our inode's next_unlinked pointer to NULL and then return
|
|
|
|
* the old pointer value so that we can update whatever was previous
|
|
|
|
* to us in the list to point to whatever was next in the list.
|
|
|
|
*/
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_iunlink_update_inode(tp, ip, pag, NULLAGINO, &next_agino);
|
2019-02-07 18:37:15 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
2019-02-07 18:37:14 +00:00
|
|
|
|
2019-02-07 18:37:16 +00:00
|
|
|
/*
|
|
|
|
* If there was a backref pointing from the next inode back to this
|
|
|
|
* one, remove it because we've removed this inode from the list.
|
|
|
|
*
|
|
|
|
* Later, if this inode was in the middle of the list we'll update
|
|
|
|
* this inode's backref to point from the next inode.
|
|
|
|
*/
|
|
|
|
if (next_agino != NULLAGINO) {
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_iunlink_change_backref(pag, next_agino, NULLAGINO);
|
2019-02-07 18:37:16 +00:00
|
|
|
if (error)
|
2020-07-13 16:13:00 +00:00
|
|
|
return error;
|
2019-02-07 18:37:16 +00:00
|
|
|
}
|
|
|
|
|
2020-07-13 16:13:00 +00:00
|
|
|
if (head_agino != agino) {
|
2019-02-07 18:37:15 +00:00
|
|
|
struct xfs_imap imap;
|
|
|
|
xfs_agino_t prev_agino;
|
|
|
|
|
2019-02-07 18:37:15 +00:00
|
|
|
/* We need to search the list for the inode being freed. */
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_iunlink_map_prev(tp, pag, head_agino, agino,
|
|
|
|
&prev_agino, &imap, &last_dip, &last_ibp);
|
2019-02-07 18:37:15 +00:00
|
|
|
if (error)
|
2020-07-13 16:13:00 +00:00
|
|
|
return error;
|
2012-07-03 16:21:22 +00:00
|
|
|
|
2019-02-07 18:37:15 +00:00
|
|
|
/* Point the previous inode on the list to the next inode. */
|
2021-06-02 00:48:51 +00:00
|
|
|
xfs_iunlink_update_dinode(tp, pag, prev_agino, last_ibp,
|
2019-02-07 18:37:15 +00:00
|
|
|
last_dip, &imap, next_agino);
|
2019-02-07 18:37:16 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Now we deal with the backref for this inode. If this inode
|
|
|
|
* pointed at a real inode, change the backref that pointed to
|
|
|
|
* us to point to our old next. If this inode was the end of
|
|
|
|
* the list, delete the backref that pointed to us. Note that
|
|
|
|
* change_backref takes care of deleting the backref if
|
|
|
|
* next_agino is NULLAGINO.
|
|
|
|
*/
|
2020-07-13 16:13:00 +00:00
|
|
|
return xfs_iunlink_change_backref(agibp->b_pag, agino,
|
|
|
|
next_agino);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2019-02-07 18:37:16 +00:00
|
|
|
|
2020-07-13 16:13:00 +00:00
|
|
|
/* Point the head of the list to the next unlinked inode. */
|
2021-06-02 00:48:51 +00:00
|
|
|
return xfs_iunlink_update_bucket(tp, pag, agibp, bucket_index,
|
2020-07-13 16:13:00 +00:00
|
|
|
next_agino);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2020-03-25 03:10:30 +00:00
|
|
|
/*
|
2020-06-29 21:49:18 +00:00
|
|
|
* Look up the inode number specified and if it is not already marked XFS_ISTALE
|
|
|
|
* mark it stale. We should only find clean inodes in this lookup that aren't
|
|
|
|
* already stale.
|
2020-03-25 03:10:30 +00:00
|
|
|
*/
|
2020-06-29 21:49:18 +00:00
|
|
|
static void
|
|
|
|
xfs_ifree_mark_inode_stale(
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_perag *pag,
|
2020-03-25 03:10:30 +00:00
|
|
|
struct xfs_inode *free_ip,
|
2020-04-02 15:18:57 +00:00
|
|
|
xfs_ino_t inum)
|
2020-03-25 03:10:30 +00:00
|
|
|
{
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_mount *mp = pag->pag_mount;
|
2020-06-29 21:49:18 +00:00
|
|
|
struct xfs_inode_log_item *iip;
|
2020-03-25 03:10:30 +00:00
|
|
|
struct xfs_inode *ip;
|
|
|
|
|
|
|
|
retry:
|
|
|
|
rcu_read_lock();
|
|
|
|
ip = radix_tree_lookup(&pag->pag_ici_root, XFS_INO_TO_AGINO(mp, inum));
|
|
|
|
|
|
|
|
/* Inode not in memory, nothing to do */
|
2020-06-29 21:49:18 +00:00
|
|
|
if (!ip) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
2020-03-25 03:10:30 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* because this is an RCU protected lookup, we could find a recently
|
|
|
|
* freed or even reallocated inode during the lookup. We need to check
|
|
|
|
* under the i_flags_lock for a valid inode here. Skip it if it is not
|
|
|
|
* valid, the wrong inode or stale.
|
|
|
|
*/
|
|
|
|
spin_lock(&ip->i_flags_lock);
|
2020-08-17 23:41:01 +00:00
|
|
|
if (ip->i_ino != inum || __xfs_iflags_test(ip, XFS_ISTALE))
|
|
|
|
goto out_iflags_unlock;
|
2020-03-25 03:10:30 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't try to lock/unlock the current inode, but we _cannot_ skip the
|
|
|
|
* other inodes that we did not find in the list attached to the buffer
|
|
|
|
* and are not already marked stale. If we can't lock it, back off and
|
|
|
|
* retry.
|
|
|
|
*/
|
|
|
|
if (ip != free_ip) {
|
|
|
|
if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
|
2020-06-29 21:49:18 +00:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2020-03-25 03:10:30 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
delay(1);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
}
|
2020-06-29 21:49:18 +00:00
|
|
|
ip->i_flags |= XFS_ISTALE;
|
2020-03-25 03:10:30 +00:00
|
|
|
|
2020-06-29 21:49:18 +00:00
|
|
|
/*
|
2020-08-17 23:41:01 +00:00
|
|
|
* If the inode is flushing, it is already attached to the buffer. All
|
2020-06-29 21:49:18 +00:00
|
|
|
* we needed to do here is mark the inode stale so buffer IO completion
|
|
|
|
* will remove it from the AIL.
|
|
|
|
*/
|
|
|
|
iip = ip->i_itemp;
|
2020-08-17 23:41:01 +00:00
|
|
|
if (__xfs_iflags_test(ip, XFS_IFLUSHING)) {
|
2020-06-29 21:49:18 +00:00
|
|
|
ASSERT(!list_empty(&iip->ili_item.li_bio_list));
|
|
|
|
ASSERT(iip->ili_last_fields);
|
|
|
|
goto out_iunlock;
|
|
|
|
}
|
2020-03-25 03:10:30 +00:00
|
|
|
|
|
|
|
/*
|
2020-06-29 21:49:18 +00:00
|
|
|
* Inodes not attached to the buffer can be released immediately.
|
|
|
|
* Everything else has to go through xfs_iflush_abort() on journal
|
|
|
|
* commit as the flock synchronises removal of the inode from the
|
|
|
|
* cluster buffer against inode reclaim.
|
2020-03-25 03:10:30 +00:00
|
|
|
*/
|
2020-08-17 23:41:01 +00:00
|
|
|
if (!iip || list_empty(&iip->ili_item.li_bio_list))
|
2020-06-29 21:49:18 +00:00
|
|
|
goto out_iunlock;
|
2020-08-17 23:41:01 +00:00
|
|
|
|
|
|
|
__xfs_iflags_set(ip, XFS_IFLUSHING);
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
rcu_read_unlock();
|
2020-03-25 03:10:30 +00:00
|
|
|
|
2020-06-29 21:49:18 +00:00
|
|
|
/* we have a dirty inode in memory that has not yet been flushed. */
|
|
|
|
spin_lock(&iip->ili_lock);
|
|
|
|
iip->ili_last_fields = iip->ili_fields;
|
|
|
|
iip->ili_fields = 0;
|
|
|
|
iip->ili_fsync_fields = 0;
|
|
|
|
spin_unlock(&iip->ili_lock);
|
|
|
|
ASSERT(iip->ili_last_fields);
|
|
|
|
|
2020-08-17 23:41:01 +00:00
|
|
|
if (ip != free_ip)
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
return;
|
|
|
|
|
2020-06-29 21:49:18 +00:00
|
|
|
out_iunlock:
|
|
|
|
if (ip != free_ip)
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2020-08-17 23:41:01 +00:00
|
|
|
out_iflags_unlock:
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
rcu_read_unlock();
|
2020-03-25 03:10:30 +00:00
|
|
|
}
|
|
|
|
|
2010-08-24 01:42:41 +00:00
|
|
|
/*
|
2013-08-12 03:14:59 +00:00
|
|
|
* A big issue when freeing the inode cluster is that we _cannot_ skip any
|
2010-08-24 01:42:41 +00:00
|
|
|
* inodes that are in memory - they all must be marked stale and attached to
|
|
|
|
* the cluster buffer.
|
|
|
|
*/
|
2021-06-02 00:48:51 +00:00
|
|
|
static int
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_ifree_cluster(
|
2020-06-29 21:49:18 +00:00
|
|
|
struct xfs_trans *tp,
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_perag *pag,
|
|
|
|
struct xfs_inode *free_ip,
|
2015-05-28 23:26:03 +00:00
|
|
|
struct xfs_icluster *xic)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2020-06-29 21:49:18 +00:00
|
|
|
struct xfs_mount *mp = free_ip->i_mount;
|
|
|
|
struct xfs_ino_geometry *igeo = M_IGEO(mp);
|
|
|
|
struct xfs_buf *bp;
|
|
|
|
xfs_daddr_t blkno;
|
|
|
|
xfs_ino_t inum = xic->first_ino;
|
2005-04-16 22:20:36 +00:00
|
|
|
int nbufs;
|
xfs: fix race in inode cluster freeing failing to stale inodes
When an inode cluster is freed, it needs to mark all inodes in memory as
XFS_ISTALE before marking the buffer as stale. This is eeded because the inodes
have a different life cycle to the buffer, and once the buffer is torn down
during transaction completion, we must ensure none of the inodes get written
back (which is what XFS_ISTALE does).
Unfortunately, xfs_ifree_cluster() has some bugs that lead to inodes not being
marked with XFS_ISTALE. This shows up when xfs_iflush() is called on these
inodes either during inode reclaim or tail pushing on the AIL. The buffer is
read back, but no longer contains inodes and so triggers assert failures and
shutdowns. This was reproducable with at run.dbench10 invocation from xfstests.
There are two main causes of xfs_ifree_cluster() failing. The first is simple -
it checks in-memory inodes it finds in the per-ag icache to see if they are
clean without holding the flush lock. if they are clean it skips them
completely. However, If an inode is flushed delwri, it will
appear clean, but is not guaranteed to be written back until the flush lock has
been dropped. Hence we may have raced on the clean check and the inode may
actually be dirty. Hence always mark inodes found in memory stale before we
check properly if they are clean.
The second is more complex, and makes the first problem easier to hit.
Basically the in-memory inode scan is done with full knowledge it can be racing
with inode flushing and AIl tail pushing, which means that inodes that it can't
get the flush lock on might not be attached to the buffer after then in-memory
inode scan due to IO completion occurring. This is actually documented in the
code as "needs better interlocking". i.e. this is a zero-day bug.
Effectively, the in-memory scan must be done while the inode buffer is locked
and Io cannot be issued on it while we do the in-memory inode scan. This
ensures that inodes we couldn't get the flush lock on are guaranteed to be
attached to the cluster buffer, so we can then catch all in-memory inodes and
mark them stale.
Now that the inode cluster buffer is locked before the in-memory scan is done,
there is no need for the two-phase update of the in-memory inodes, so simplify
the code into two loops and remove the allocation of the temporary buffer used
to hold locked inodes across the phases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2010-06-03 06:22:29 +00:00
|
|
|
int i, j;
|
2015-06-04 03:03:34 +00:00
|
|
|
int ioffset;
|
2020-01-24 01:01:18 +00:00
|
|
|
int error;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-06-05 18:19:34 +00:00
|
|
|
nbufs = igeo->ialloc_blks / igeo->blocks_per_cluster;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-06-05 18:19:34 +00:00
|
|
|
for (j = 0; j < nbufs; j++, inum += igeo->inodes_per_cluster) {
|
2015-05-28 23:26:03 +00:00
|
|
|
/*
|
|
|
|
* The allocation bitmap tells us which inodes of the chunk were
|
|
|
|
* physically allocated. Skip the cluster if an inode falls into
|
|
|
|
* a sparse region.
|
|
|
|
*/
|
2015-06-04 03:03:34 +00:00
|
|
|
ioffset = inum - xic->first_ino;
|
|
|
|
if ((xic->alloc & XFS_INOBT_MASK(ioffset)) == 0) {
|
2019-06-05 18:19:34 +00:00
|
|
|
ASSERT(ioffset % igeo->inodes_per_cluster == 0);
|
2015-05-28 23:26:03 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
blkno = XFS_AGB_TO_DADDR(mp, XFS_INO_TO_AGNO(mp, inum),
|
|
|
|
XFS_INO_TO_AGBNO(mp, inum));
|
|
|
|
|
xfs: fix race in inode cluster freeing failing to stale inodes
When an inode cluster is freed, it needs to mark all inodes in memory as
XFS_ISTALE before marking the buffer as stale. This is eeded because the inodes
have a different life cycle to the buffer, and once the buffer is torn down
during transaction completion, we must ensure none of the inodes get written
back (which is what XFS_ISTALE does).
Unfortunately, xfs_ifree_cluster() has some bugs that lead to inodes not being
marked with XFS_ISTALE. This shows up when xfs_iflush() is called on these
inodes either during inode reclaim or tail pushing on the AIL. The buffer is
read back, but no longer contains inodes and so triggers assert failures and
shutdowns. This was reproducable with at run.dbench10 invocation from xfstests.
There are two main causes of xfs_ifree_cluster() failing. The first is simple -
it checks in-memory inodes it finds in the per-ag icache to see if they are
clean without holding the flush lock. if they are clean it skips them
completely. However, If an inode is flushed delwri, it will
appear clean, but is not guaranteed to be written back until the flush lock has
been dropped. Hence we may have raced on the clean check and the inode may
actually be dirty. Hence always mark inodes found in memory stale before we
check properly if they are clean.
The second is more complex, and makes the first problem easier to hit.
Basically the in-memory inode scan is done with full knowledge it can be racing
with inode flushing and AIl tail pushing, which means that inodes that it can't
get the flush lock on might not be attached to the buffer after then in-memory
inode scan due to IO completion occurring. This is actually documented in the
code as "needs better interlocking". i.e. this is a zero-day bug.
Effectively, the in-memory scan must be done while the inode buffer is locked
and Io cannot be issued on it while we do the in-memory inode scan. This
ensures that inodes we couldn't get the flush lock on are guaranteed to be
attached to the cluster buffer, so we can then catch all in-memory inodes and
mark them stale.
Now that the inode cluster buffer is locked before the in-memory scan is done,
there is no need for the two-phase update of the in-memory inodes, so simplify
the code into two loops and remove the allocation of the temporary buffer used
to hold locked inodes across the phases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2010-06-03 06:22:29 +00:00
|
|
|
/*
|
|
|
|
* We obtain and lock the backing buffer first in the process
|
2020-08-17 23:41:01 +00:00
|
|
|
* here to ensure dirty inodes attached to the buffer remain in
|
|
|
|
* the flushing state while we mark them stale.
|
|
|
|
*
|
xfs: fix race in inode cluster freeing failing to stale inodes
When an inode cluster is freed, it needs to mark all inodes in memory as
XFS_ISTALE before marking the buffer as stale. This is eeded because the inodes
have a different life cycle to the buffer, and once the buffer is torn down
during transaction completion, we must ensure none of the inodes get written
back (which is what XFS_ISTALE does).
Unfortunately, xfs_ifree_cluster() has some bugs that lead to inodes not being
marked with XFS_ISTALE. This shows up when xfs_iflush() is called on these
inodes either during inode reclaim or tail pushing on the AIL. The buffer is
read back, but no longer contains inodes and so triggers assert failures and
shutdowns. This was reproducable with at run.dbench10 invocation from xfstests.
There are two main causes of xfs_ifree_cluster() failing. The first is simple -
it checks in-memory inodes it finds in the per-ag icache to see if they are
clean without holding the flush lock. if they are clean it skips them
completely. However, If an inode is flushed delwri, it will
appear clean, but is not guaranteed to be written back until the flush lock has
been dropped. Hence we may have raced on the clean check and the inode may
actually be dirty. Hence always mark inodes found in memory stale before we
check properly if they are clean.
The second is more complex, and makes the first problem easier to hit.
Basically the in-memory inode scan is done with full knowledge it can be racing
with inode flushing and AIl tail pushing, which means that inodes that it can't
get the flush lock on might not be attached to the buffer after then in-memory
inode scan due to IO completion occurring. This is actually documented in the
code as "needs better interlocking". i.e. this is a zero-day bug.
Effectively, the in-memory scan must be done while the inode buffer is locked
and Io cannot be issued on it while we do the in-memory inode scan. This
ensures that inodes we couldn't get the flush lock on are guaranteed to be
attached to the cluster buffer, so we can then catch all in-memory inodes and
mark them stale.
Now that the inode cluster buffer is locked before the in-memory scan is done,
there is no need for the two-phase update of the in-memory inodes, so simplify
the code into two loops and remove the allocation of the temporary buffer used
to hold locked inodes across the phases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2010-06-03 06:22:29 +00:00
|
|
|
* If we scan the in-memory inodes first, then buffer IO can
|
|
|
|
* complete before we get a lock on it, and hence we may fail
|
|
|
|
* to mark all the active inodes on the buffer stale.
|
|
|
|
*/
|
2020-01-24 01:01:18 +00:00
|
|
|
error = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
|
|
|
|
mp->m_bsize * igeo->blocks_per_cluster,
|
|
|
|
XBF_UNMAPPED, &bp);
|
2020-06-29 21:49:18 +00:00
|
|
|
if (error)
|
2020-01-24 01:01:18 +00:00
|
|
|
return error;
|
2012-11-14 06:53:49 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This buffer may not have been correctly initialised as we
|
|
|
|
* didn't read it from disk. That's not important because we are
|
|
|
|
* only using to mark the buffer as stale in the log, and to
|
|
|
|
* attach stale cached inodes on it. That means it will never be
|
|
|
|
* dispatched for IO. If it is, we want to know about it, and we
|
|
|
|
* want it to fail. We can acheive this by adding a write
|
|
|
|
* verifier to the buffer.
|
|
|
|
*/
|
2018-12-12 16:46:20 +00:00
|
|
|
bp->b_ops = &xfs_inode_buf_ops;
|
2012-11-14 06:53:49 +00:00
|
|
|
|
xfs: fix race in inode cluster freeing failing to stale inodes
When an inode cluster is freed, it needs to mark all inodes in memory as
XFS_ISTALE before marking the buffer as stale. This is eeded because the inodes
have a different life cycle to the buffer, and once the buffer is torn down
during transaction completion, we must ensure none of the inodes get written
back (which is what XFS_ISTALE does).
Unfortunately, xfs_ifree_cluster() has some bugs that lead to inodes not being
marked with XFS_ISTALE. This shows up when xfs_iflush() is called on these
inodes either during inode reclaim or tail pushing on the AIL. The buffer is
read back, but no longer contains inodes and so triggers assert failures and
shutdowns. This was reproducable with at run.dbench10 invocation from xfstests.
There are two main causes of xfs_ifree_cluster() failing. The first is simple -
it checks in-memory inodes it finds in the per-ag icache to see if they are
clean without holding the flush lock. if they are clean it skips them
completely. However, If an inode is flushed delwri, it will
appear clean, but is not guaranteed to be written back until the flush lock has
been dropped. Hence we may have raced on the clean check and the inode may
actually be dirty. Hence always mark inodes found in memory stale before we
check properly if they are clean.
The second is more complex, and makes the first problem easier to hit.
Basically the in-memory inode scan is done with full knowledge it can be racing
with inode flushing and AIl tail pushing, which means that inodes that it can't
get the flush lock on might not be attached to the buffer after then in-memory
inode scan due to IO completion occurring. This is actually documented in the
code as "needs better interlocking". i.e. this is a zero-day bug.
Effectively, the in-memory scan must be done while the inode buffer is locked
and Io cannot be issued on it while we do the in-memory inode scan. This
ensures that inodes we couldn't get the flush lock on are guaranteed to be
attached to the cluster buffer, so we can then catch all in-memory inodes and
mark them stale.
Now that the inode cluster buffer is locked before the in-memory scan is done,
there is no need for the two-phase update of the in-memory inodes, so simplify
the code into two loops and remove the allocation of the temporary buffer used
to hold locked inodes across the phases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2010-06-03 06:22:29 +00:00
|
|
|
/*
|
2020-06-29 21:49:18 +00:00
|
|
|
* Now we need to set all the cached clean inodes as XFS_ISTALE,
|
|
|
|
* too. This requires lookups, and will skip inodes that we've
|
|
|
|
* already marked XFS_ISTALE.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2020-06-29 21:49:18 +00:00
|
|
|
for (i = 0; i < igeo->inodes_per_cluster; i++)
|
2021-06-02 00:48:51 +00:00
|
|
|
xfs_ifree_mark_inode_stale(pag, free_ip, inum + i);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-08-24 01:42:41 +00:00
|
|
|
xfs_trans_stale_inode_buf(tp, bp);
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_trans_binval(tp, bp);
|
|
|
|
}
|
2011-09-20 13:56:55 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called to return an inode to the inode free list.
|
|
|
|
* The inode should already be truncated to 0 length and have
|
|
|
|
* no pages associated with it. This routine also assumes that
|
|
|
|
* the inode is already a part of the transaction.
|
|
|
|
*
|
|
|
|
* The on-disk copy of the inode will have been added to the list
|
|
|
|
* of unlinked inodes in the AGI. We need to remove the inode from
|
|
|
|
* that list atomically with respect to freeing it here.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_ifree(
|
2018-07-12 05:26:07 +00:00
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_inode *ip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_perag *pag;
|
2015-05-28 23:26:03 +00:00
|
|
|
struct xfs_icluster xic = { 0 };
|
2020-06-29 21:48:46 +00:00
|
|
|
struct xfs_inode_log_item *iip = ip->i_itemp;
|
2021-06-02 00:48:51 +00:00
|
|
|
int error;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-22 07:34:00 +00:00
|
|
|
ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
|
2016-02-09 05:54:58 +00:00
|
|
|
ASSERT(VFS_I(ip)->i_nlink == 0);
|
2020-05-18 17:27:22 +00:00
|
|
|
ASSERT(ip->i_df.if_nextents == 0);
|
2021-03-29 18:11:40 +00:00
|
|
|
ASSERT(ip->i_disk_size == 0 || !S_ISREG(VFS_I(ip)->i_mode));
|
2021-03-29 18:11:40 +00:00
|
|
|
ASSERT(ip->i_nblocks == 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-06-02 00:48:51 +00:00
|
|
|
pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Pull the on-disk inode from the AGI unlinked list.
|
|
|
|
*/
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_iunlink_remove(tp, pag, ip);
|
2013-06-27 06:04:50 +00:00
|
|
|
if (error)
|
2021-06-02 00:48:51 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_difree(tp, pag, ip->i_ino, &xic);
|
2013-06-27 06:04:50 +00:00
|
|
|
if (error)
|
2021-06-02 00:48:51 +00:00
|
|
|
goto out;
|
2013-06-27 06:04:50 +00:00
|
|
|
|
2020-05-18 17:27:21 +00:00
|
|
|
/*
|
|
|
|
* Free any local-format data sitting around before we reset the
|
|
|
|
* data fork to extents format. Note that the attr fork data has
|
|
|
|
* already been freed by xfs_attr_inactive.
|
|
|
|
*/
|
2020-05-18 17:28:05 +00:00
|
|
|
if (ip->i_df.if_format == XFS_DINODE_FMT_LOCAL) {
|
2020-05-18 17:27:21 +00:00
|
|
|
kmem_free(ip->i_df.if_u1.if_data);
|
|
|
|
ip->i_df.if_u1.if_data = NULL;
|
|
|
|
ip->i_df.if_bytes = 0;
|
|
|
|
}
|
2017-11-22 20:21:07 +00:00
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
VFS_I(ip)->i_mode = 0; /* mark incore inode as free */
|
2021-03-29 18:11:44 +00:00
|
|
|
ip->i_diflags = 0;
|
2021-06-02 00:48:51 +00:00
|
|
|
ip->i_diflags2 = mp->m_ino_geo.new_diflags2;
|
2021-03-29 18:11:44 +00:00
|
|
|
ip->i_forkoff = 0; /* mark the attr fork not in use */
|
2020-05-18 17:28:05 +00:00
|
|
|
ip->i_df.if_format = XFS_DINODE_FMT_EXTENTS;
|
2021-03-29 18:11:38 +00:00
|
|
|
if (xfs_iflags_test(ip, XFS_IPRESERVE_DM_FIELDS))
|
|
|
|
xfs_iflags_clear(ip, XFS_IPRESERVE_DM_FIELDS);
|
2018-03-29 00:48:08 +00:00
|
|
|
|
|
|
|
/* Don't attempt to replay owner changes for a deleted inode */
|
2020-06-29 21:48:46 +00:00
|
|
|
spin_lock(&iip->ili_lock);
|
|
|
|
iip->ili_fields &= ~(XFS_ILOG_AOWNER | XFS_ILOG_DOWNER);
|
|
|
|
spin_unlock(&iip->ili_lock);
|
2018-03-29 00:48:08 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Bump the generation count so no one will be confused
|
|
|
|
* by reincarnations of this inode.
|
|
|
|
*/
|
2016-02-09 05:54:58 +00:00
|
|
|
VFS_I(ip)->i_generation++;
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
|
2015-05-28 23:26:03 +00:00
|
|
|
if (xic.deleted)
|
2021-06-02 00:48:51 +00:00
|
|
|
error = xfs_ifree_cluster(tp, pag, ip, &xic);
|
|
|
|
out:
|
|
|
|
xfs_perag_put(pag);
|
2011-09-20 13:56:55 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-02-17 19:43:56 +00:00
|
|
|
* This is called to unpin an inode. The caller must have the inode locked
|
|
|
|
* in at least shared mode so that the buffer cannot be subsequently pinned
|
|
|
|
* once someone is waiting for it to be unpinned.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2010-02-17 19:43:56 +00:00
|
|
|
static void
|
2011-12-18 20:00:10 +00:00
|
|
|
xfs_iunpin(
|
2010-02-17 19:43:56 +00:00
|
|
|
struct xfs_inode *ip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-22 07:34:00 +00:00
|
|
|
ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-03-08 00:24:07 +00:00
|
|
|
trace_xfs_inode_unpin_nowait(ip, _RET_IP_);
|
|
|
|
|
2008-03-06 02:43:42 +00:00
|
|
|
/* Give the log a push to start the unpinning I/O */
|
2021-06-18 15:21:52 +00:00
|
|
|
xfs_log_force_seq(ip->i_mount, ip->i_itemp->ili_commit_seq, 0, NULL);
|
2010-01-19 09:56:46 +00:00
|
|
|
|
2008-03-06 02:43:42 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-12-18 20:00:10 +00:00
|
|
|
static void
|
|
|
|
__xfs_iunpin_wait(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IPINNED_BIT);
|
|
|
|
DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IPINNED_BIT);
|
|
|
|
|
|
|
|
xfs_iunpin(ip);
|
|
|
|
|
|
|
|
do {
|
2017-03-05 10:25:39 +00:00
|
|
|
prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
|
2011-12-18 20:00:10 +00:00
|
|
|
if (xfs_ipincount(ip))
|
|
|
|
io_schedule();
|
|
|
|
} while (xfs_ipincount(ip));
|
2017-03-05 10:25:39 +00:00
|
|
|
finish_wait(wq, &wait.wq_entry);
|
2011-12-18 20:00:10 +00:00
|
|
|
}
|
|
|
|
|
2010-02-06 01:37:26 +00:00
|
|
|
void
|
2008-03-06 02:43:42 +00:00
|
|
|
xfs_iunpin_wait(
|
2010-02-17 19:43:56 +00:00
|
|
|
struct xfs_inode *ip)
|
2008-03-06 02:43:42 +00:00
|
|
|
{
|
2011-12-18 20:00:10 +00:00
|
|
|
if (xfs_ipincount(ip))
|
|
|
|
__xfs_iunpin_wait(ip);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-10-29 11:11:44 +00:00
|
|
|
/*
|
|
|
|
* Removing an inode from the namespace involves removing the directory entry
|
|
|
|
* and dropping the link count on the inode. Removing the directory entry can
|
|
|
|
* result in locking an AGF (directory blocks were freed) and removing a link
|
|
|
|
* count can result in placing the inode on an unlinked list which results in
|
|
|
|
* locking an AGI.
|
|
|
|
*
|
|
|
|
* The big problem here is that we have an ordering constraint on AGF and AGI
|
|
|
|
* locking - inode allocation locks the AGI, then can allocate a new extent for
|
|
|
|
* new inodes, locking the AGF after the AGI. Similarly, freeing the inode
|
|
|
|
* removes the inode from the unlinked list, requiring that we lock the AGI
|
|
|
|
* first, and then freeing the inode can result in an inode chunk being freed
|
|
|
|
* and hence freeing disk space requiring that we lock an AGF.
|
|
|
|
*
|
|
|
|
* Hence the ordering that is imposed by other parts of the code is AGI before
|
|
|
|
* AGF. This means we cannot remove the directory entry before we drop the inode
|
|
|
|
* reference count and put it on the unlinked list as this results in a lock
|
|
|
|
* order of AGF then AGI, and this can deadlock against inode allocation and
|
|
|
|
* freeing. Therefore we must drop the link counts before we remove the
|
|
|
|
* directory entry.
|
|
|
|
*
|
|
|
|
* This is still safe from a transactional point of view - it is not until we
|
2016-08-03 01:18:10 +00:00
|
|
|
* get to xfs_defer_finish() that we have the possibility of multiple
|
2013-10-29 11:11:44 +00:00
|
|
|
* transactions in this operation. Hence as long as we remove the directory
|
|
|
|
* entry and drop the link count in the first transaction of the remove
|
|
|
|
* operation, there are no transactional constraints on the ordering here.
|
|
|
|
*/
|
2013-08-12 10:49:45 +00:00
|
|
|
int
|
|
|
|
xfs_remove(
|
|
|
|
xfs_inode_t *dp,
|
|
|
|
struct xfs_name *name,
|
|
|
|
xfs_inode_t *ip)
|
|
|
|
{
|
|
|
|
xfs_mount_t *mp = dp->i_mount;
|
|
|
|
xfs_trans_t *tp = NULL;
|
2016-02-09 05:54:58 +00:00
|
|
|
int is_dir = S_ISDIR(VFS_I(ip)->i_mode);
|
2013-08-12 10:49:45 +00:00
|
|
|
int error = 0;
|
|
|
|
uint resblks;
|
|
|
|
|
|
|
|
trace_xfs_remove(dp, name);
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EIO;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2018-05-04 22:30:21 +00:00
|
|
|
error = xfs_qm_dqattach(dp);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
|
|
|
goto std_return;
|
|
|
|
|
2018-05-04 22:30:21 +00:00
|
|
|
error = xfs_qm_dqattach(ip);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
|
|
|
goto std_return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We try to get the real space reservation first,
|
|
|
|
* allowing for directory btree deletion(s) implying
|
|
|
|
* possible bmap insert(s). If we can't get the space
|
|
|
|
* reservation then we use 0 instead, and avoid the bmap
|
|
|
|
* btree insert(s) in the directory code by, if the bmap
|
|
|
|
* insert tries to happen, instead trimming the LAST
|
|
|
|
* block from the directory.
|
|
|
|
*/
|
|
|
|
resblks = XFS_REMOVE_SPACE_RES(mp);
|
2016-04-05 23:19:55 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, resblks, 0, 0, &tp);
|
2014-06-25 04:58:08 +00:00
|
|
|
if (error == -ENOSPC) {
|
2013-08-12 10:49:45 +00:00
|
|
|
resblks = 0;
|
2016-04-05 23:19:55 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, 0, 0, 0,
|
|
|
|
&tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
if (error) {
|
2014-06-25 04:58:08 +00:00
|
|
|
ASSERT(error != -ENOSPC);
|
2016-04-05 23:19:55 +00:00
|
|
|
goto std_return;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
2018-01-26 23:27:33 +00:00
|
|
|
xfs_lock_two_inodes(dp, XFS_ILOCK_EXCL, ip, XFS_ILOCK_EXCL);
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2016-11-30 03:33:25 +00:00
|
|
|
xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're removing a directory perform some additional validation.
|
|
|
|
*/
|
|
|
|
if (is_dir) {
|
2016-02-09 05:54:58 +00:00
|
|
|
ASSERT(VFS_I(ip)->i_nlink >= 2);
|
|
|
|
if (VFS_I(ip)->i_nlink != 2) {
|
2014-06-25 04:58:08 +00:00
|
|
|
error = -ENOTEMPTY;
|
2013-08-12 10:49:45 +00:00
|
|
|
goto out_trans_cancel;
|
|
|
|
}
|
|
|
|
if (!xfs_dir_isempty(ip)) {
|
2014-06-25 04:58:08 +00:00
|
|
|
error = -ENOTEMPTY;
|
2013-08-12 10:49:45 +00:00
|
|
|
goto out_trans_cancel;
|
|
|
|
}
|
|
|
|
|
2013-10-29 11:11:44 +00:00
|
|
|
/* Drop the link from ip's "..". */
|
2013-08-12 10:49:45 +00:00
|
|
|
error = xfs_droplink(tp, dp);
|
|
|
|
if (error)
|
2013-10-29 11:11:44 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2013-10-29 11:11:44 +00:00
|
|
|
/* Drop the "." link from ip to self. */
|
2013-08-12 10:49:45 +00:00
|
|
|
error = xfs_droplink(tp, ip);
|
|
|
|
if (error)
|
2013-10-29 11:11:44 +00:00
|
|
|
goto out_trans_cancel;
|
2021-07-12 19:58:48 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Point the unlinked child directory's ".." entry to the root
|
|
|
|
* directory to eliminate back-references to inodes that may
|
|
|
|
* get freed before the child directory is closed. If the fs
|
|
|
|
* gets shrunk, this can lead to dirent inode validation errors.
|
|
|
|
*/
|
|
|
|
if (dp->i_ino != tp->t_mountp->m_sb.sb_rootino) {
|
|
|
|
error = xfs_dir_replace(tp, ip, &xfs_name_dotdot,
|
|
|
|
tp->t_mountp->m_sb.sb_rootino, 0);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
2013-08-12 10:49:45 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* When removing a non-directory we need to log the parent
|
|
|
|
* inode here. For a directory this is done implicitly
|
|
|
|
* by the xfs_droplink call for the ".." entry.
|
|
|
|
*/
|
|
|
|
xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
|
|
|
|
}
|
2013-10-29 11:11:44 +00:00
|
|
|
xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2013-10-29 11:11:44 +00:00
|
|
|
/* Drop the link from dp to ip. */
|
2013-08-12 10:49:45 +00:00
|
|
|
error = xfs_droplink(tp, ip);
|
|
|
|
if (error)
|
2013-10-29 11:11:44 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2018-07-12 05:26:21 +00:00
|
|
|
error = xfs_dir_removename(tp, dp, name, ip->i_ino, resblks);
|
2013-10-29 11:11:44 +00:00
|
|
|
if (error) {
|
2014-06-25 04:58:08 +00:00
|
|
|
ASSERT(error != -ENOENT);
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2013-10-29 11:11:44 +00:00
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
/*
|
|
|
|
* If this is a synchronous mount, make sure that the
|
|
|
|
* remove transaction goes to disk before returning to
|
|
|
|
* the user.
|
|
|
|
*/
|
|
|
|
if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
|
|
|
|
xfs_trans_set_sync(tp);
|
|
|
|
|
2015-06-04 03:48:08 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
|
|
|
goto std_return;
|
|
|
|
|
2014-04-22 21:11:51 +00:00
|
|
|
if (is_dir && xfs_inode_is_filestream(ip))
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_filestream_deassociate(ip);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_trans_cancel:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
std_return:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:46 +00:00
|
|
|
/*
|
|
|
|
* Enter all inodes for a rename transaction into a sorted array.
|
|
|
|
*/
|
2015-03-25 03:03:32 +00:00
|
|
|
#define __XFS_SORT_INODES 5
|
2013-08-12 10:49:46 +00:00
|
|
|
STATIC void
|
|
|
|
xfs_sort_for_rename(
|
2015-03-25 03:03:32 +00:00
|
|
|
struct xfs_inode *dp1, /* in: old (source) directory inode */
|
|
|
|
struct xfs_inode *dp2, /* in: new (target) directory inode */
|
|
|
|
struct xfs_inode *ip1, /* in: inode of old entry */
|
|
|
|
struct xfs_inode *ip2, /* in: inode of new entry */
|
|
|
|
struct xfs_inode *wip, /* in: whiteout inode */
|
|
|
|
struct xfs_inode **i_tab,/* out: sorted array of inodes */
|
|
|
|
int *num_inodes) /* in/out: inodes in array */
|
2013-08-12 10:49:46 +00:00
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
|
2015-03-25 03:03:32 +00:00
|
|
|
ASSERT(*num_inodes == __XFS_SORT_INODES);
|
|
|
|
memset(i_tab, 0, *num_inodes * sizeof(struct xfs_inode *));
|
|
|
|
|
2013-08-12 10:49:46 +00:00
|
|
|
/*
|
|
|
|
* i_tab contains a list of pointers to inodes. We initialize
|
|
|
|
* the table here & we'll sort it. We will then use it to
|
|
|
|
* order the acquisition of the inode locks.
|
|
|
|
*
|
|
|
|
* Note that the table may contain duplicates. e.g., dp1 == dp2.
|
|
|
|
*/
|
2015-03-25 03:03:32 +00:00
|
|
|
i = 0;
|
|
|
|
i_tab[i++] = dp1;
|
|
|
|
i_tab[i++] = dp2;
|
|
|
|
i_tab[i++] = ip1;
|
|
|
|
if (ip2)
|
|
|
|
i_tab[i++] = ip2;
|
|
|
|
if (wip)
|
|
|
|
i_tab[i++] = wip;
|
|
|
|
*num_inodes = i;
|
2013-08-12 10:49:46 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Sort the elements via bubble sort. (Remember, there are at
|
2015-03-25 03:03:32 +00:00
|
|
|
* most 5 elements to sort, so this is adequate.)
|
2013-08-12 10:49:46 +00:00
|
|
|
*/
|
|
|
|
for (i = 0; i < *num_inodes; i++) {
|
|
|
|
for (j = 1; j < *num_inodes; j++) {
|
|
|
|
if (i_tab[j]->i_ino < i_tab[j-1]->i_ino) {
|
2015-03-25 03:03:32 +00:00
|
|
|
struct xfs_inode *temp = i_tab[j];
|
2013-08-12 10:49:46 +00:00
|
|
|
i_tab[j] = i_tab[j-1];
|
|
|
|
i_tab[j-1] = temp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-25 03:06:07 +00:00
|
|
|
static int
|
|
|
|
xfs_finish_rename(
|
2018-07-12 05:26:08 +00:00
|
|
|
struct xfs_trans *tp)
|
2015-03-25 03:06:07 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If this is a synchronous mount, make sure that the rename transaction
|
|
|
|
* goes to disk before returning to the user.
|
|
|
|
*/
|
|
|
|
if (tp->t_mountp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
|
|
|
|
xfs_trans_set_sync(tp);
|
|
|
|
|
2015-06-04 03:48:08 +00:00
|
|
|
return xfs_trans_commit(tp);
|
2015-03-25 03:06:07 +00:00
|
|
|
}
|
|
|
|
|
2014-12-23 21:51:42 +00:00
|
|
|
/*
|
|
|
|
* xfs_cross_rename()
|
|
|
|
*
|
2021-03-23 23:59:30 +00:00
|
|
|
* responsible for handling RENAME_EXCHANGE flag in renameat2() syscall
|
2014-12-23 21:51:42 +00:00
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_cross_rename(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_inode *dp1,
|
|
|
|
struct xfs_name *name1,
|
|
|
|
struct xfs_inode *ip1,
|
|
|
|
struct xfs_inode *dp2,
|
|
|
|
struct xfs_name *name2,
|
|
|
|
struct xfs_inode *ip2,
|
|
|
|
int spaceres)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
int ip1_flags = 0;
|
|
|
|
int ip2_flags = 0;
|
|
|
|
int dp2_flags = 0;
|
|
|
|
|
|
|
|
/* Swap inode number for dirent in first parent */
|
2018-07-12 05:26:21 +00:00
|
|
|
error = xfs_dir_replace(tp, dp1, name1, ip2->i_ino, spaceres);
|
2014-12-23 21:51:42 +00:00
|
|
|
if (error)
|
2015-03-25 03:08:07 +00:00
|
|
|
goto out_trans_abort;
|
2014-12-23 21:51:42 +00:00
|
|
|
|
|
|
|
/* Swap inode number for dirent in second parent */
|
2018-07-12 05:26:21 +00:00
|
|
|
error = xfs_dir_replace(tp, dp2, name2, ip1->i_ino, spaceres);
|
2014-12-23 21:51:42 +00:00
|
|
|
if (error)
|
2015-03-25 03:08:07 +00:00
|
|
|
goto out_trans_abort;
|
2014-12-23 21:51:42 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're renaming one or more directories across different parents,
|
|
|
|
* update the respective ".." entries (and link counts) to match the new
|
|
|
|
* parents.
|
|
|
|
*/
|
|
|
|
if (dp1 != dp2) {
|
|
|
|
dp2_flags = XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
|
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
if (S_ISDIR(VFS_I(ip2)->i_mode)) {
|
2014-12-23 21:51:42 +00:00
|
|
|
error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot,
|
2018-07-12 05:26:21 +00:00
|
|
|
dp1->i_ino, spaceres);
|
2014-12-23 21:51:42 +00:00
|
|
|
if (error)
|
2015-03-25 03:08:07 +00:00
|
|
|
goto out_trans_abort;
|
2014-12-23 21:51:42 +00:00
|
|
|
|
|
|
|
/* transfer ip2 ".." reference to dp1 */
|
2016-02-09 05:54:58 +00:00
|
|
|
if (!S_ISDIR(VFS_I(ip1)->i_mode)) {
|
2014-12-23 21:51:42 +00:00
|
|
|
error = xfs_droplink(tp, dp2);
|
|
|
|
if (error)
|
2015-03-25 03:08:07 +00:00
|
|
|
goto out_trans_abort;
|
2019-05-02 03:26:30 +00:00
|
|
|
xfs_bumplink(tp, dp1);
|
2014-12-23 21:51:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Although ip1 isn't changed here, userspace needs
|
|
|
|
* to be warned about the change, so that applications
|
|
|
|
* relying on it (like backup ones), will properly
|
|
|
|
* notify the change
|
|
|
|
*/
|
|
|
|
ip1_flags |= XFS_ICHGTIME_CHG;
|
|
|
|
ip2_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
|
|
|
|
}
|
|
|
|
|
2016-02-09 05:54:58 +00:00
|
|
|
if (S_ISDIR(VFS_I(ip1)->i_mode)) {
|
2014-12-23 21:51:42 +00:00
|
|
|
error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot,
|
2018-07-12 05:26:21 +00:00
|
|
|
dp2->i_ino, spaceres);
|
2014-12-23 21:51:42 +00:00
|
|
|
if (error)
|
2015-03-25 03:08:07 +00:00
|
|
|
goto out_trans_abort;
|
2014-12-23 21:51:42 +00:00
|
|
|
|
|
|
|
/* transfer ip1 ".." reference to dp2 */
|
2016-02-09 05:54:58 +00:00
|
|
|
if (!S_ISDIR(VFS_I(ip2)->i_mode)) {
|
2014-12-23 21:51:42 +00:00
|
|
|
error = xfs_droplink(tp, dp1);
|
|
|
|
if (error)
|
2015-03-25 03:08:07 +00:00
|
|
|
goto out_trans_abort;
|
2019-05-02 03:26:30 +00:00
|
|
|
xfs_bumplink(tp, dp2);
|
2014-12-23 21:51:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Although ip2 isn't changed here, userspace needs
|
|
|
|
* to be warned about the change, so that applications
|
|
|
|
* relying on it (like backup ones), will properly
|
|
|
|
* notify the change
|
|
|
|
*/
|
|
|
|
ip1_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
|
|
|
|
ip2_flags |= XFS_ICHGTIME_CHG;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ip1_flags) {
|
|
|
|
xfs_trans_ichgtime(tp, ip1, ip1_flags);
|
|
|
|
xfs_trans_log_inode(tp, ip1, XFS_ILOG_CORE);
|
|
|
|
}
|
|
|
|
if (ip2_flags) {
|
|
|
|
xfs_trans_ichgtime(tp, ip2, ip2_flags);
|
|
|
|
xfs_trans_log_inode(tp, ip2, XFS_ILOG_CORE);
|
|
|
|
}
|
|
|
|
if (dp2_flags) {
|
|
|
|
xfs_trans_ichgtime(tp, dp2, dp2_flags);
|
|
|
|
xfs_trans_log_inode(tp, dp2, XFS_ILOG_CORE);
|
|
|
|
}
|
|
|
|
xfs_trans_ichgtime(tp, dp1, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
|
|
|
|
xfs_trans_log_inode(tp, dp1, XFS_ILOG_CORE);
|
2018-07-12 05:26:08 +00:00
|
|
|
return xfs_finish_rename(tp);
|
2015-03-25 03:08:07 +00:00
|
|
|
|
|
|
|
out_trans_abort:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2014-12-23 21:51:42 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
/*
|
|
|
|
* xfs_rename_alloc_whiteout()
|
|
|
|
*
|
2020-08-05 15:49:58 +00:00
|
|
|
* Return a referenced, unlinked, unlocked inode that can be used as a
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
* whiteout in a rename transaction. We use a tmpfile inode here so that if we
|
|
|
|
* crash between allocating the inode and linking it into the rename transaction
|
|
|
|
* recovery will free the inode and we won't leak it.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_rename_alloc_whiteout(
|
2021-01-21 13:19:58 +00:00
|
|
|
struct user_namespace *mnt_userns,
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
struct xfs_inode *dp,
|
|
|
|
struct xfs_inode **wip)
|
|
|
|
{
|
|
|
|
struct xfs_inode *tmpfile;
|
|
|
|
int error;
|
|
|
|
|
2021-01-21 13:19:58 +00:00
|
|
|
error = xfs_create_tmpfile(mnt_userns, dp, S_IFCHR | WHITEOUT_MODE,
|
|
|
|
&tmpfile);
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2015-05-28 22:14:55 +00:00
|
|
|
/*
|
|
|
|
* Prepare the tmpfile inode as if it were created through the VFS.
|
xfs: don't ever put nlink > 0 inodes on the unlinked list
When XFS creates an O_TMPFILE file, the inode is created with nlink = 1,
put on the unlinked list, and then the VFS sets nlink = 0 in d_tmpfile.
If we crash before anything logs the inode (it's dirty incore but the
vfs doesn't tell us it's dirty so we never log that change), the iunlink
processing part of recovery will then explode with a pile of:
XFS: Assertion failed: VFS_I(ip)->i_nlink == 0, file:
fs/xfs/xfs_log_recover.c, line: 5072
Worse yet, since nlink is nonzero, the inodes also don't get cleaned up
and they just leak until the next xfs_repair run.
Therefore, change xfs_iunlink to require that inodes being put on the
unlinked list have nlink == 0, change the tmpfile callers to instantiate
nodes that way, and set the nlink to 1 just prior to calling d_tmpfile.
Fix the comment for xfs_iunlink while we're at it.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2019-02-13 19:15:17 +00:00
|
|
|
* Complete the inode setup and flag it as linkable. nlink is already
|
|
|
|
* zero, so we can skip the drop_nlink.
|
2015-05-28 22:14:55 +00:00
|
|
|
*/
|
2016-04-05 21:48:27 +00:00
|
|
|
xfs_setup_iops(tmpfile);
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
xfs_finish_inode_setup(tmpfile);
|
|
|
|
VFS_I(tmpfile)->i_state |= I_LINKABLE;
|
|
|
|
|
|
|
|
*wip = tmpfile;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:46 +00:00
|
|
|
/*
|
|
|
|
* xfs_rename
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_rename(
|
2021-01-21 13:19:58 +00:00
|
|
|
struct user_namespace *mnt_userns,
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
struct xfs_inode *src_dp,
|
|
|
|
struct xfs_name *src_name,
|
|
|
|
struct xfs_inode *src_ip,
|
|
|
|
struct xfs_inode *target_dp,
|
|
|
|
struct xfs_name *target_name,
|
|
|
|
struct xfs_inode *target_ip,
|
|
|
|
unsigned int flags)
|
2013-08-12 10:49:46 +00:00
|
|
|
{
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
struct xfs_mount *mp = src_dp->i_mount;
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
struct xfs_inode *wip = NULL; /* whiteout inode */
|
|
|
|
struct xfs_inode *inodes[__XFS_SORT_INODES];
|
2021-01-23 00:48:32 +00:00
|
|
|
int i;
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
int num_inodes = __XFS_SORT_INODES;
|
2015-03-25 04:12:30 +00:00
|
|
|
bool new_parent = (src_dp != target_dp);
|
2016-02-09 05:54:58 +00:00
|
|
|
bool src_is_directory = S_ISDIR(VFS_I(src_ip)->i_mode);
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
int spaceres;
|
|
|
|
int error;
|
2013-08-12 10:49:46 +00:00
|
|
|
|
|
|
|
trace_xfs_rename(src_dp, target_dp, src_name, target_name);
|
|
|
|
|
2015-03-25 03:08:07 +00:00
|
|
|
if ((flags & RENAME_EXCHANGE) && !target_ip)
|
|
|
|
return -EINVAL;
|
|
|
|
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
/*
|
|
|
|
* If we are doing a whiteout operation, allocate the whiteout inode
|
|
|
|
* we will be placing at the target and ensure the type is set
|
|
|
|
* appropriately.
|
|
|
|
*/
|
|
|
|
if (flags & RENAME_WHITEOUT) {
|
|
|
|
ASSERT(!(flags & (RENAME_NOREPLACE | RENAME_EXCHANGE)));
|
2021-01-21 13:19:58 +00:00
|
|
|
error = xfs_rename_alloc_whiteout(mnt_userns, target_dp, &wip);
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/* setup target dirent info as whiteout */
|
|
|
|
src_name->type = XFS_DIR3_FT_CHRDEV;
|
|
|
|
}
|
2013-08-12 10:49:46 +00:00
|
|
|
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
xfs_sort_for_rename(src_dp, target_dp, src_ip, target_ip, wip,
|
2013-08-12 10:49:46 +00:00
|
|
|
inodes, &num_inodes);
|
|
|
|
|
|
|
|
spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len);
|
2016-04-05 23:19:55 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, spaceres, 0, 0, &tp);
|
2014-06-25 04:58:08 +00:00
|
|
|
if (error == -ENOSPC) {
|
2013-08-12 10:49:46 +00:00
|
|
|
spaceres = 0;
|
2016-04-05 23:19:55 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, 0, 0, 0,
|
|
|
|
&tp);
|
2013-08-12 10:49:46 +00:00
|
|
|
}
|
2015-03-25 03:05:43 +00:00
|
|
|
if (error)
|
2016-04-05 23:19:55 +00:00
|
|
|
goto out_release_wip;
|
2013-08-12 10:49:46 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Attach the dquots to the inodes
|
|
|
|
*/
|
|
|
|
error = xfs_qm_vop_rename_dqattach(inodes);
|
2015-03-25 03:05:43 +00:00
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:46 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock all the participating inodes. Depending upon whether
|
|
|
|
* the target_name exists in the target directory, and
|
|
|
|
* whether the target directory is the same as the source
|
|
|
|
* directory, we can lock from 2 to 4 inodes.
|
|
|
|
*/
|
|
|
|
xfs_lock_inodes(inodes, num_inodes, XFS_ILOCK_EXCL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Join all the inodes to the transaction. From this point on,
|
|
|
|
* we can rely on either trans_commit or trans_cancel to unlock
|
|
|
|
* them.
|
|
|
|
*/
|
2016-11-30 03:33:25 +00:00
|
|
|
xfs_trans_ijoin(tp, src_dp, XFS_ILOCK_EXCL);
|
2013-08-12 10:49:46 +00:00
|
|
|
if (new_parent)
|
2016-11-30 03:33:25 +00:00
|
|
|
xfs_trans_ijoin(tp, target_dp, XFS_ILOCK_EXCL);
|
2013-08-12 10:49:46 +00:00
|
|
|
xfs_trans_ijoin(tp, src_ip, XFS_ILOCK_EXCL);
|
|
|
|
if (target_ip)
|
|
|
|
xfs_trans_ijoin(tp, target_ip, XFS_ILOCK_EXCL);
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
if (wip)
|
|
|
|
xfs_trans_ijoin(tp, wip, XFS_ILOCK_EXCL);
|
2013-08-12 10:49:46 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are using project inheritance, we only allow renames
|
|
|
|
* into our tree when the project IDs are the same; else the
|
|
|
|
* tree quota mechanism would be circumvented.
|
|
|
|
*/
|
2021-03-29 18:11:44 +00:00
|
|
|
if (unlikely((target_dp->i_diflags & XFS_DIFLAG_PROJINHERIT) &&
|
2021-03-29 18:11:39 +00:00
|
|
|
target_dp->i_projid != src_ip->i_projid)) {
|
2014-06-25 04:58:08 +00:00
|
|
|
error = -EXDEV;
|
2015-03-25 03:05:43 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:46 +00:00
|
|
|
}
|
|
|
|
|
2015-03-25 03:08:07 +00:00
|
|
|
/* RENAME_EXCHANGE is unique from here on. */
|
|
|
|
if (flags & RENAME_EXCHANGE)
|
|
|
|
return xfs_cross_rename(tp, src_dp, src_name, src_ip,
|
|
|
|
target_dp, target_name, target_ip,
|
2018-07-12 05:26:20 +00:00
|
|
|
spaceres);
|
2014-12-23 21:51:42 +00:00
|
|
|
|
2013-08-12 10:49:46 +00:00
|
|
|
/*
|
2019-09-04 04:06:50 +00:00
|
|
|
* Check for expected errors before we dirty the transaction
|
|
|
|
* so we can return an error without a transaction abort.
|
2021-01-23 00:48:13 +00:00
|
|
|
*
|
|
|
|
* Extent count overflow check:
|
|
|
|
*
|
|
|
|
* From the perspective of src_dp, a rename operation is essentially a
|
|
|
|
* directory entry remove operation. Hence the only place where we check
|
|
|
|
* for extent count overflow for src_dp is in
|
|
|
|
* xfs_bmap_del_extent_real(). xfs_bmap_del_extent_real() returns
|
|
|
|
* -ENOSPC when it detects a possible extent count overflow and in
|
|
|
|
* response, the higher layers of directory handling code do the
|
|
|
|
* following:
|
|
|
|
* 1. Data/Free blocks: XFS lets these blocks linger until a
|
|
|
|
* future remove operation removes them.
|
|
|
|
* 2. Dabtree blocks: XFS swaps the blocks with the last block in the
|
|
|
|
* Leaf space and unmaps the last block.
|
|
|
|
*
|
|
|
|
* For target_dp, there are two cases depending on whether the
|
|
|
|
* destination directory entry exists or not.
|
|
|
|
*
|
|
|
|
* When destination directory entry does not exist (i.e. target_ip ==
|
|
|
|
* NULL), extent count overflow check is performed only when transaction
|
|
|
|
* has a non-zero sized space reservation associated with it. With a
|
|
|
|
* zero-sized space reservation, XFS allows a rename operation to
|
|
|
|
* continue only when the directory has sufficient free space in its
|
|
|
|
* data/leaf/free space blocks to hold the new entry.
|
|
|
|
*
|
|
|
|
* When destination directory entry exists (i.e. target_ip != NULL), all
|
|
|
|
* we need to do is change the inode number associated with the already
|
|
|
|
* existing entry. Hence there is no need to perform an extent count
|
|
|
|
* overflow check.
|
2013-08-12 10:49:46 +00:00
|
|
|
*/
|
|
|
|
if (target_ip == NULL) {
|
|
|
|
/*
|
|
|
|
* If there's no space reservation, check the entry will
|
|
|
|
* fit before actually inserting it.
|
|
|
|
*/
|
2014-09-09 01:57:52 +00:00
|
|
|
if (!spaceres) {
|
|
|
|
error = xfs_dir_canenter(tp, target_dp, target_name);
|
|
|
|
if (error)
|
2015-03-25 03:05:43 +00:00
|
|
|
goto out_trans_cancel;
|
2021-01-23 00:48:13 +00:00
|
|
|
} else {
|
|
|
|
error = xfs_iext_count_may_overflow(target_dp,
|
|
|
|
XFS_DATA_FORK,
|
|
|
|
XFS_IEXT_DIR_MANIP_CNT(mp));
|
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
2014-09-09 01:57:52 +00:00
|
|
|
}
|
2019-09-04 04:06:50 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If target exists and it's a directory, check that whether
|
|
|
|
* it can be destroyed.
|
|
|
|
*/
|
|
|
|
if (S_ISDIR(VFS_I(target_ip)->i_mode) &&
|
|
|
|
(!xfs_dir_isempty(target_ip) ||
|
|
|
|
(VFS_I(target_ip)->i_nlink > 2))) {
|
|
|
|
error = -EEXIST;
|
|
|
|
goto out_trans_cancel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-23 00:48:32 +00:00
|
|
|
/*
|
|
|
|
* Lock the AGI buffers we need to handle bumping the nlink of the
|
|
|
|
* whiteout inode off the unlinked list and to handle dropping the
|
|
|
|
* nlink of the target inode. Per locking order rules, do this in
|
|
|
|
* increasing AG order and before directory block allocation tries to
|
|
|
|
* grab AGFs because we grab AGIs before AGFs.
|
|
|
|
*
|
|
|
|
* The (vfs) caller must ensure that if src is a directory then
|
|
|
|
* target_ip is either null or an empty directory.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < num_inodes && inodes[i] != NULL; i++) {
|
|
|
|
if (inodes[i] == wip ||
|
|
|
|
(inodes[i] == target_ip &&
|
|
|
|
(VFS_I(target_ip)->i_nlink == 1 || src_is_directory))) {
|
|
|
|
struct xfs_buf *bp;
|
|
|
|
xfs_agnumber_t agno;
|
|
|
|
|
|
|
|
agno = XFS_INO_TO_AGNO(mp, inodes[i]->i_ino);
|
|
|
|
error = xfs_read_agi(mp, tp, agno, &bp);
|
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-04 04:06:50 +00:00
|
|
|
/*
|
|
|
|
* Directory entry creation below may acquire the AGF. Remove
|
|
|
|
* the whiteout from the unlinked list first to preserve correct
|
|
|
|
* AGI/AGF locking order. This dirties the transaction so failures
|
|
|
|
* after this point will abort and log recovery will clean up the
|
|
|
|
* mess.
|
|
|
|
*
|
|
|
|
* For whiteouts, we need to bump the link count on the whiteout
|
|
|
|
* inode. After this point, we have a real link, clear the tmpfile
|
|
|
|
* state flag from the inode so it doesn't accidentally get misused
|
|
|
|
* in future.
|
|
|
|
*/
|
|
|
|
if (wip) {
|
2021-06-02 00:48:51 +00:00
|
|
|
struct xfs_perag *pag;
|
|
|
|
|
2019-09-04 04:06:50 +00:00
|
|
|
ASSERT(VFS_I(wip)->i_nlink == 0);
|
2021-06-02 00:48:51 +00:00
|
|
|
|
|
|
|
pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, wip->i_ino));
|
|
|
|
error = xfs_iunlink_remove(tp, pag, wip);
|
|
|
|
xfs_perag_put(pag);
|
2019-09-04 04:06:50 +00:00
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
|
|
|
|
|
|
|
xfs_bumplink(tp, wip);
|
|
|
|
VFS_I(wip)->i_state &= ~I_LINKABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up the target.
|
|
|
|
*/
|
|
|
|
if (target_ip == NULL) {
|
2013-08-12 10:49:46 +00:00
|
|
|
/*
|
|
|
|
* If target does not exist and the rename crosses
|
|
|
|
* directories, adjust the target directory link count
|
|
|
|
* to account for the ".." reference from the new entry.
|
|
|
|
*/
|
|
|
|
error = xfs_dir_createname(tp, target_dp, target_name,
|
2018-07-12 05:26:21 +00:00
|
|
|
src_ip->i_ino, spaceres);
|
2013-08-12 10:49:46 +00:00
|
|
|
if (error)
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:46 +00:00
|
|
|
|
|
|
|
xfs_trans_ichgtime(tp, target_dp,
|
|
|
|
XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
|
|
|
|
|
|
|
|
if (new_parent && src_is_directory) {
|
2019-05-02 03:26:30 +00:00
|
|
|
xfs_bumplink(tp, target_dp);
|
2013-08-12 10:49:46 +00:00
|
|
|
}
|
|
|
|
} else { /* target_ip != NULL */
|
|
|
|
/*
|
|
|
|
* Link the source inode under the target name.
|
|
|
|
* If the source inode is a directory and we are moving
|
|
|
|
* it across directories, its ".." entry will be
|
|
|
|
* inconsistent until we replace that down below.
|
|
|
|
*
|
|
|
|
* In case there is already an entry with the same
|
|
|
|
* name at the destination directory, remove it first.
|
|
|
|
*/
|
|
|
|
error = xfs_dir_replace(tp, target_dp, target_name,
|
2018-07-12 05:26:21 +00:00
|
|
|
src_ip->i_ino, spaceres);
|
2013-08-12 10:49:46 +00:00
|
|
|
if (error)
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:46 +00:00
|
|
|
|
|
|
|
xfs_trans_ichgtime(tp, target_dp,
|
|
|
|
XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decrement the link count on the target since the target
|
|
|
|
* dir no longer points to it.
|
|
|
|
*/
|
|
|
|
error = xfs_droplink(tp, target_ip);
|
|
|
|
if (error)
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:46 +00:00
|
|
|
|
|
|
|
if (src_is_directory) {
|
|
|
|
/*
|
|
|
|
* Drop the link from the old "." entry.
|
|
|
|
*/
|
|
|
|
error = xfs_droplink(tp, target_ip);
|
|
|
|
if (error)
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:46 +00:00
|
|
|
}
|
|
|
|
} /* target_ip != NULL */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove the source.
|
|
|
|
*/
|
|
|
|
if (new_parent && src_is_directory) {
|
|
|
|
/*
|
|
|
|
* Rewrite the ".." entry to point to the new
|
|
|
|
* directory.
|
|
|
|
*/
|
|
|
|
error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
|
2018-07-12 05:26:21 +00:00
|
|
|
target_dp->i_ino, spaceres);
|
2014-06-25 04:58:08 +00:00
|
|
|
ASSERT(error != -EEXIST);
|
2013-08-12 10:49:46 +00:00
|
|
|
if (error)
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We always want to hit the ctime on the source inode.
|
|
|
|
*
|
|
|
|
* This isn't strictly required by the standards since the source
|
|
|
|
* inode isn't really being changed, but old unix file systems did
|
|
|
|
* it and some incremental backup programs won't work without it.
|
|
|
|
*/
|
|
|
|
xfs_trans_ichgtime(tp, src_ip, XFS_ICHGTIME_CHG);
|
|
|
|
xfs_trans_log_inode(tp, src_ip, XFS_ILOG_CORE);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Adjust the link count on src_dp. This is necessary when
|
|
|
|
* renaming a directory, either within one parent when
|
|
|
|
* the target existed, or across two parent directories.
|
|
|
|
*/
|
|
|
|
if (src_is_directory && (new_parent || target_ip != NULL)) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decrement link count on src_directory since the
|
|
|
|
* entry that's moved no longer points to it.
|
|
|
|
*/
|
|
|
|
error = xfs_droplink(tp, src_dp);
|
|
|
|
if (error)
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:46 +00:00
|
|
|
}
|
|
|
|
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
/*
|
|
|
|
* For whiteouts, we only need to update the source dirent with the
|
|
|
|
* inode number of the whiteout inode rather than removing it
|
|
|
|
* altogether.
|
|
|
|
*/
|
|
|
|
if (wip) {
|
|
|
|
error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
|
2018-07-12 05:26:21 +00:00
|
|
|
spaceres);
|
2021-01-23 00:48:13 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* NOTE: We don't need to check for extent count overflow here
|
|
|
|
* because the dir remove name code will leave the dir block in
|
|
|
|
* place if the extent count would overflow.
|
|
|
|
*/
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
|
2018-07-12 05:26:21 +00:00
|
|
|
spaceres);
|
2021-01-23 00:48:13 +00:00
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:46 +00:00
|
|
|
if (error)
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2013-08-12 10:49:46 +00:00
|
|
|
|
|
|
|
xfs_trans_ichgtime(tp, src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
|
|
|
|
xfs_trans_log_inode(tp, src_dp, XFS_ILOG_CORE);
|
|
|
|
if (new_parent)
|
|
|
|
xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE);
|
|
|
|
|
2018-07-12 05:26:08 +00:00
|
|
|
error = xfs_finish_rename(tp);
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
if (wip)
|
2018-07-25 19:52:32 +00:00
|
|
|
xfs_irele(wip);
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
return error;
|
2013-08-12 10:49:46 +00:00
|
|
|
|
2015-03-25 03:05:43 +00:00
|
|
|
out_trans_cancel:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2016-04-05 23:19:55 +00:00
|
|
|
out_release_wip:
|
xfs: add RENAME_WHITEOUT support
Whiteouts are used by overlayfs - it has a crazy convention that a
whiteout is a character device inode with a major:minor of 0:0.
Because it's not documented anywhere, here's an example of what
RENAME_WHITEOUT does on ext4:
# echo foo > /mnt/scratch/foo
# echo bar > /mnt/scratch/bar
# ls -l /mnt/scratch
total 24
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
-rw-r--r-- 1 root root 4 Feb 11 20:22 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# src/renameat2 -w /mnt/scratch/foo /mnt/scratch/bar
# ls -l /mnt/scratch
total 20
-rw-r--r-- 1 root root 4 Feb 11 20:22 bar
c--------- 1 root root 0, 0 Feb 11 20:23 foo
drwx------ 2 root root 16384 Feb 11 20:18 lost+found
# cat /mnt/scratch/bar
foo
#
In XFS rename terms, the operation that has been done is that source
(foo) has been moved to the target (bar), which is like a nomal
rename operation, but rather than the source being removed, it have
been replaced with a whiteout.
We can't allocate whiteout inodes within the rename transaction due
to allocation being a multi-commit transaction: rename needs to
be a single, atomic commit. Hence we have several options here, form
most efficient to least efficient:
- use DT_WHT in the target dirent and do no whiteout inode
allocation. The main issue with this approach is that we need
hooks in lookup to create a virtual chardev inode to present
to userspace and in places where we might need to modify the
dirent e.g. unlink. Overlayfs also needs to be taught about
DT_WHT. Most invasive change, lowest overhead.
- create a special whiteout inode in the root directory (e.g. a
".wino" dirent) and then hardlink every new whiteout to it.
This means we only need to create a single whiteout inode, and
rename simply creates a hardlink to it. We can use DT_WHT for
these, though using DT_CHR means we won't have to modify
overlayfs, nor anything in userspace. Downside is we have to
look up the whiteout inode on every operation and create it if
it doesn't exist.
- copy ext4: create a special whiteout chardev inode for every
whiteout. This is more complex than the above options because
of the lack of atomicity between inode creation and the rename
operation, requiring us to create a tmpfile inode and then
linking it into the directory structure during the rename. At
least with a tmpfile inode crashes between the create and
rename doesn't leave unreferenced inodes or directory
pollution around.
By far the simplest thing to do in the short term is to copy ext4.
While it is the most inefficient way of supporting whiteouts, but as
an initial implementation we can simply reuse existing functions and
add a small amount of extra code the the rename operation.
When we get full whiteout support in the VFS (via the dentry cache)
we can then look to supporting DT_WHT method outlined as the first
method of supporting whiteouts. But until then, we'll stick with
what overlayfs expects us to be: dumb and stupid.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
2015-03-25 03:08:08 +00:00
|
|
|
if (wip)
|
2018-07-25 19:52:32 +00:00
|
|
|
xfs_irele(wip);
|
2013-08-12 10:49:46 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2020-06-29 21:49:19 +00:00
|
|
|
static int
|
|
|
|
xfs_iflush(
|
2013-04-03 05:11:17 +00:00
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_buf *bp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-04-03 05:11:17 +00:00
|
|
|
struct xfs_inode_log_item *iip = ip->i_itemp;
|
|
|
|
struct xfs_dinode *dip;
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2020-05-06 20:25:20 +00:00
|
|
|
int error;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-22 07:34:00 +00:00
|
|
|
ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
|
2020-08-17 23:41:01 +00:00
|
|
|
ASSERT(xfs_iflags_test(ip, XFS_IFLUSHING));
|
2020-05-18 17:28:05 +00:00
|
|
|
ASSERT(ip->i_df.if_format != XFS_DINODE_FMT_BTREE ||
|
2020-05-18 17:27:22 +00:00
|
|
|
ip->i_df.if_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
|
2020-06-29 21:49:19 +00:00
|
|
|
ASSERT(iip->ili_item.li_buf == bp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-06-21 23:44:29 +00:00
|
|
|
dip = xfs_buf_offset(bp, ip->i_imap.im_boffset);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-05-06 20:25:20 +00:00
|
|
|
/*
|
|
|
|
* We don't flush the inode if any of the following checks fail, but we
|
|
|
|
* do still update the log item and attach to the backing buffer as if
|
|
|
|
* the flush happened. This is a formality to facilitate predictable
|
|
|
|
* error handling as the caller will shutdown and fail the buffer.
|
|
|
|
*/
|
|
|
|
error = -EFSCORRUPTED;
|
2011-07-08 12:36:05 +00:00
|
|
|
if (XFS_TEST_ERROR(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC),
|
2017-06-21 00:54:47 +00:00
|
|
|
mp, XFS_ERRTAG_IFLUSH_1)) {
|
2011-03-06 23:02:35 +00:00
|
|
|
xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
|
2018-01-09 20:02:55 +00:00
|
|
|
"%s: Bad inode %Lu magic number 0x%x, ptr "PTR_FMT,
|
2011-03-06 23:02:35 +00:00
|
|
|
__func__, ip->i_ino, be16_to_cpu(dip->di_magic), dip);
|
2020-05-06 20:25:20 +00:00
|
|
|
goto flush_out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-02-09 05:54:58 +00:00
|
|
|
if (S_ISREG(VFS_I(ip)->i_mode)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (XFS_TEST_ERROR(
|
2020-05-18 17:28:05 +00:00
|
|
|
ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS &&
|
|
|
|
ip->i_df.if_format != XFS_DINODE_FMT_BTREE,
|
2017-06-21 00:54:47 +00:00
|
|
|
mp, XFS_ERRTAG_IFLUSH_3)) {
|
2011-03-06 23:02:35 +00:00
|
|
|
xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
|
2018-01-09 20:02:55 +00:00
|
|
|
"%s: Bad regular inode %Lu, ptr "PTR_FMT,
|
2011-03-06 23:02:35 +00:00
|
|
|
__func__, ip->i_ino, ip);
|
2020-05-06 20:25:20 +00:00
|
|
|
goto flush_out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-02-09 05:54:58 +00:00
|
|
|
} else if (S_ISDIR(VFS_I(ip)->i_mode)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (XFS_TEST_ERROR(
|
2020-05-18 17:28:05 +00:00
|
|
|
ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS &&
|
|
|
|
ip->i_df.if_format != XFS_DINODE_FMT_BTREE &&
|
|
|
|
ip->i_df.if_format != XFS_DINODE_FMT_LOCAL,
|
2017-06-21 00:54:47 +00:00
|
|
|
mp, XFS_ERRTAG_IFLUSH_4)) {
|
2011-03-06 23:02:35 +00:00
|
|
|
xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
|
2018-01-09 20:02:55 +00:00
|
|
|
"%s: Bad directory inode %Lu, ptr "PTR_FMT,
|
2011-03-06 23:02:35 +00:00
|
|
|
__func__, ip->i_ino, ip);
|
2020-05-06 20:25:20 +00:00
|
|
|
goto flush_out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2020-05-18 17:27:22 +00:00
|
|
|
if (XFS_TEST_ERROR(ip->i_df.if_nextents + xfs_ifork_nextents(ip->i_afp) >
|
2021-03-29 18:11:40 +00:00
|
|
|
ip->i_nblocks, mp, XFS_ERRTAG_IFLUSH_5)) {
|
2011-03-06 23:02:35 +00:00
|
|
|
xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
|
|
|
|
"%s: detected corrupt incore inode %Lu, "
|
2018-01-09 20:02:55 +00:00
|
|
|
"total extents = %d, nblocks = %Ld, ptr "PTR_FMT,
|
2011-03-06 23:02:35 +00:00
|
|
|
__func__, ip->i_ino,
|
2020-05-18 17:27:22 +00:00
|
|
|
ip->i_df.if_nextents + xfs_ifork_nextents(ip->i_afp),
|
2021-03-29 18:11:40 +00:00
|
|
|
ip->i_nblocks, ip);
|
2020-05-06 20:25:20 +00:00
|
|
|
goto flush_out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2021-03-29 18:11:44 +00:00
|
|
|
if (XFS_TEST_ERROR(ip->i_forkoff > mp->m_sb.sb_inodesize,
|
2017-06-21 00:54:47 +00:00
|
|
|
mp, XFS_ERRTAG_IFLUSH_6)) {
|
2011-03-06 23:02:35 +00:00
|
|
|
xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
|
2018-01-09 20:02:55 +00:00
|
|
|
"%s: bad inode %Lu, forkoff 0x%x, ptr "PTR_FMT,
|
2021-03-29 18:11:44 +00:00
|
|
|
__func__, ip->i_ino, ip->i_forkoff, ip);
|
2020-05-06 20:25:20 +00:00
|
|
|
goto flush_out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
xfs: di_flushiter considered harmful
When we made all inode updates transactional, we no longer needed
the log recovery detection for inodes being newer on disk than the
transaction being replayed - it was redundant as replay of the log
would always result in the latest version of the inode would be on
disk. It was redundant, but left in place because it wasn't
considered to be a problem.
However, with the new "don't read inodes on create" optimisation,
flushiter has come back to bite us. Essentially, the optimisation
made always initialises flushiter to zero in the create transaction,
and so if we then crash and run recovery and the inode already on
disk has a non-zero flushiter it will skip recovery of that inode.
As a result, log recovery does the wrong thing and we end up with a
corrupt filesystem.
Because we have to support old kernel to new kernel upgrades, we
can't just get rid of the flushiter support in log recovery as we
might be upgrading from a kernel that doesn't have fully transactional
inode updates. Unfortunately, for v4 superblocks there is no way to
guarantee that log recovery knows about this fact.
We cannot add a new inode format flag to say it's a "special inode
create" because it won't be understood by older kernels and so
recovery could do the wrong thing on downgrade. We cannot specially
detect the combination of zero mode/non-zero flushiter on disk to
non-zero mode, zero flushiter in the log item during recovery
because wrapping of the flushiter can result in false detection.
Hence that makes this "don't use flushiter" optimisation limited to
a disk format that guarantees that we don't need it. And that means
the only fix here is to limit the "no read IO on create"
optimisation to version 5 superblocks....
Reported-by: Markus Trippelsdorf <markus@trippelsdorf.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-07-24 05:47:30 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2021-03-29 18:11:42 +00:00
|
|
|
* Inode item log recovery for v2 inodes are dependent on the flushiter
|
|
|
|
* count for correct sequencing. We bump the flush iteration count so
|
|
|
|
* we can detect flushes which postdate a log record during recovery.
|
|
|
|
* This is redundant as we now log every change and hence this can't
|
|
|
|
* happen but we need to still do it to ensure backwards compatibility
|
|
|
|
* with old kernels that predate logging all inode changes.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2020-03-18 15:15:11 +00:00
|
|
|
if (!xfs_sb_version_has_v3inode(&mp->m_sb))
|
2021-03-29 18:11:42 +00:00
|
|
|
ip->i_flushiter++;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-05-14 21:01:31 +00:00
|
|
|
/*
|
|
|
|
* If there are inline format data / attr forks attached to this inode,
|
|
|
|
* make sure they are not corrupt.
|
|
|
|
*/
|
2020-05-18 17:28:05 +00:00
|
|
|
if (ip->i_df.if_format == XFS_DINODE_FMT_LOCAL &&
|
2020-05-14 21:01:31 +00:00
|
|
|
xfs_ifork_verify_local_data(ip))
|
|
|
|
goto flush_out;
|
2020-05-18 17:28:05 +00:00
|
|
|
if (ip->i_afp && ip->i_afp->if_format == XFS_DINODE_FMT_LOCAL &&
|
2020-05-14 21:01:31 +00:00
|
|
|
xfs_ifork_verify_local_attr(ip))
|
2020-05-06 20:25:20 +00:00
|
|
|
goto flush_out;
|
2017-03-28 21:51:10 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2016-02-09 05:54:58 +00:00
|
|
|
* Copy the dirty parts of the inode into the on-disk inode. We always
|
|
|
|
* copy out the core of the inode, because if the inode is dirty at all
|
|
|
|
* the core must be.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2016-02-09 05:54:58 +00:00
|
|
|
xfs_inode_to_disk(ip, dip, iip->ili_item.li_lsn);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Wrap, we never let the log put out DI_MAX_FLUSH */
|
2021-03-29 18:11:43 +00:00
|
|
|
if (!xfs_sb_version_has_v3inode(&mp->m_sb)) {
|
|
|
|
if (ip->i_flushiter == DI_MAX_FLUSH)
|
|
|
|
ip->i_flushiter = 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-03-28 21:51:10 +00:00
|
|
|
xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK);
|
|
|
|
if (XFS_IFORK_Q(ip))
|
|
|
|
xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2012-02-29 09:53:54 +00:00
|
|
|
* We've recorded everything logged in the inode, so we'd like to clear
|
|
|
|
* the ili_fields bits so we don't log and flush things unnecessarily.
|
|
|
|
* However, we can't stop logging all this information until the data
|
|
|
|
* we've copied into the disk buffer is written to disk. If we did we
|
|
|
|
* might overwrite the copy of the inode in the log with all the data
|
|
|
|
* after re-logging only part of it, and in the face of a crash we
|
|
|
|
* wouldn't have all the data we need to recover.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2012-02-29 09:53:54 +00:00
|
|
|
* What we do is move the bits to the ili_last_fields field. When
|
|
|
|
* logging the inode, these bits are moved back to the ili_fields field.
|
2020-09-01 17:55:29 +00:00
|
|
|
* In the xfs_buf_inode_iodone() routine we clear ili_last_fields, since
|
|
|
|
* we know that the information those bits represent is permanently on
|
2012-02-29 09:53:54 +00:00
|
|
|
* disk. As long as the flush completes before the inode is logged
|
|
|
|
* again, then both ili_fields and ili_last_fields will be cleared.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2020-05-06 20:25:20 +00:00
|
|
|
error = 0;
|
|
|
|
flush_out:
|
2020-06-29 21:48:46 +00:00
|
|
|
spin_lock(&iip->ili_lock);
|
2013-04-03 05:11:17 +00:00
|
|
|
iip->ili_last_fields = iip->ili_fields;
|
|
|
|
iip->ili_fields = 0;
|
xfs: optimise away log forces on timestamp updates for fdatasync
xfs: timestamp updates cause excessive fdatasync log traffic
Sage Weil reported that a ceph test workload was writing to the
log on every fdatasync during an overwrite workload. Event tracing
showed that the only metadata modification being made was the
timestamp updates during the write(2) syscall, but fdatasync(2)
is supposed to ignore them. The key observation was that the
transactions in the log all looked like this:
INODE: #regs: 4 ino: 0x8b flags: 0x45 dsize: 32
And contained a flags field of 0x45 or 0x85, and had data and
attribute forks following the inode core. This means that the
timestamp updates were triggering dirty relogging of previously
logged parts of the inode that hadn't yet been flushed back to
disk.
There are two parts to this problem. The first is that XFS relogs
dirty regions in subsequent transactions, so it carries around the
fields that have been dirtied since the last time the inode was
written back to disk, not since the last time the inode was forced
into the log.
The second part is that on v5 filesystems, the inode change count
update during inode dirtying also sets the XFS_ILOG_CORE flag, so
on v5 filesystems this makes a timestamp update dirty the entire
inode.
As a result when fdatasync is run, it looks at the dirty fields in
the inode, and sees more than just the timestamp flag, even though
the only metadata change since the last fdatasync was just the
timestamps. Hence we force the log on every subsequent fdatasync
even though it is not needed.
To fix this, add a new field to the inode log item that tracks
changes since the last time fsync/fdatasync forced the log to flush
the changes to the journal. This flag is updated when we dirty the
inode, but we do it before updating the change count so it does not
carry the "core dirty" flag from timestamp updates. The fields are
zeroed when the inode is marked clean (due to writeback/freeing) or
when an fsync/datasync forces the log. Hence if we only dirty the
timestamps on the inode between fsync/fdatasync calls, the fdatasync
will not trigger another log force.
Over 100 runs of the test program:
Ext4 baseline:
runtime: 1.63s +/- 0.24s
avg lat: 1.59ms +/- 0.24ms
iops: ~2000
XFS, vanilla kernel:
runtime: 2.45s +/- 0.18s
avg lat: 2.39ms +/- 0.18ms
log forces: ~400/s
iops: ~1000
XFS, patched kernel:
runtime: 1.49s +/- 0.26s
avg lat: 1.46ms +/- 0.25ms
log forces: ~30/s
iops: ~1500
Reported-by: Sage Weil <sage@redhat.com>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-11-03 02:14:59 +00:00
|
|
|
iip->ili_fsync_fields = 0;
|
2020-06-29 21:48:46 +00:00
|
|
|
spin_unlock(&iip->ili_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-06-29 21:48:46 +00:00
|
|
|
/*
|
|
|
|
* Store the current LSN of the inode so that we can tell whether the
|
2020-09-01 17:55:29 +00:00
|
|
|
* item has moved in the AIL from xfs_buf_inode_iodone().
|
2020-06-29 21:48:46 +00:00
|
|
|
*/
|
2013-04-03 05:11:17 +00:00
|
|
|
xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
|
|
|
|
&iip->ili_item.li_lsn);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-04-03 05:11:17 +00:00
|
|
|
/* generate the checksum. */
|
|
|
|
xfs_dinode_calc_crc(mp, dip);
|
2020-05-06 20:25:20 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2018-07-25 19:52:32 +00:00
|
|
|
|
2020-06-29 21:49:19 +00:00
|
|
|
/*
|
|
|
|
* Non-blocking flush of dirty inode metadata into the backing buffer.
|
|
|
|
*
|
|
|
|
* The caller must have a reference to the inode and hold the cluster buffer
|
|
|
|
* locked. The function will walk across all the inodes on the cluster buffer it
|
|
|
|
* can find and lock without blocking, and flush them to the cluster buffer.
|
|
|
|
*
|
2020-06-29 21:49:20 +00:00
|
|
|
* On successful flushing of at least one inode, the caller must write out the
|
|
|
|
* buffer and release it. If no inodes are flushed, -EAGAIN will be returned and
|
|
|
|
* the caller needs to release the buffer. On failure, the filesystem will be
|
|
|
|
* shut down, the buffer will have been unlocked and released, and EFSCORRUPTED
|
|
|
|
* will be returned.
|
2020-06-29 21:49:19 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_iflush_cluster(
|
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
2020-06-29 21:49:20 +00:00
|
|
|
struct xfs_mount *mp = bp->b_mount;
|
|
|
|
struct xfs_log_item *lip, *n;
|
|
|
|
struct xfs_inode *ip;
|
|
|
|
struct xfs_inode_log_item *iip;
|
2020-06-29 21:49:19 +00:00
|
|
|
int clcount = 0;
|
2020-06-29 21:49:20 +00:00
|
|
|
int error = 0;
|
2020-06-29 21:49:19 +00:00
|
|
|
|
2020-06-29 21:49:20 +00:00
|
|
|
/*
|
|
|
|
* We must use the safe variant here as on shutdown xfs_iflush_abort()
|
|
|
|
* can remove itself from the list.
|
|
|
|
*/
|
|
|
|
list_for_each_entry_safe(lip, n, &bp->b_li_list, li_bio_list) {
|
|
|
|
iip = (struct xfs_inode_log_item *)lip;
|
|
|
|
ip = iip->ili_inode;
|
2020-06-29 21:49:19 +00:00
|
|
|
|
|
|
|
/*
|
2020-06-29 21:49:20 +00:00
|
|
|
* Quick and dirty check to avoid locks if possible.
|
2020-06-29 21:49:19 +00:00
|
|
|
*/
|
2020-08-17 23:41:01 +00:00
|
|
|
if (__xfs_iflags_test(ip, XFS_IRECLAIM | XFS_IFLUSHING))
|
2020-06-29 21:49:20 +00:00
|
|
|
continue;
|
|
|
|
if (xfs_ipincount(ip))
|
2020-06-29 21:49:19 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
2020-06-29 21:49:20 +00:00
|
|
|
* The inode is still attached to the buffer, which means it is
|
|
|
|
* dirty but reclaim might try to grab it. Check carefully for
|
|
|
|
* that, and grab the ilock while still holding the i_flags_lock
|
|
|
|
* to guarantee reclaim will not be able to reclaim this inode
|
|
|
|
* once we drop the i_flags_lock.
|
2020-06-29 21:49:19 +00:00
|
|
|
*/
|
2020-06-29 21:49:20 +00:00
|
|
|
spin_lock(&ip->i_flags_lock);
|
|
|
|
ASSERT(!__xfs_iflags_test(ip, XFS_ISTALE));
|
2020-08-17 23:41:01 +00:00
|
|
|
if (__xfs_iflags_test(ip, XFS_IRECLAIM | XFS_IFLUSHING)) {
|
2020-06-29 21:49:20 +00:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
continue;
|
2020-06-29 21:49:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2020-06-29 21:49:20 +00:00
|
|
|
* ILOCK will pin the inode against reclaim and prevent
|
|
|
|
* concurrent transactions modifying the inode while we are
|
2020-08-17 23:41:01 +00:00
|
|
|
* flushing the inode. If we get the lock, set the flushing
|
|
|
|
* state before we drop the i_flags_lock.
|
2020-06-29 21:49:19 +00:00
|
|
|
*/
|
2020-06-29 21:49:20 +00:00
|
|
|
if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) {
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2020-06-29 21:49:19 +00:00
|
|
|
continue;
|
2020-06-29 21:49:20 +00:00
|
|
|
}
|
2020-08-17 23:41:01 +00:00
|
|
|
__xfs_iflags_set(ip, XFS_IFLUSHING);
|
2020-06-29 21:49:20 +00:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2020-06-29 21:49:19 +00:00
|
|
|
|
|
|
|
/*
|
2020-06-29 21:49:20 +00:00
|
|
|
* Abort flushing this inode if we are shut down because the
|
|
|
|
* inode may not currently be in the AIL. This can occur when
|
|
|
|
* log I/O failure unpins the inode without inserting into the
|
|
|
|
* AIL, leaving a dirty/unpinned inode attached to the buffer
|
|
|
|
* that otherwise looks like it should be flushed.
|
2020-06-29 21:49:19 +00:00
|
|
|
*/
|
2020-06-29 21:49:20 +00:00
|
|
|
if (XFS_FORCED_SHUTDOWN(mp)) {
|
|
|
|
xfs_iunpin_wait(ip);
|
|
|
|
xfs_iflush_abort(ip);
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_SHARED);
|
|
|
|
error = -EIO;
|
2020-06-29 21:49:19 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2020-06-29 21:49:20 +00:00
|
|
|
/* don't block waiting on a log force to unpin dirty inodes */
|
|
|
|
if (xfs_ipincount(ip)) {
|
2020-08-17 23:41:01 +00:00
|
|
|
xfs_iflags_clear(ip, XFS_IFLUSHING);
|
2020-06-29 21:49:20 +00:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_SHARED);
|
|
|
|
continue;
|
2020-06-29 21:49:19 +00:00
|
|
|
}
|
|
|
|
|
2020-06-29 21:49:20 +00:00
|
|
|
if (!xfs_inode_clean(ip))
|
|
|
|
error = xfs_iflush(ip, bp);
|
|
|
|
else
|
2020-08-17 23:41:01 +00:00
|
|
|
xfs_iflags_clear(ip, XFS_IFLUSHING);
|
2020-06-29 21:49:20 +00:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_SHARED);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
clcount++;
|
2020-06-29 21:49:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (error) {
|
|
|
|
bp->b_flags |= XBF_ASYNC;
|
|
|
|
xfs_buf_ioend_fail(bp);
|
|
|
|
xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
|
2020-06-29 21:49:20 +00:00
|
|
|
return error;
|
2020-06-29 21:49:19 +00:00
|
|
|
}
|
2020-06-29 21:49:20 +00:00
|
|
|
|
|
|
|
if (!clcount)
|
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
XFS_STATS_INC(mp, xs_icluster_flushcnt);
|
|
|
|
XFS_STATS_ADD(mp, xs_icluster_flushinode, clcount);
|
|
|
|
return 0;
|
|
|
|
|
2020-06-29 21:49:19 +00:00
|
|
|
}
|
|
|
|
|
2018-07-25 19:52:32 +00:00
|
|
|
/* Release an inode. */
|
|
|
|
void
|
|
|
|
xfs_irele(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
trace_xfs_irele(ip, _RET_IP_);
|
|
|
|
iput(VFS_I(ip));
|
|
|
|
}
|
2020-04-03 18:45:37 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Ensure all commited transactions touching the inode are written to the log.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_log_force_inode(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
2021-06-18 15:21:52 +00:00
|
|
|
xfs_csn_t seq = 0;
|
2020-04-03 18:45:37 +00:00
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_SHARED);
|
|
|
|
if (xfs_ipincount(ip))
|
2021-06-18 15:21:52 +00:00
|
|
|
seq = ip->i_itemp->ili_commit_seq;
|
2020-04-03 18:45:37 +00:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_SHARED);
|
|
|
|
|
2021-06-18 15:21:52 +00:00
|
|
|
if (!seq)
|
2020-04-03 18:45:37 +00:00
|
|
|
return 0;
|
2021-06-18 15:21:52 +00:00
|
|
|
return xfs_log_force_seq(ip->i_mount, seq, XFS_LOG_SYNC, NULL);
|
2020-04-03 18:45:37 +00:00
|
|
|
}
|
2020-06-29 21:47:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Grab the exclusive iolock for a data copy from src to dest, making sure to
|
|
|
|
* abide vfs locking order (lowest pointer value goes first) and breaking the
|
|
|
|
* layout leases before proceeding. The loop is needed because we cannot call
|
|
|
|
* the blocking break_layout() with the iolocks held, and therefore have to
|
|
|
|
* back out both locks.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_iolock_two_inodes_and_break_layout(
|
|
|
|
struct inode *src,
|
|
|
|
struct inode *dest)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (src > dest)
|
|
|
|
swap(src, dest);
|
|
|
|
|
|
|
|
retry:
|
|
|
|
/* Wait to break both inodes' layouts before we start locking. */
|
|
|
|
error = break_layout(src, true);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
if (src != dest) {
|
|
|
|
error = break_layout(dest, true);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Lock one inode and make sure nobody got in and leased it. */
|
|
|
|
inode_lock(src);
|
|
|
|
error = break_layout(src, false);
|
|
|
|
if (error) {
|
|
|
|
inode_unlock(src);
|
|
|
|
if (error == -EWOULDBLOCK)
|
|
|
|
goto retry;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (src == dest)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Lock the other inode and make sure nobody got in and leased it. */
|
|
|
|
inode_lock_nested(dest, I_MUTEX_NONDIR2);
|
|
|
|
error = break_layout(dest, false);
|
|
|
|
if (error) {
|
|
|
|
inode_unlock(src);
|
|
|
|
inode_unlock(dest);
|
|
|
|
if (error == -EWOULDBLOCK)
|
|
|
|
goto retry;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock two inodes so that userspace cannot initiate I/O via file syscalls or
|
|
|
|
* mmap activity.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_ilock2_io_mmap(
|
|
|
|
struct xfs_inode *ip1,
|
|
|
|
struct xfs_inode *ip2)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = xfs_iolock_two_inodes_and_break_layout(VFS_I(ip1), VFS_I(ip2));
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (ip1 == ip2)
|
|
|
|
xfs_ilock(ip1, XFS_MMAPLOCK_EXCL);
|
|
|
|
else
|
|
|
|
xfs_lock_two_inodes(ip1, XFS_MMAPLOCK_EXCL,
|
|
|
|
ip2, XFS_MMAPLOCK_EXCL);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Unlock both inodes to allow IO and mmap activity. */
|
|
|
|
void
|
|
|
|
xfs_iunlock2_io_mmap(
|
|
|
|
struct xfs_inode *ip1,
|
|
|
|
struct xfs_inode *ip2)
|
|
|
|
{
|
|
|
|
bool same_inode = (ip1 == ip2);
|
|
|
|
|
|
|
|
xfs_iunlock(ip2, XFS_MMAPLOCK_EXCL);
|
|
|
|
if (!same_inode)
|
|
|
|
xfs_iunlock(ip1, XFS_MMAPLOCK_EXCL);
|
|
|
|
inode_unlock(VFS_I(ip2));
|
|
|
|
if (!same_inode)
|
|
|
|
inode_unlock(VFS_I(ip1));
|
|
|
|
}
|