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.
|
2018-07-12 05:26:06 +00:00
|
|
|
* Copyright (c) 2016-2018 Christoph Hellwig.
|
2005-11-02 03:58:39 +00:00
|
|
|
* All Rights Reserved.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
|
|
|
#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"
|
|
|
|
#include "xfs_inode.h"
|
2005-11-02 03:38:42 +00:00
|
|
|
#include "xfs_btree.h"
|
2013-10-22 23:51:50 +00:00
|
|
|
#include "xfs_bmap_btree.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#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"
|
2013-10-22 23:51:50 +00:00
|
|
|
#include "xfs_trans.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_trans_space.h"
|
2017-11-01 15:36:47 +00:00
|
|
|
#include "xfs_inode_item.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_iomap.h"
|
2009-12-14 23:14:59 +00:00
|
|
|
#include "xfs_trace.h"
|
2013-10-22 23:51:50 +00:00
|
|
|
#include "xfs_quota.h"
|
2013-03-18 14:51:47 +00:00
|
|
|
#include "xfs_dquot_item.h"
|
|
|
|
#include "xfs_dquot.h"
|
2016-10-03 16:11:33 +00:00
|
|
|
#include "xfs_reflink.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
2019-10-28 15:41:44 +00:00
|
|
|
#define XFS_ALLOC_ALIGN(mp, off) \
|
|
|
|
(((off) >> mp->m_allocsize_log) << mp->m_allocsize_log)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-02-18 17:38:46 +00:00
|
|
|
static int
|
|
|
|
xfs_alert_fsblock_zero(
|
|
|
|
xfs_inode_t *ip,
|
|
|
|
xfs_bmbt_irec_t *imap)
|
|
|
|
{
|
|
|
|
xfs_alert_tag(ip->i_mount, XFS_PTAG_FSBLOCK_ZERO,
|
|
|
|
"Access to block zero in inode %llu "
|
|
|
|
"start_block: %llx start_off: %llx "
|
|
|
|
"blkcnt: %llx extent-state: %x",
|
|
|
|
(unsigned long long)ip->i_ino,
|
|
|
|
(unsigned long long)imap->br_startblock,
|
|
|
|
(unsigned long long)imap->br_startoff,
|
|
|
|
(unsigned long long)imap->br_blockcount,
|
|
|
|
imap->br_state);
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2016-09-19 01:09:12 +00:00
|
|
|
xfs_bmbt_to_iomap(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct iomap *iomap,
|
2019-02-18 17:38:46 +00:00
|
|
|
struct xfs_bmbt_irec *imap,
|
2019-10-17 20:12:02 +00:00
|
|
|
u16 flags)
|
2016-09-19 01:09:12 +00:00
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2019-10-25 05:25:38 +00:00
|
|
|
struct xfs_buftarg *target = xfs_inode_buftarg(ip);
|
2016-09-19 01:09:12 +00:00
|
|
|
|
2019-09-03 15:13:13 +00:00
|
|
|
if (unlikely(!xfs_valid_startblock(ip, imap->br_startblock)))
|
2019-02-18 17:38:46 +00:00
|
|
|
return xfs_alert_fsblock_zero(ip, imap);
|
|
|
|
|
2016-09-19 01:09:12 +00:00
|
|
|
if (imap->br_startblock == HOLESTARTBLOCK) {
|
2017-10-01 21:55:54 +00:00
|
|
|
iomap->addr = IOMAP_NULL_ADDR;
|
2016-09-19 01:09:12 +00:00
|
|
|
iomap->type = IOMAP_HOLE;
|
2019-02-18 17:38:46 +00:00
|
|
|
} else if (imap->br_startblock == DELAYSTARTBLOCK ||
|
|
|
|
isnullstartblock(imap->br_startblock)) {
|
2017-10-01 21:55:54 +00:00
|
|
|
iomap->addr = IOMAP_NULL_ADDR;
|
2016-09-19 01:09:12 +00:00
|
|
|
iomap->type = IOMAP_DELALLOC;
|
|
|
|
} else {
|
2017-10-01 21:55:54 +00:00
|
|
|
iomap->addr = BBTOB(xfs_fsb_to_db(ip, imap->br_startblock));
|
2016-09-19 01:09:12 +00:00
|
|
|
if (imap->br_state == XFS_EXT_UNWRITTEN)
|
|
|
|
iomap->type = IOMAP_UNWRITTEN;
|
|
|
|
else
|
|
|
|
iomap->type = IOMAP_MAPPED;
|
|
|
|
}
|
|
|
|
iomap->offset = XFS_FSB_TO_B(mp, imap->br_startoff);
|
|
|
|
iomap->length = XFS_FSB_TO_B(mp, imap->br_blockcount);
|
2019-10-25 05:25:38 +00:00
|
|
|
iomap->bdev = target->bt_bdev;
|
|
|
|
iomap->dax_dev = target->bt_daxdev;
|
2019-10-17 20:12:02 +00:00
|
|
|
iomap->flags = flags;
|
2019-02-18 17:38:46 +00:00
|
|
|
|
|
|
|
if (xfs_ipincount(ip) &&
|
|
|
|
(ip->i_itemp->ili_fsync_fields & ~XFS_ILOG_TIMESTAMP))
|
|
|
|
iomap->flags |= IOMAP_F_DIRTY;
|
|
|
|
return 0;
|
2016-09-19 01:09:12 +00:00
|
|
|
}
|
|
|
|
|
2018-10-18 06:19:26 +00:00
|
|
|
static void
|
|
|
|
xfs_hole_to_iomap(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct iomap *iomap,
|
|
|
|
xfs_fileoff_t offset_fsb,
|
|
|
|
xfs_fileoff_t end_fsb)
|
|
|
|
{
|
2019-10-25 05:25:38 +00:00
|
|
|
struct xfs_buftarg *target = xfs_inode_buftarg(ip);
|
|
|
|
|
2018-10-18 06:19:26 +00:00
|
|
|
iomap->addr = IOMAP_NULL_ADDR;
|
|
|
|
iomap->type = IOMAP_HOLE;
|
|
|
|
iomap->offset = XFS_FSB_TO_B(ip->i_mount, offset_fsb);
|
|
|
|
iomap->length = XFS_FSB_TO_B(ip->i_mount, end_fsb - offset_fsb);
|
2019-10-25 05:25:38 +00:00
|
|
|
iomap->bdev = target->bt_bdev;
|
|
|
|
iomap->dax_dev = target->bt_daxdev;
|
2018-10-18 06:19:26 +00:00
|
|
|
}
|
|
|
|
|
2019-10-19 16:09:44 +00:00
|
|
|
static inline xfs_fileoff_t
|
|
|
|
xfs_iomap_end_fsb(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
loff_t offset,
|
|
|
|
loff_t count)
|
|
|
|
{
|
|
|
|
ASSERT(offset <= mp->m_super->s_maxbytes);
|
|
|
|
return min(XFS_B_TO_FSB(mp, offset + count),
|
|
|
|
XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes));
|
|
|
|
}
|
|
|
|
|
2019-10-30 19:24:57 +00:00
|
|
|
static xfs_extlen_t
|
2016-09-19 01:09:28 +00:00
|
|
|
xfs_eof_alignment(
|
2019-10-30 19:24:58 +00:00
|
|
|
struct xfs_inode *ip)
|
2006-01-11 04:28:28 +00:00
|
|
|
{
|
2016-09-19 01:09:28 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
xfs_extlen_t align = 0;
|
2006-01-11 04:28:28 +00:00
|
|
|
|
2011-12-18 20:00:05 +00:00
|
|
|
if (!XFS_IS_REALTIME_INODE(ip)) {
|
|
|
|
/*
|
|
|
|
* Round up the allocation request to a stripe unit
|
|
|
|
* (m_dalign) boundary if the file size is >= stripe unit
|
|
|
|
* size, and we are allocating past the allocation eof.
|
|
|
|
*
|
|
|
|
* If mounted with the "-o swalloc" option the alignment is
|
|
|
|
* increased from the strip unit size to the stripe width.
|
|
|
|
*/
|
|
|
|
if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC))
|
|
|
|
align = mp->m_swidth;
|
|
|
|
else if (mp->m_dalign)
|
|
|
|
align = mp->m_dalign;
|
|
|
|
|
2014-12-03 22:30:51 +00:00
|
|
|
if (align && XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, align))
|
|
|
|
align = 0;
|
2011-12-18 20:00:05 +00:00
|
|
|
}
|
2006-01-11 04:28:28 +00:00
|
|
|
|
2016-09-19 01:09:28 +00:00
|
|
|
return align;
|
|
|
|
}
|
|
|
|
|
2019-10-30 19:24:57 +00:00
|
|
|
/*
|
|
|
|
* Check if last_fsb is outside the last extent, and if so grow it to the next
|
|
|
|
* stripe unit boundary.
|
|
|
|
*/
|
2019-10-30 19:24:59 +00:00
|
|
|
xfs_fileoff_t
|
2016-09-19 01:09:28 +00:00
|
|
|
xfs_iomap_eof_align_last_fsb(
|
|
|
|
struct xfs_inode *ip,
|
2019-10-30 19:24:57 +00:00
|
|
|
xfs_fileoff_t end_fsb)
|
2016-09-19 01:09:28 +00:00
|
|
|
{
|
2019-10-30 19:24:57 +00:00
|
|
|
struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
|
|
|
|
xfs_extlen_t extsz = xfs_get_extsz_hint(ip);
|
2019-10-30 19:24:58 +00:00
|
|
|
xfs_extlen_t align = xfs_eof_alignment(ip);
|
2019-10-30 19:24:57 +00:00
|
|
|
struct xfs_bmbt_irec irec;
|
|
|
|
struct xfs_iext_cursor icur;
|
|
|
|
|
2021-04-13 18:15:12 +00:00
|
|
|
ASSERT(!xfs_need_iread_extents(ifp));
|
2016-09-19 01:09:28 +00:00
|
|
|
|
2019-10-30 19:24:58 +00:00
|
|
|
/*
|
|
|
|
* Always round up the allocation request to the extent hint boundary.
|
|
|
|
*/
|
|
|
|
if (extsz) {
|
|
|
|
if (align)
|
|
|
|
align = roundup_64(align, extsz);
|
|
|
|
else
|
|
|
|
align = extsz;
|
|
|
|
}
|
|
|
|
|
2014-12-03 22:30:51 +00:00
|
|
|
if (align) {
|
2019-10-30 19:24:57 +00:00
|
|
|
xfs_fileoff_t aligned_end_fsb = roundup_64(end_fsb, align);
|
|
|
|
|
|
|
|
xfs_iext_last(ifp, &icur);
|
|
|
|
if (!xfs_iext_get_extent(ifp, &icur, &irec) ||
|
|
|
|
aligned_end_fsb >= irec.br_startoff + irec.br_blockcount)
|
|
|
|
return aligned_end_fsb;
|
2006-01-11 04:28:28 +00:00
|
|
|
}
|
2019-10-30 19:24:57 +00:00
|
|
|
|
|
|
|
return end_fsb;
|
2006-01-11 04:28:28 +00:00
|
|
|
}
|
|
|
|
|
2010-12-10 08:42:20 +00:00
|
|
|
int
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_iomap_write_direct(
|
2019-10-30 19:24:59 +00:00
|
|
|
struct xfs_inode *ip,
|
|
|
|
xfs_fileoff_t offset_fsb,
|
|
|
|
xfs_fileoff_t count_fsb,
|
|
|
|
struct xfs_bmbt_irec *imap)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2019-10-30 19:24:59 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
xfs_filblks_t resaligned;
|
|
|
|
int nimaps;
|
2021-01-27 01:20:42 +00:00
|
|
|
unsigned int dblocks, rblocks;
|
2021-01-27 00:44:07 +00:00
|
|
|
bool force = false;
|
2019-10-30 19:24:59 +00:00
|
|
|
int error;
|
|
|
|
int bmapi_flags = XFS_BMAPI_PREALLOC;
|
2021-03-25 18:48:18 +00:00
|
|
|
int nr_exts = XFS_IEXT_ADD_NOSPLIT_CNT;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-11 04:28:28 +00:00
|
|
|
ASSERT(count_fsb > 0);
|
|
|
|
|
2019-10-30 19:24:59 +00:00
|
|
|
resaligned = xfs_aligned_fsb_count(offset_fsb, count_fsb,
|
|
|
|
xfs_get_extsz_hint(ip));
|
|
|
|
if (unlikely(XFS_IS_REALTIME_INODE(ip))) {
|
2021-01-27 01:20:42 +00:00
|
|
|
dblocks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
|
|
|
|
rblocks = resaligned;
|
2007-06-18 06:50:27 +00:00
|
|
|
} else {
|
2021-01-27 01:20:42 +00:00
|
|
|
dblocks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
|
|
|
|
rblocks = 0;
|
2007-06-18 06:50:27 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-05-04 22:30:21 +00:00
|
|
|
error = xfs_qm_dqattach(ip);
|
2015-10-12 04:34:20 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
xfs: Don't use unwritten extents for DAX
DAX has a page fault serialisation problem with block allocation.
Because it allows concurrent page faults and does not have a page
lock to serialise faults to the same page, it can get two concurrent
faults to the page that race.
When two read faults race, this isn't a huge problem as the data
underlying the page is not changing and so "detect and drop" works
just fine. The issues are to do with write faults.
When two write faults occur, we serialise block allocation in
get_blocks() so only one faul will allocate the extent. It will,
however, be marked as an unwritten extent, and that is where the
problem lies - the DAX fault code cannot differentiate between a
block that was just allocated and a block that was preallocated and
needs zeroing. The result is that both write faults end up zeroing
the block and attempting to convert it back to written.
The problem is that the first fault can zero and convert before the
second fault starts zeroing, resulting in the zeroing for the second
fault overwriting the data that the first fault wrote with zeros.
The second fault then attempts to convert the unwritten extent,
which is then a no-op because it's already written. Data loss occurs
as a result of this race.
Because there is no sane locking construct in the page fault code
that we can use for serialisation across the page faults, we need to
ensure block allocation and zeroing occurs atomically in the
filesystem. This means we can still take concurrent page faults and
the only time they will serialise is in the filesystem
mapping/allocation callback. The page fault code will always see
written, initialised extents, so we will be able to remove the
unwritten extent handling from the DAX code when all filesystems are
converted.
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 01:37:00 +00:00
|
|
|
/*
|
|
|
|
* For DAX, we do not allocate unwritten extents, but instead we zero
|
|
|
|
* the block before we commit the transaction. Ideally we'd like to do
|
|
|
|
* this outside the transaction context, but if we commit and then crash
|
|
|
|
* we may not have zeroed the blocks and this will be exposed on
|
|
|
|
* recovery of the allocation. Hence we must zero before commit.
|
2016-01-04 05:22:45 +00:00
|
|
|
*
|
xfs: Don't use unwritten extents for DAX
DAX has a page fault serialisation problem with block allocation.
Because it allows concurrent page faults and does not have a page
lock to serialise faults to the same page, it can get two concurrent
faults to the page that race.
When two read faults race, this isn't a huge problem as the data
underlying the page is not changing and so "detect and drop" works
just fine. The issues are to do with write faults.
When two write faults occur, we serialise block allocation in
get_blocks() so only one faul will allocate the extent. It will,
however, be marked as an unwritten extent, and that is where the
problem lies - the DAX fault code cannot differentiate between a
block that was just allocated and a block that was preallocated and
needs zeroing. The result is that both write faults end up zeroing
the block and attempting to convert it back to written.
The problem is that the first fault can zero and convert before the
second fault starts zeroing, resulting in the zeroing for the second
fault overwriting the data that the first fault wrote with zeros.
The second fault then attempts to convert the unwritten extent,
which is then a no-op because it's already written. Data loss occurs
as a result of this race.
Because there is no sane locking construct in the page fault code
that we can use for serialisation across the page faults, we need to
ensure block allocation and zeroing occurs atomically in the
filesystem. This means we can still take concurrent page faults and
the only time they will serialise is in the filesystem
mapping/allocation callback. The page fault code will always see
written, initialised extents, so we will be able to remove the
unwritten extent handling from the DAX code when all filesystems are
converted.
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 01:37:00 +00:00
|
|
|
* Further, if we are mapping unwritten extents here, we need to zero
|
|
|
|
* and convert them to written so that we don't need an unwritten extent
|
|
|
|
* callback for DAX. This also means that we need to be able to dip into
|
2016-01-04 05:22:45 +00:00
|
|
|
* the reserve block pool for bmbt block allocation if there is no space
|
|
|
|
* left but we need to do unwritten extent conversion.
|
xfs: Don't use unwritten extents for DAX
DAX has a page fault serialisation problem with block allocation.
Because it allows concurrent page faults and does not have a page
lock to serialise faults to the same page, it can get two concurrent
faults to the page that race.
When two read faults race, this isn't a huge problem as the data
underlying the page is not changing and so "detect and drop" works
just fine. The issues are to do with write faults.
When two write faults occur, we serialise block allocation in
get_blocks() so only one faul will allocate the extent. It will,
however, be marked as an unwritten extent, and that is where the
problem lies - the DAX fault code cannot differentiate between a
block that was just allocated and a block that was preallocated and
needs zeroing. The result is that both write faults end up zeroing
the block and attempting to convert it back to written.
The problem is that the first fault can zero and convert before the
second fault starts zeroing, resulting in the zeroing for the second
fault overwriting the data that the first fault wrote with zeros.
The second fault then attempts to convert the unwritten extent,
which is then a no-op because it's already written. Data loss occurs
as a result of this race.
Because there is no sane locking construct in the page fault code
that we can use for serialisation across the page faults, we need to
ensure block allocation and zeroing occurs atomically in the
filesystem. This means we can still take concurrent page faults and
the only time they will serialise is in the filesystem
mapping/allocation callback. The page fault code will always see
written, initialised extents, so we will be able to remove the
unwritten extent handling from the DAX code when all filesystems are
converted.
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 01:37:00 +00:00
|
|
|
*/
|
|
|
|
if (IS_DAX(VFS_I(ip))) {
|
|
|
|
bmapi_flags = XFS_BMAPI_CONVERT | XFS_BMAPI_ZERO;
|
2017-03-28 21:53:36 +00:00
|
|
|
if (imap->br_state == XFS_EXT_UNWRITTEN) {
|
2021-01-27 01:20:42 +00:00
|
|
|
force = true;
|
2021-03-25 18:48:18 +00:00
|
|
|
nr_exts = XFS_IEXT_WRITE_UNWRITTEN_CNT;
|
2021-01-27 01:20:42 +00:00
|
|
|
dblocks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
|
2016-01-04 05:22:45 +00:00
|
|
|
}
|
xfs: Don't use unwritten extents for DAX
DAX has a page fault serialisation problem with block allocation.
Because it allows concurrent page faults and does not have a page
lock to serialise faults to the same page, it can get two concurrent
faults to the page that race.
When two read faults race, this isn't a huge problem as the data
underlying the page is not changing and so "detect and drop" works
just fine. The issues are to do with write faults.
When two write faults occur, we serialise block allocation in
get_blocks() so only one faul will allocate the extent. It will,
however, be marked as an unwritten extent, and that is where the
problem lies - the DAX fault code cannot differentiate between a
block that was just allocated and a block that was preallocated and
needs zeroing. The result is that both write faults end up zeroing
the block and attempting to convert it back to written.
The problem is that the first fault can zero and convert before the
second fault starts zeroing, resulting in the zeroing for the second
fault overwriting the data that the first fault wrote with zeros.
The second fault then attempts to convert the unwritten extent,
which is then a no-op because it's already written. Data loss occurs
as a result of this race.
Because there is no sane locking construct in the page fault code
that we can use for serialisation across the page faults, we need to
ensure block allocation and zeroing occurs atomically in the
filesystem. This means we can still take concurrent page faults and
the only time they will serialise is in the filesystem
mapping/allocation callback. The page fault code will always see
written, initialised extents, so we will be able to remove the
unwritten extent handling from the DAX code when all filesystems are
converted.
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 01:37:00 +00:00
|
|
|
}
|
2012-03-27 14:34:50 +00:00
|
|
|
|
2021-01-27 00:44:07 +00:00
|
|
|
error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write, dblocks,
|
|
|
|
rblocks, force, &tp);
|
2016-04-05 23:19:55 +00:00
|
|
|
if (error)
|
2014-06-22 05:04:54 +00:00
|
|
|
return error;
|
2012-03-27 14:34:50 +00:00
|
|
|
|
2021-03-25 18:48:18 +00:00
|
|
|
error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK, nr_exts);
|
2006-01-11 04:28:28 +00:00
|
|
|
if (error)
|
2012-03-27 14:34:50 +00:00
|
|
|
goto out_trans_cancel;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2010-06-24 01:42:19 +00:00
|
|
|
* From this point onwards we overwrite the imap pointer that the
|
|
|
|
* caller gave to us.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2005-06-21 05:48:47 +00:00
|
|
|
nimaps = 1;
|
xfs: don't set bmapi total block req where minleft is
xfs_bmapi_write() takes a total block requirement parameter that is
passed down to the block allocation code and is used to specify the
total block requirement of the associated transaction. This is used
to try and select an AG that can not only satisfy the requested
extent allocation, but can also accommodate subsequent allocations
that might be required to complete the transaction. For example,
additional bmbt block allocations may be required on insertion of
the resulting extent to an inode data fork.
While it's important for callers to calculate and reserve such extra
blocks in the transaction, it is not necessary to pass the total
value to xfs_bmapi_write() in all cases. The latter automatically
sets minleft to ensure that sufficient free blocks remain after the
allocation attempt to expand the format of the associated inode
(i.e., such as extent to btree conversion, btree splits, etc).
Therefore, any callers that pass a total block requirement of the
bmap mapping length plus worst case bmbt expansion essentially
specify the additional reservation requirement twice. These callers
can pass a total of zero to rely on the bmapi minleft policy.
Beyond being superfluous, the primary motivation for this change is
that the total reservation logic in the bmbt code is dubious in
scenarios where minlen < maxlen and a maxlen extent cannot be
allocated (which is more common for data extent allocations where
contiguity is not required). The total value is based on maxlen in
the xfs_bmapi_write() caller. If the bmbt code falls back to an
allocation between minlen and maxlen, that allocation will not
succeed until total is reset to minlen, which essentially throws
away any additional reservation included in total by the caller. In
addition, the total value is not reset until after alignment is
dropped, which means that such callers drop alignment far too
aggressively than necessary.
Update all callers of xfs_bmapi_write() that pass a total block
value of the mapping length plus bmbt reservation to instead pass
zero and rely on xfs_bmapi_minleft() to enforce the bmbt reservation
requirement. This trades off slightly less conservative AG selection
for the ability to preserve alignment in more scenarios.
xfs_bmapi_write() callers that incorporate unrelated or additional
reservations in total beyond what is already included in minleft
must continue to use the former.
Signed-off-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>
2019-10-21 16:26:48 +00:00
|
|
|
error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb, bmapi_flags, 0,
|
|
|
|
imap, &nimaps);
|
2005-06-21 05:48:47 +00:00
|
|
|
if (error)
|
2021-01-27 01:23:30 +00:00
|
|
|
goto out_trans_cancel;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2005-06-21 05:48:47 +00:00
|
|
|
* Complete the transaction
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2015-06-04 03:48:08 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
2005-06-21 05:48:47 +00:00
|
|
|
if (error)
|
2012-03-27 14:34:50 +00:00
|
|
|
goto out_unlock;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-21 05:48:47 +00:00
|
|
|
/*
|
|
|
|
* Copy any maps to caller's array and return any error.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
if (nimaps == 0) {
|
2014-06-25 04:58:08 +00:00
|
|
|
error = -ENOSPC;
|
2012-03-27 14:34:50 +00:00
|
|
|
goto out_unlock;
|
2006-09-28 01:03:20 +00:00
|
|
|
}
|
|
|
|
|
2019-09-03 15:13:13 +00:00
|
|
|
if (unlikely(!xfs_valid_startblock(ip, imap->br_startblock)))
|
2011-03-06 23:06:35 +00:00
|
|
|
error = xfs_alert_fsblock_zero(ip, imap);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-03-27 14:34:50 +00:00
|
|
|
out_unlock:
|
2019-10-30 19:24:59 +00:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2012-03-27 14:34:50 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-03-27 14:34:50 +00:00
|
|
|
out_trans_cancel:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2012-03-27 14:34:50 +00:00
|
|
|
goto out_unlock;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-03-18 14:51:47 +00:00
|
|
|
STATIC bool
|
|
|
|
xfs_quota_need_throttle(
|
2020-07-16 00:53:43 +00:00
|
|
|
struct xfs_inode *ip,
|
|
|
|
xfs_dqtype_t type,
|
|
|
|
xfs_fsblock_t alloc_blocks)
|
2013-03-18 14:51:47 +00:00
|
|
|
{
|
2020-07-16 00:53:43 +00:00
|
|
|
struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
|
2013-03-18 14:51:47 +00:00
|
|
|
|
|
|
|
if (!dq || !xfs_this_quota_on(ip->i_mount, type))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* no hi watermark, no throttle */
|
|
|
|
if (!dq->q_prealloc_hi_wmark)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* under the lo watermark, no throttle */
|
2020-07-14 17:37:30 +00:00
|
|
|
if (dq->q_blk.reserved + alloc_blocks < dq->q_prealloc_lo_wmark)
|
2013-03-18 14:51:47 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC void
|
|
|
|
xfs_quota_calc_throttle(
|
2020-07-16 00:53:43 +00:00
|
|
|
struct xfs_inode *ip,
|
|
|
|
xfs_dqtype_t type,
|
|
|
|
xfs_fsblock_t *qblocks,
|
|
|
|
int *qshift,
|
|
|
|
int64_t *qfreesp)
|
2013-03-18 14:51:47 +00:00
|
|
|
{
|
2020-07-16 00:53:43 +00:00
|
|
|
struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
|
|
|
|
int64_t freesp;
|
|
|
|
int shift = 0;
|
2013-03-18 14:51:47 +00:00
|
|
|
|
2014-10-01 23:27:09 +00:00
|
|
|
/* no dq, or over hi wmark, squash the prealloc completely */
|
2020-07-14 17:37:30 +00:00
|
|
|
if (!dq || dq->q_blk.reserved >= dq->q_prealloc_hi_wmark) {
|
2013-03-18 14:51:47 +00:00
|
|
|
*qblocks = 0;
|
2014-07-24 09:56:08 +00:00
|
|
|
*qfreesp = 0;
|
2013-03-18 14:51:47 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-07-14 17:37:30 +00:00
|
|
|
freesp = dq->q_prealloc_hi_wmark - dq->q_blk.reserved;
|
2013-03-18 14:51:47 +00:00
|
|
|
if (freesp < dq->q_low_space[XFS_QLOWSP_5_PCNT]) {
|
|
|
|
shift = 2;
|
|
|
|
if (freesp < dq->q_low_space[XFS_QLOWSP_3_PCNT])
|
|
|
|
shift += 2;
|
|
|
|
if (freesp < dq->q_low_space[XFS_QLOWSP_1_PCNT])
|
|
|
|
shift += 2;
|
|
|
|
}
|
|
|
|
|
2014-07-24 09:56:08 +00:00
|
|
|
if (freesp < *qfreesp)
|
|
|
|
*qfreesp = freesp;
|
|
|
|
|
2013-03-18 14:51:47 +00:00
|
|
|
/* only overwrite the throttle values if we are more aggressive */
|
|
|
|
if ((freesp >> shift) < (*qblocks >> *qshift)) {
|
|
|
|
*qblocks = freesp;
|
|
|
|
*qshift = shift;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-04 00:35:03 +00:00
|
|
|
/*
|
|
|
|
* If we don't have a user specified preallocation size, dynamically increase
|
2016-09-19 01:10:21 +00:00
|
|
|
* the preallocation size as the size of the file grows. Cap the maximum size
|
2011-01-04 00:35:03 +00:00
|
|
|
* at a single extent or less if the filesystem is near full. The closer the
|
2020-05-23 16:43:30 +00:00
|
|
|
* filesystem is to being full, the smaller the maximum preallocation.
|
2011-01-04 00:35:03 +00:00
|
|
|
*/
|
|
|
|
STATIC xfs_fsblock_t
|
|
|
|
xfs_iomap_prealloc_size(
|
2013-02-11 05:05:01 +00:00
|
|
|
struct xfs_inode *ip,
|
2019-02-18 17:38:49 +00:00
|
|
|
int whichfork,
|
2016-09-19 01:10:21 +00:00
|
|
|
loff_t offset,
|
|
|
|
loff_t count,
|
2017-11-03 17:34:43 +00:00
|
|
|
struct xfs_iext_cursor *icur)
|
2011-01-04 00:35:03 +00:00
|
|
|
{
|
2020-05-23 16:43:30 +00:00
|
|
|
struct xfs_iext_cursor ncur = *icur;
|
|
|
|
struct xfs_bmbt_irec prev, got;
|
2016-09-19 01:10:21 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2019-02-18 17:38:49 +00:00
|
|
|
struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
|
2016-09-19 01:10:21 +00:00
|
|
|
xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
2013-03-18 14:51:43 +00:00
|
|
|
int64_t freesp;
|
2013-03-18 14:51:47 +00:00
|
|
|
xfs_fsblock_t qblocks;
|
2016-09-19 01:10:21 +00:00
|
|
|
xfs_fsblock_t alloc_blocks = 0;
|
2020-05-23 16:43:30 +00:00
|
|
|
xfs_extlen_t plen;
|
|
|
|
int shift = 0;
|
|
|
|
int qshift = 0;
|
2016-09-19 01:10:21 +00:00
|
|
|
|
2020-05-23 16:43:30 +00:00
|
|
|
/*
|
|
|
|
* As an exception we don't do any preallocation at all if the file is
|
|
|
|
* smaller than the minimum preallocation and we are using the default
|
|
|
|
* dynamic preallocation scheme, as it is likely this is the only write
|
|
|
|
* to the file that is going to be done.
|
|
|
|
*/
|
|
|
|
if (XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_allocsize_blocks))
|
2016-09-19 01:10:21 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
2020-05-23 16:43:30 +00:00
|
|
|
* Use the minimum preallocation size for small files or if we are
|
|
|
|
* writing right after a hole.
|
2016-09-19 01:10:21 +00:00
|
|
|
*/
|
2020-05-23 16:43:30 +00:00
|
|
|
if (XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_dalign) ||
|
2020-05-23 16:43:30 +00:00
|
|
|
!xfs_iext_prev_extent(ifp, &ncur, &prev) ||
|
2016-11-24 00:39:44 +00:00
|
|
|
prev.br_startoff + prev.br_blockcount < offset_fsb)
|
2019-10-28 15:41:44 +00:00
|
|
|
return mp->m_allocsize_blocks;
|
2011-01-04 00:35:03 +00:00
|
|
|
|
2016-09-19 01:10:21 +00:00
|
|
|
/*
|
2020-05-23 16:43:30 +00:00
|
|
|
* Take the size of the preceding data extents as the basis for the
|
|
|
|
* preallocation size. Note that we don't care if the previous extents
|
|
|
|
* are written or not.
|
2016-09-19 01:10:21 +00:00
|
|
|
*/
|
2020-05-23 16:43:30 +00:00
|
|
|
plen = prev.br_blockcount;
|
|
|
|
while (xfs_iext_prev_extent(ifp, &ncur, &got)) {
|
|
|
|
if (plen > MAXEXTLEN / 2 ||
|
|
|
|
isnullstartblock(got.br_startblock) ||
|
|
|
|
got.br_startoff + got.br_blockcount != prev.br_startoff ||
|
|
|
|
got.br_startblock + got.br_blockcount != prev.br_startblock)
|
|
|
|
break;
|
|
|
|
plen += got.br_blockcount;
|
|
|
|
prev = got;
|
|
|
|
}
|
2020-05-23 16:43:30 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the size of the extents is greater than half the maximum extent
|
|
|
|
* length, then use the current offset as the basis. This ensures that
|
|
|
|
* for large files the preallocation size always extends to MAXEXTLEN
|
|
|
|
* rather than falling short due to things like stripe unit/width
|
|
|
|
* alignment of real extents.
|
|
|
|
*/
|
2020-05-23 16:43:30 +00:00
|
|
|
alloc_blocks = plen * 2;
|
|
|
|
if (alloc_blocks > MAXEXTLEN)
|
2016-09-19 01:10:21 +00:00
|
|
|
alloc_blocks = XFS_B_TO_FSB(mp, offset);
|
2013-03-18 14:51:47 +00:00
|
|
|
qblocks = alloc_blocks;
|
2013-03-18 14:51:43 +00:00
|
|
|
|
2013-03-18 14:51:44 +00:00
|
|
|
/*
|
|
|
|
* MAXEXTLEN is not a power of two value but we round the prealloc down
|
|
|
|
* to the nearest power of two value after throttling. To prevent the
|
2020-05-23 16:43:30 +00:00
|
|
|
* round down from unconditionally reducing the maximum supported
|
|
|
|
* prealloc size, we round up first, apply appropriate throttling,
|
|
|
|
* round down and cap the value to MAXEXTLEN.
|
2013-03-18 14:51:44 +00:00
|
|
|
*/
|
|
|
|
alloc_blocks = XFS_FILEOFF_MIN(roundup_pow_of_two(MAXEXTLEN),
|
|
|
|
alloc_blocks);
|
2013-03-18 14:51:43 +00:00
|
|
|
|
2015-02-23 10:22:03 +00:00
|
|
|
freesp = percpu_counter_read_positive(&mp->m_fdblocks);
|
2013-03-18 14:51:43 +00:00
|
|
|
if (freesp < mp->m_low_space[XFS_LOWSP_5_PCNT]) {
|
|
|
|
shift = 2;
|
|
|
|
if (freesp < mp->m_low_space[XFS_LOWSP_4_PCNT])
|
|
|
|
shift++;
|
|
|
|
if (freesp < mp->m_low_space[XFS_LOWSP_3_PCNT])
|
|
|
|
shift++;
|
|
|
|
if (freesp < mp->m_low_space[XFS_LOWSP_2_PCNT])
|
|
|
|
shift++;
|
|
|
|
if (freesp < mp->m_low_space[XFS_LOWSP_1_PCNT])
|
|
|
|
shift++;
|
2011-01-04 00:35:03 +00:00
|
|
|
}
|
2013-03-18 14:51:47 +00:00
|
|
|
|
|
|
|
/*
|
2014-07-24 09:56:08 +00:00
|
|
|
* Check each quota to cap the prealloc size, provide a shift value to
|
|
|
|
* throttle with and adjust amount of available space.
|
2013-03-18 14:51:47 +00:00
|
|
|
*/
|
2020-07-16 00:42:36 +00:00
|
|
|
if (xfs_quota_need_throttle(ip, XFS_DQTYPE_USER, alloc_blocks))
|
|
|
|
xfs_quota_calc_throttle(ip, XFS_DQTYPE_USER, &qblocks, &qshift,
|
2014-07-24 09:56:08 +00:00
|
|
|
&freesp);
|
2020-07-16 00:42:36 +00:00
|
|
|
if (xfs_quota_need_throttle(ip, XFS_DQTYPE_GROUP, alloc_blocks))
|
|
|
|
xfs_quota_calc_throttle(ip, XFS_DQTYPE_GROUP, &qblocks, &qshift,
|
2014-07-24 09:56:08 +00:00
|
|
|
&freesp);
|
2020-07-16 00:42:36 +00:00
|
|
|
if (xfs_quota_need_throttle(ip, XFS_DQTYPE_PROJ, alloc_blocks))
|
|
|
|
xfs_quota_calc_throttle(ip, XFS_DQTYPE_PROJ, &qblocks, &qshift,
|
2014-07-24 09:56:08 +00:00
|
|
|
&freesp);
|
2013-03-18 14:51:47 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The final prealloc size is set to the minimum of free space available
|
|
|
|
* in each of the quotas and the overall filesystem.
|
|
|
|
*
|
|
|
|
* The shift throttle value is set to the maximum value as determined by
|
|
|
|
* the global low free space values and per-quota low free space values.
|
|
|
|
*/
|
2018-06-07 14:54:02 +00:00
|
|
|
alloc_blocks = min(alloc_blocks, qblocks);
|
|
|
|
shift = max(shift, qshift);
|
2013-03-18 14:51:47 +00:00
|
|
|
|
2013-03-18 14:51:43 +00:00
|
|
|
if (shift)
|
|
|
|
alloc_blocks >>= shift;
|
2013-03-18 14:51:44 +00:00
|
|
|
/*
|
|
|
|
* rounddown_pow_of_two() returns an undefined result if we pass in
|
|
|
|
* alloc_blocks = 0.
|
|
|
|
*/
|
|
|
|
if (alloc_blocks)
|
|
|
|
alloc_blocks = rounddown_pow_of_two(alloc_blocks);
|
|
|
|
if (alloc_blocks > MAXEXTLEN)
|
|
|
|
alloc_blocks = MAXEXTLEN;
|
2013-03-18 14:51:43 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are still trying to allocate more space than is
|
|
|
|
* available, squash the prealloc hard. This can happen if we
|
|
|
|
* have a large file on a small filesystem and the above
|
|
|
|
* lowspace thresholds are smaller than MAXEXTLEN.
|
|
|
|
*/
|
|
|
|
while (alloc_blocks && alloc_blocks >= freesp)
|
|
|
|
alloc_blocks >>= 4;
|
2019-10-28 15:41:44 +00:00
|
|
|
if (alloc_blocks < mp->m_allocsize_blocks)
|
|
|
|
alloc_blocks = mp->m_allocsize_blocks;
|
2013-03-18 14:51:48 +00:00
|
|
|
trace_xfs_iomap_prealloc_size(ip, alloc_blocks, shift,
|
2019-10-28 15:41:44 +00:00
|
|
|
mp->m_allocsize_blocks);
|
2011-01-04 00:35:03 +00:00
|
|
|
return alloc_blocks;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int
|
|
|
|
xfs_iomap_write_unwritten(
|
|
|
|
xfs_inode_t *ip,
|
2005-05-05 20:33:40 +00:00
|
|
|
xfs_off_t offset,
|
2017-09-21 18:26:18 +00:00
|
|
|
xfs_off_t count,
|
|
|
|
bool update_isize)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
xfs_mount_t *mp = ip->i_mount;
|
|
|
|
xfs_fileoff_t offset_fsb;
|
|
|
|
xfs_filblks_t count_fsb;
|
|
|
|
xfs_filblks_t numblks_fsb;
|
2006-01-11 04:28:28 +00:00
|
|
|
int nimaps;
|
|
|
|
xfs_trans_t *tp;
|
|
|
|
xfs_bmbt_irec_t imap;
|
2017-09-21 18:26:18 +00:00
|
|
|
struct inode *inode = VFS_I(ip);
|
2012-02-29 09:53:50 +00:00
|
|
|
xfs_fsize_t i_size;
|
2006-01-11 04:28:28 +00:00
|
|
|
uint resblks;
|
2005-04-16 22:20:36 +00:00
|
|
|
int error;
|
|
|
|
|
2009-12-14 23:14:59 +00:00
|
|
|
trace_xfs_unwritten_convert(ip, offset, count);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
|
|
|
count_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + count);
|
|
|
|
count_fsb = (xfs_filblks_t)(count_fsb - offset_fsb);
|
|
|
|
|
2008-06-27 03:32:53 +00:00
|
|
|
/*
|
|
|
|
* Reserve enough blocks in this transaction for two complete extent
|
|
|
|
* btree splits. We may be converting the middle part of an unwritten
|
|
|
|
* extent and in this case we will insert two new extents in the btree
|
|
|
|
* each of which could cause a full split.
|
|
|
|
*
|
|
|
|
* This reservation amount will be used in the first call to
|
|
|
|
* xfs_bmbt_split() to select an AG with enough space to satisfy the
|
|
|
|
* rest of the operation.
|
|
|
|
*/
|
2006-01-11 04:28:28 +00:00
|
|
|
resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-11-09 07:04:20 +00:00
|
|
|
/* Attach dquots so that bmbt splits are accounted correctly. */
|
|
|
|
error = xfs_qm_dqattach(ip);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2006-01-11 04:28:28 +00:00
|
|
|
do {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2016-04-05 23:19:55 +00:00
|
|
|
* Set up a transaction to convert the range of extents
|
2005-04-16 22:20:36 +00:00
|
|
|
* from unwritten to real. Do allocations in a loop until
|
|
|
|
* we have covered the range passed in.
|
2009-10-19 04:00:03 +00:00
|
|
|
*
|
2016-04-05 23:19:55 +00:00
|
|
|
* Note that we can't risk to recursing back into the filesystem
|
|
|
|
* here as we might be asked to write out the same inode that we
|
|
|
|
* complete here and might deadlock on the iolock.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2021-01-27 00:33:29 +00:00
|
|
|
error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write, resblks,
|
2021-01-27 00:44:07 +00:00
|
|
|
0, true, &tp);
|
2016-04-05 23:19:55 +00:00
|
|
|
if (error)
|
2014-06-22 05:04:54 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-01-23 00:48:14 +00:00
|
|
|
error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
|
|
|
|
XFS_IEXT_WRITE_UNWRITTEN_CNT);
|
2019-11-09 07:04:20 +00:00
|
|
|
if (error)
|
|
|
|
goto error_on_bmapi_transaction;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Modify the unwritten extent state of the buffer.
|
|
|
|
*/
|
|
|
|
nimaps = 1;
|
2011-09-18 20:40:52 +00:00
|
|
|
error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
|
2018-07-12 05:26:25 +00:00
|
|
|
XFS_BMAPI_CONVERT, resblks, &imap,
|
|
|
|
&nimaps);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (error)
|
|
|
|
goto error_on_bmapi_transaction;
|
|
|
|
|
2012-02-29 09:53:50 +00:00
|
|
|
/*
|
|
|
|
* Log the updated inode size as we go. We have to be careful
|
|
|
|
* to only log it up to the actual write offset if it is
|
|
|
|
* halfway into a block.
|
|
|
|
*/
|
|
|
|
i_size = XFS_FSB_TO_B(mp, offset_fsb + count_fsb);
|
|
|
|
if (i_size > offset + count)
|
|
|
|
i_size = offset + count;
|
2017-09-21 18:26:18 +00:00
|
|
|
if (update_isize && i_size > i_size_read(inode))
|
|
|
|
i_size_write(inode, i_size);
|
2012-02-29 09:53:50 +00:00
|
|
|
i_size = xfs_new_eof(ip, i_size);
|
|
|
|
if (i_size) {
|
2021-03-29 18:11:40 +00:00
|
|
|
ip->i_disk_size = i_size;
|
2012-02-29 09:53:50 +00:00
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
}
|
|
|
|
|
2015-06-04 03:48:08 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
if (error)
|
2014-06-22 05:04:54 +00:00
|
|
|
return error;
|
2006-09-28 01:03:20 +00:00
|
|
|
|
2019-09-03 15:13:13 +00:00
|
|
|
if (unlikely(!xfs_valid_startblock(ip, imap.br_startblock)))
|
2011-03-06 23:06:35 +00:00
|
|
|
return xfs_alert_fsblock_zero(ip, &imap);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if ((numblks_fsb = imap.br_blockcount) == 0) {
|
|
|
|
/*
|
|
|
|
* The numblks_fsb value should always get
|
|
|
|
* smaller, otherwise the loop is stuck.
|
|
|
|
*/
|
|
|
|
ASSERT(imap.br_blockcount);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
offset_fsb += numblks_fsb;
|
|
|
|
count_fsb -= numblks_fsb;
|
|
|
|
} while (count_fsb > 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_on_bmapi_transaction:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2014-06-22 05:04:54 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-06-20 23:52:47 +00:00
|
|
|
|
2018-05-02 19:54:54 +00:00
|
|
|
static inline bool
|
|
|
|
imap_needs_alloc(
|
|
|
|
struct inode *inode,
|
2019-10-19 16:09:47 +00:00
|
|
|
unsigned flags,
|
2018-05-02 19:54:54 +00:00
|
|
|
struct xfs_bmbt_irec *imap,
|
|
|
|
int nimaps)
|
2016-06-20 23:53:44 +00:00
|
|
|
{
|
2019-10-19 16:09:47 +00:00
|
|
|
/* don't allocate blocks when just zeroing */
|
|
|
|
if (flags & IOMAP_ZERO)
|
|
|
|
return false;
|
|
|
|
if (!nimaps ||
|
|
|
|
imap->br_startblock == HOLESTARTBLOCK ||
|
|
|
|
imap->br_startblock == DELAYSTARTBLOCK)
|
|
|
|
return true;
|
|
|
|
/* we convert unwritten extents before copying the data for DAX */
|
|
|
|
if (IS_DAX(inode) && imap->br_state == XFS_EXT_UNWRITTEN)
|
|
|
|
return true;
|
|
|
|
return false;
|
2016-06-20 23:53:44 +00:00
|
|
|
}
|
|
|
|
|
2018-05-02 19:54:54 +00:00
|
|
|
static inline bool
|
2019-10-19 16:09:47 +00:00
|
|
|
imap_needs_cow(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
unsigned int flags,
|
2018-05-02 19:54:54 +00:00
|
|
|
struct xfs_bmbt_irec *imap,
|
|
|
|
int nimaps)
|
2018-03-01 22:10:31 +00:00
|
|
|
{
|
2019-10-19 16:09:47 +00:00
|
|
|
if (!xfs_is_cow_inode(ip))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* when zeroing we don't have to COW holes or unwritten extents */
|
|
|
|
if (flags & IOMAP_ZERO) {
|
|
|
|
if (!nimaps ||
|
|
|
|
imap->br_startblock == HOLESTARTBLOCK ||
|
|
|
|
imap->br_state == XFS_EXT_UNWRITTEN)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
2018-03-01 22:10:31 +00:00
|
|
|
}
|
|
|
|
|
2018-05-02 19:54:54 +00:00
|
|
|
static int
|
|
|
|
xfs_ilock_for_iomap(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
unsigned flags,
|
|
|
|
unsigned *lockmode)
|
2016-11-30 03:37:15 +00:00
|
|
|
{
|
2018-05-02 19:54:54 +00:00
|
|
|
unsigned mode = XFS_ILOCK_SHARED;
|
2018-06-22 06:26:57 +00:00
|
|
|
bool is_write = flags & (IOMAP_WRITE | IOMAP_ZERO);
|
2018-05-02 19:54:54 +00:00
|
|
|
|
2016-11-30 03:37:15 +00:00
|
|
|
/*
|
2018-03-01 22:12:12 +00:00
|
|
|
* COW writes may allocate delalloc space or convert unwritten COW
|
|
|
|
* extents, so we need to make sure to take the lock exclusively here.
|
2016-11-30 03:37:15 +00:00
|
|
|
*/
|
2019-10-19 16:09:47 +00:00
|
|
|
if (xfs_is_cow_inode(ip) && is_write)
|
2018-05-02 19:54:54 +00:00
|
|
|
mode = XFS_ILOCK_EXCL;
|
2018-03-01 22:12:45 +00:00
|
|
|
|
|
|
|
/*
|
2018-05-02 19:54:54 +00:00
|
|
|
* Extents not yet cached requires exclusive access, don't block. This
|
|
|
|
* is an opencoded xfs_ilock_data_map_shared() call but with
|
2018-03-01 22:12:45 +00:00
|
|
|
* non-blocking behaviour.
|
|
|
|
*/
|
2021-04-13 18:15:12 +00:00
|
|
|
if (xfs_need_iread_extents(&ip->i_df)) {
|
2018-05-02 19:54:54 +00:00
|
|
|
if (flags & IOMAP_NOWAIT)
|
|
|
|
return -EAGAIN;
|
|
|
|
mode = XFS_ILOCK_EXCL;
|
|
|
|
}
|
|
|
|
|
2018-06-22 06:26:57 +00:00
|
|
|
relock:
|
2018-05-02 19:54:54 +00:00
|
|
|
if (flags & IOMAP_NOWAIT) {
|
|
|
|
if (!xfs_ilock_nowait(ip, mode))
|
|
|
|
return -EAGAIN;
|
|
|
|
} else {
|
|
|
|
xfs_ilock(ip, mode);
|
|
|
|
}
|
|
|
|
|
2018-06-22 06:26:57 +00:00
|
|
|
/*
|
|
|
|
* The reflink iflag could have changed since the earlier unlocked
|
|
|
|
* check, so if we got ILOCK_SHARED for a write and but we're now a
|
|
|
|
* reflink inode we have to switch to ILOCK_EXCL and relock.
|
|
|
|
*/
|
2019-02-18 17:38:49 +00:00
|
|
|
if (mode == XFS_ILOCK_SHARED && is_write && xfs_is_cow_inode(ip)) {
|
2018-06-22 06:26:57 +00:00
|
|
|
xfs_iunlock(ip, mode);
|
|
|
|
mode = XFS_ILOCK_EXCL;
|
|
|
|
goto relock;
|
|
|
|
}
|
|
|
|
|
2018-05-02 19:54:54 +00:00
|
|
|
*lockmode = mode;
|
|
|
|
return 0;
|
2016-11-30 03:37:15 +00:00
|
|
|
}
|
|
|
|
|
2020-11-19 16:59:11 +00:00
|
|
|
/*
|
|
|
|
* Check that the imap we are going to return to the caller spans the entire
|
|
|
|
* range that the caller requested for the IO.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
imap_spans_range(
|
|
|
|
struct xfs_bmbt_irec *imap,
|
|
|
|
xfs_fileoff_t offset_fsb,
|
|
|
|
xfs_fileoff_t end_fsb)
|
|
|
|
{
|
|
|
|
if (imap->br_startoff > offset_fsb)
|
|
|
|
return false;
|
|
|
|
if (imap->br_startoff + imap->br_blockcount < end_fsb)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-10-19 16:09:46 +00:00
|
|
|
static int
|
2019-10-19 16:09:46 +00:00
|
|
|
xfs_direct_write_iomap_begin(
|
2016-06-20 23:53:44 +00:00
|
|
|
struct inode *inode,
|
|
|
|
loff_t offset,
|
|
|
|
loff_t length,
|
|
|
|
unsigned flags,
|
2019-10-18 23:44:10 +00:00
|
|
|
struct iomap *iomap,
|
|
|
|
struct iomap *srcmap)
|
2016-06-20 23:53:44 +00:00
|
|
|
{
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2019-10-19 16:09:44 +00:00
|
|
|
struct xfs_bmbt_irec imap, cmap;
|
2019-10-19 16:09:44 +00:00
|
|
|
xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
|
|
|
xfs_fileoff_t end_fsb = xfs_iomap_end_fsb(mp, offset, length);
|
2016-06-20 23:53:44 +00:00
|
|
|
int nimaps = 1, error = 0;
|
2018-10-18 06:19:48 +00:00
|
|
|
bool shared = false;
|
2019-10-17 20:12:02 +00:00
|
|
|
u16 iomap_flags = 0;
|
2016-09-19 01:26:39 +00:00
|
|
|
unsigned lockmode;
|
2016-06-20 23:53:44 +00:00
|
|
|
|
2019-10-19 16:09:45 +00:00
|
|
|
ASSERT(flags & (IOMAP_WRITE | IOMAP_ZERO));
|
|
|
|
|
2016-06-20 23:53:44 +00:00
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
|
|
|
return -EIO;
|
|
|
|
|
2019-10-19 16:09:47 +00:00
|
|
|
/*
|
|
|
|
* Writes that span EOF might trigger an IO size update on completion,
|
|
|
|
* so consider them to be dirty for the purposes of O_DSYNC even if
|
|
|
|
* there is no other metadata changes pending or have been made here.
|
|
|
|
*/
|
|
|
|
if (offset + length > i_size_read(inode))
|
|
|
|
iomap_flags |= IOMAP_F_DIRTY;
|
|
|
|
|
2018-05-02 19:54:54 +00:00
|
|
|
error = xfs_ilock_for_iomap(ip, flags, &lockmode);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2017-06-20 12:05:48 +00:00
|
|
|
|
2016-06-20 23:53:44 +00:00
|
|
|
error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb, &imap,
|
2016-10-03 16:11:36 +00:00
|
|
|
&nimaps, 0);
|
2016-10-20 04:53:50 +00:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2016-10-03 16:11:36 +00:00
|
|
|
|
2019-10-19 16:09:47 +00:00
|
|
|
if (imap_needs_cow(ip, flags, &imap, nimaps)) {
|
2019-10-19 16:09:47 +00:00
|
|
|
error = -EAGAIN;
|
|
|
|
if (flags & IOMAP_NOWAIT)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2019-02-18 17:38:46 +00:00
|
|
|
/* may drop and re-acquire the ilock */
|
2019-10-19 16:09:43 +00:00
|
|
|
error = xfs_reflink_allocate_cow(ip, &imap, &cmap, &shared,
|
2019-10-19 16:09:44 +00:00
|
|
|
&lockmode, flags & IOMAP_DIRECT);
|
2019-02-18 17:38:46 +00:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2019-10-19 16:09:44 +00:00
|
|
|
if (shared)
|
|
|
|
goto out_found_cow;
|
2016-10-20 04:53:50 +00:00
|
|
|
end_fsb = imap.br_startoff + imap.br_blockcount;
|
|
|
|
length = XFS_FSB_TO_B(mp, end_fsb) - offset;
|
2016-06-20 23:53:44 +00:00
|
|
|
}
|
|
|
|
|
2019-10-19 16:09:47 +00:00
|
|
|
if (imap_needs_alloc(inode, flags, &imap, nimaps))
|
|
|
|
goto allocate_blocks;
|
2016-06-20 23:53:44 +00:00
|
|
|
|
2020-11-19 16:59:11 +00:00
|
|
|
/*
|
xfs: reduce exclusive locking on unaligned dio
Attempt shared locking for unaligned DIO, but only if the the
underlying extent is already allocated and in written state. On
failure, retry with the existing exclusive locking.
Test case is fio randrw of 512 byte IOs using AIO and an iodepth of
32 IOs.
Vanilla:
READ: bw=4560KiB/s (4670kB/s), 4560KiB/s-4560KiB/s (4670kB/s-4670kB/s), io=134MiB (140MB), run=30001-30001msec
WRITE: bw=4567KiB/s (4676kB/s), 4567KiB/s-4567KiB/s (4676kB/s-4676kB/s), io=134MiB (140MB), run=30001-30001msec
Patched:
READ: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1127MiB (1182MB), run=30002-30002msec
WRITE: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1128MiB (1183MB), run=30002-30002msec
That's an improvement from ~18k IOPS to a ~150k IOPS, which is
about the IOPS limit of the VM block device setup I'm testing on.
4kB block IO comparison:
READ: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8868MiB (9299MB), run=30002-30002msec
WRITE: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8878MiB (9309MB), run=30002-30002msec
Which is ~150k IOPS, same as what the test gets for sub-block
AIO+DIO writes with this patch.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
[hch: rebased, split unaligned from nowait]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2021-01-23 18:06:31 +00:00
|
|
|
* NOWAIT and OVERWRITE I/O needs to span the entire requested I/O with
|
|
|
|
* a single map so that we avoid partial IO failures due to the rest of
|
|
|
|
* the I/O range not covered by this map triggering an EAGAIN condition
|
|
|
|
* when it is subsequently mapped and aborting the I/O.
|
2020-11-19 16:59:11 +00:00
|
|
|
*/
|
xfs: reduce exclusive locking on unaligned dio
Attempt shared locking for unaligned DIO, but only if the the
underlying extent is already allocated and in written state. On
failure, retry with the existing exclusive locking.
Test case is fio randrw of 512 byte IOs using AIO and an iodepth of
32 IOs.
Vanilla:
READ: bw=4560KiB/s (4670kB/s), 4560KiB/s-4560KiB/s (4670kB/s-4670kB/s), io=134MiB (140MB), run=30001-30001msec
WRITE: bw=4567KiB/s (4676kB/s), 4567KiB/s-4567KiB/s (4676kB/s-4676kB/s), io=134MiB (140MB), run=30001-30001msec
Patched:
READ: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1127MiB (1182MB), run=30002-30002msec
WRITE: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1128MiB (1183MB), run=30002-30002msec
That's an improvement from ~18k IOPS to a ~150k IOPS, which is
about the IOPS limit of the VM block device setup I'm testing on.
4kB block IO comparison:
READ: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8868MiB (9299MB), run=30002-30002msec
WRITE: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8878MiB (9309MB), run=30002-30002msec
Which is ~150k IOPS, same as what the test gets for sub-block
AIO+DIO writes with this patch.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
[hch: rebased, split unaligned from nowait]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2021-01-23 18:06:31 +00:00
|
|
|
if (flags & (IOMAP_NOWAIT | IOMAP_OVERWRITE_ONLY)) {
|
2020-11-19 16:59:11 +00:00
|
|
|
error = -EAGAIN;
|
xfs: reduce exclusive locking on unaligned dio
Attempt shared locking for unaligned DIO, but only if the the
underlying extent is already allocated and in written state. On
failure, retry with the existing exclusive locking.
Test case is fio randrw of 512 byte IOs using AIO and an iodepth of
32 IOs.
Vanilla:
READ: bw=4560KiB/s (4670kB/s), 4560KiB/s-4560KiB/s (4670kB/s-4670kB/s), io=134MiB (140MB), run=30001-30001msec
WRITE: bw=4567KiB/s (4676kB/s), 4567KiB/s-4567KiB/s (4676kB/s-4676kB/s), io=134MiB (140MB), run=30001-30001msec
Patched:
READ: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1127MiB (1182MB), run=30002-30002msec
WRITE: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1128MiB (1183MB), run=30002-30002msec
That's an improvement from ~18k IOPS to a ~150k IOPS, which is
about the IOPS limit of the VM block device setup I'm testing on.
4kB block IO comparison:
READ: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8868MiB (9299MB), run=30002-30002msec
WRITE: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8878MiB (9309MB), run=30002-30002msec
Which is ~150k IOPS, same as what the test gets for sub-block
AIO+DIO writes with this patch.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
[hch: rebased, split unaligned from nowait]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2021-01-23 18:06:31 +00:00
|
|
|
if (!imap_spans_range(&imap, offset_fsb, end_fsb))
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For overwrite only I/O, we cannot convert unwritten extents without
|
|
|
|
* requiring sub-block zeroing. This can only be done under an
|
|
|
|
* exclusive IOLOCK, hence return -EAGAIN if this is not a written
|
|
|
|
* extent to tell the caller to try again.
|
|
|
|
*/
|
|
|
|
if (flags & IOMAP_OVERWRITE_ONLY) {
|
|
|
|
error = -EAGAIN;
|
|
|
|
if (imap.br_state != XFS_EXT_NORM &&
|
|
|
|
((offset | length) & mp->m_blockmask))
|
|
|
|
goto out_unlock;
|
2020-11-19 16:59:11 +00:00
|
|
|
}
|
|
|
|
|
2019-10-19 16:09:47 +00:00
|
|
|
xfs_iunlock(ip, lockmode);
|
|
|
|
trace_xfs_iomap_found(ip, offset, length, XFS_DATA_FORK, &imap);
|
|
|
|
return xfs_bmbt_to_iomap(ip, iomap, &imap, iomap_flags);
|
2016-08-16 22:44:52 +00:00
|
|
|
|
2019-10-19 16:09:47 +00:00
|
|
|
allocate_blocks:
|
|
|
|
error = -EAGAIN;
|
xfs: reduce exclusive locking on unaligned dio
Attempt shared locking for unaligned DIO, but only if the the
underlying extent is already allocated and in written state. On
failure, retry with the existing exclusive locking.
Test case is fio randrw of 512 byte IOs using AIO and an iodepth of
32 IOs.
Vanilla:
READ: bw=4560KiB/s (4670kB/s), 4560KiB/s-4560KiB/s (4670kB/s-4670kB/s), io=134MiB (140MB), run=30001-30001msec
WRITE: bw=4567KiB/s (4676kB/s), 4567KiB/s-4567KiB/s (4676kB/s-4676kB/s), io=134MiB (140MB), run=30001-30001msec
Patched:
READ: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1127MiB (1182MB), run=30002-30002msec
WRITE: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1128MiB (1183MB), run=30002-30002msec
That's an improvement from ~18k IOPS to a ~150k IOPS, which is
about the IOPS limit of the VM block device setup I'm testing on.
4kB block IO comparison:
READ: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8868MiB (9299MB), run=30002-30002msec
WRITE: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8878MiB (9309MB), run=30002-30002msec
Which is ~150k IOPS, same as what the test gets for sub-block
AIO+DIO writes with this patch.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
[hch: rebased, split unaligned from nowait]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2021-01-23 18:06:31 +00:00
|
|
|
if (flags & (IOMAP_NOWAIT | IOMAP_OVERWRITE_ONLY))
|
2018-05-02 19:54:53 +00:00
|
|
|
goto out_unlock;
|
2016-06-20 23:53:44 +00:00
|
|
|
|
2018-05-02 19:54:53 +00:00
|
|
|
/*
|
|
|
|
* We cap the maximum length we map to a sane size to keep the chunks
|
|
|
|
* of work done where somewhat symmetric with the work writeback does.
|
|
|
|
* This is a completely arbitrary number pulled out of thin air as a
|
|
|
|
* best guess for initial testing.
|
|
|
|
*
|
|
|
|
* Note that the values needs to be less than 32-bits wide until the
|
|
|
|
* lower level functions are updated.
|
|
|
|
*/
|
|
|
|
length = min_t(loff_t, length, 1024 * PAGE_SIZE);
|
2019-10-30 19:24:59 +00:00
|
|
|
end_fsb = xfs_iomap_end_fsb(mp, offset, length);
|
2018-05-02 19:54:53 +00:00
|
|
|
|
2019-10-30 19:24:59 +00:00
|
|
|
if (offset + length > XFS_ISIZE(ip))
|
|
|
|
end_fsb = xfs_iomap_eof_align_last_fsb(ip, end_fsb);
|
|
|
|
else if (nimaps && imap.br_startblock == HOLESTARTBLOCK)
|
|
|
|
end_fsb = min(end_fsb, imap.br_startoff + imap.br_blockcount);
|
|
|
|
xfs_iunlock(ip, lockmode);
|
|
|
|
|
|
|
|
error = xfs_iomap_write_direct(ip, offset_fsb, end_fsb - offset_fsb,
|
|
|
|
&imap);
|
2018-05-02 19:54:53 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2019-02-15 16:02:46 +00:00
|
|
|
trace_xfs_iomap_alloc(ip, offset, length, XFS_DATA_FORK, &imap);
|
2019-10-19 16:09:47 +00:00
|
|
|
return xfs_bmbt_to_iomap(ip, iomap, &imap, iomap_flags | IOMAP_F_NEW);
|
2018-05-02 19:54:53 +00:00
|
|
|
|
2019-10-19 16:09:44 +00:00
|
|
|
out_found_cow:
|
|
|
|
xfs_iunlock(ip, lockmode);
|
|
|
|
length = XFS_FSB_TO_B(mp, cmap.br_startoff + cmap.br_blockcount);
|
|
|
|
trace_xfs_iomap_found(ip, offset, length - offset, XFS_COW_FORK, &cmap);
|
|
|
|
if (imap.br_startblock != HOLESTARTBLOCK) {
|
|
|
|
error = xfs_bmbt_to_iomap(ip, srcmap, &imap, 0);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
return xfs_bmbt_to_iomap(ip, iomap, &cmap, IOMAP_F_SHARED);
|
|
|
|
|
2016-10-20 04:53:50 +00:00
|
|
|
out_unlock:
|
2021-01-27 18:07:27 +00:00
|
|
|
if (lockmode)
|
|
|
|
xfs_iunlock(ip, lockmode);
|
2016-10-20 04:53:50 +00:00
|
|
|
return error;
|
2016-06-20 23:53:44 +00:00
|
|
|
}
|
|
|
|
|
2019-10-19 16:09:46 +00:00
|
|
|
const struct iomap_ops xfs_direct_write_iomap_ops = {
|
|
|
|
.iomap_begin = xfs_direct_write_iomap_begin,
|
|
|
|
};
|
|
|
|
|
2019-10-19 16:09:46 +00:00
|
|
|
static int
|
2019-10-19 16:09:46 +00:00
|
|
|
xfs_buffered_write_iomap_begin(
|
2019-10-19 16:09:46 +00:00
|
|
|
struct inode *inode,
|
|
|
|
loff_t offset,
|
|
|
|
loff_t count,
|
|
|
|
unsigned flags,
|
|
|
|
struct iomap *iomap,
|
|
|
|
struct iomap *srcmap)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
|
|
|
xfs_fileoff_t end_fsb = xfs_iomap_end_fsb(mp, offset, count);
|
|
|
|
struct xfs_bmbt_irec imap, cmap;
|
|
|
|
struct xfs_iext_cursor icur, ccur;
|
|
|
|
xfs_fsblock_t prealloc_blocks = 0;
|
|
|
|
bool eof = false, cow_eof = false, shared = false;
|
2019-10-19 16:09:47 +00:00
|
|
|
int allocfork = XFS_DATA_FORK;
|
2019-10-19 16:09:46 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2021-02-11 01:27:20 +00:00
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
|
|
|
return -EIO;
|
|
|
|
|
2019-10-19 16:09:46 +00:00
|
|
|
/* we can't use delayed allocations when using extent size hints */
|
|
|
|
if (xfs_get_extsz_hint(ip))
|
|
|
|
return xfs_direct_write_iomap_begin(inode, offset, count,
|
|
|
|
flags, iomap, srcmap);
|
|
|
|
|
2019-10-19 16:09:46 +00:00
|
|
|
ASSERT(!XFS_IS_REALTIME_INODE(ip));
|
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
|
2020-05-18 17:28:05 +00:00
|
|
|
if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(&ip->i_df)) ||
|
2019-11-11 20:53:22 +00:00
|
|
|
XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
|
2019-10-19 16:09:46 +00:00
|
|
|
error = -EFSCORRUPTED;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
XFS_STATS_INC(mp, xs_blk_mapw);
|
|
|
|
|
2021-04-13 18:15:09 +00:00
|
|
|
error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2019-10-19 16:09:46 +00:00
|
|
|
|
|
|
|
/*
|
2020-08-05 15:49:58 +00:00
|
|
|
* Search the data fork first to look up our source mapping. We
|
2019-10-19 16:09:46 +00:00
|
|
|
* always need the data fork map, as we have to return it to the
|
|
|
|
* iomap code so that the higher level write code can read data in to
|
|
|
|
* perform read-modify-write cycles for unaligned writes.
|
|
|
|
*/
|
|
|
|
eof = !xfs_iext_lookup_extent(ip, &ip->i_df, offset_fsb, &icur, &imap);
|
|
|
|
if (eof)
|
|
|
|
imap.br_startoff = end_fsb; /* fake hole until the end */
|
|
|
|
|
|
|
|
/* We never need to allocate blocks for zeroing a hole. */
|
|
|
|
if ((flags & IOMAP_ZERO) && imap.br_startoff > offset_fsb) {
|
|
|
|
xfs_hole_to_iomap(ip, iomap, offset_fsb, imap.br_startoff);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Search the COW fork extent list even if we did not find a data fork
|
|
|
|
* extent. This serves two purposes: first this implements the
|
|
|
|
* speculative preallocation using cowextsize, so that we also unshare
|
|
|
|
* block adjacent to shared blocks instead of just the shared blocks
|
|
|
|
* themselves. Second the lookup in the extent list is generally faster
|
|
|
|
* than going out to the shared extent tree.
|
|
|
|
*/
|
|
|
|
if (xfs_is_cow_inode(ip)) {
|
|
|
|
if (!ip->i_cowfp) {
|
|
|
|
ASSERT(!xfs_is_reflink_inode(ip));
|
|
|
|
xfs_ifork_init_cow(ip);
|
|
|
|
}
|
|
|
|
cow_eof = !xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb,
|
|
|
|
&ccur, &cmap);
|
|
|
|
if (!cow_eof && cmap.br_startoff <= offset_fsb) {
|
|
|
|
trace_xfs_reflink_cow_found(ip, &cmap);
|
|
|
|
goto found_cow;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (imap.br_startoff <= offset_fsb) {
|
|
|
|
/*
|
|
|
|
* For reflink files we may need a delalloc reservation when
|
|
|
|
* overwriting shared extents. This includes zeroing of
|
|
|
|
* existing extents that contain data.
|
|
|
|
*/
|
|
|
|
if (!xfs_is_cow_inode(ip) ||
|
|
|
|
((flags & IOMAP_ZERO) && imap.br_state != XFS_EXT_NORM)) {
|
|
|
|
trace_xfs_iomap_found(ip, offset, count, XFS_DATA_FORK,
|
|
|
|
&imap);
|
|
|
|
goto found_imap;
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_trim_extent(&imap, offset_fsb, end_fsb - offset_fsb);
|
|
|
|
|
|
|
|
/* Trim the mapping to the nearest shared extent boundary. */
|
2020-01-20 22:34:47 +00:00
|
|
|
error = xfs_bmap_trim_cow(ip, &imap, &shared);
|
2019-10-19 16:09:46 +00:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
/* Not shared? Just report the (potentially capped) extent. */
|
|
|
|
if (!shared) {
|
|
|
|
trace_xfs_iomap_found(ip, offset, count, XFS_DATA_FORK,
|
|
|
|
&imap);
|
|
|
|
goto found_imap;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fork all the shared blocks from our write offset until the
|
|
|
|
* end of the extent.
|
|
|
|
*/
|
2019-10-19 16:09:47 +00:00
|
|
|
allocfork = XFS_COW_FORK;
|
2019-10-19 16:09:46 +00:00
|
|
|
end_fsb = imap.br_startoff + imap.br_blockcount;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We cap the maximum length we map here to MAX_WRITEBACK_PAGES
|
|
|
|
* pages to keep the chunks of work done where somewhat
|
|
|
|
* symmetric with the work writeback does. This is a completely
|
|
|
|
* arbitrary number pulled out of thin air.
|
|
|
|
*
|
|
|
|
* Note that the values needs to be less than 32-bits wide until
|
|
|
|
* the lower level functions are updated.
|
|
|
|
*/
|
|
|
|
count = min_t(loff_t, count, 1024 * PAGE_SIZE);
|
|
|
|
end_fsb = xfs_iomap_end_fsb(mp, offset, count);
|
|
|
|
|
|
|
|
if (xfs_is_always_cow_inode(ip))
|
2019-10-19 16:09:47 +00:00
|
|
|
allocfork = XFS_COW_FORK;
|
2019-10-19 16:09:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
error = xfs_qm_dqattach_locked(ip, false);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2020-05-23 16:43:30 +00:00
|
|
|
if (eof && offset + count > XFS_ISIZE(ip)) {
|
|
|
|
/*
|
|
|
|
* Determine the initial size of the preallocation.
|
|
|
|
* We clean up any extra preallocation when the file is closed.
|
|
|
|
*/
|
|
|
|
if (mp->m_flags & XFS_MOUNT_ALLOCSIZE)
|
|
|
|
prealloc_blocks = mp->m_allocsize_blocks;
|
|
|
|
else
|
|
|
|
prealloc_blocks = xfs_iomap_prealloc_size(ip, allocfork,
|
|
|
|
offset, count, &icur);
|
2019-10-19 16:09:46 +00:00
|
|
|
if (prealloc_blocks) {
|
|
|
|
xfs_extlen_t align;
|
|
|
|
xfs_off_t end_offset;
|
|
|
|
xfs_fileoff_t p_end_fsb;
|
|
|
|
|
2019-10-28 15:41:44 +00:00
|
|
|
end_offset = XFS_ALLOC_ALIGN(mp, offset + count - 1);
|
2019-10-19 16:09:46 +00:00
|
|
|
p_end_fsb = XFS_B_TO_FSBT(mp, end_offset) +
|
|
|
|
prealloc_blocks;
|
|
|
|
|
2019-10-30 19:24:58 +00:00
|
|
|
align = xfs_eof_alignment(ip);
|
2019-10-19 16:09:46 +00:00
|
|
|
if (align)
|
|
|
|
p_end_fsb = roundup_64(p_end_fsb, align);
|
|
|
|
|
|
|
|
p_end_fsb = min(p_end_fsb,
|
|
|
|
XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes));
|
|
|
|
ASSERT(p_end_fsb > offset_fsb);
|
|
|
|
prealloc_blocks = p_end_fsb - end_fsb;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
retry:
|
2019-10-19 16:09:47 +00:00
|
|
|
error = xfs_bmapi_reserve_delalloc(ip, allocfork, offset_fsb,
|
2019-10-19 16:09:46 +00:00
|
|
|
end_fsb - offset_fsb, prealloc_blocks,
|
2019-10-19 16:09:47 +00:00
|
|
|
allocfork == XFS_DATA_FORK ? &imap : &cmap,
|
|
|
|
allocfork == XFS_DATA_FORK ? &icur : &ccur,
|
|
|
|
allocfork == XFS_DATA_FORK ? eof : cow_eof);
|
2019-10-19 16:09:46 +00:00
|
|
|
switch (error) {
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case -ENOSPC:
|
|
|
|
case -EDQUOT:
|
|
|
|
/* retry without any preallocation */
|
|
|
|
trace_xfs_delalloc_enospc(ip, offset, count);
|
|
|
|
if (prealloc_blocks) {
|
|
|
|
prealloc_blocks = 0;
|
|
|
|
goto retry;
|
|
|
|
}
|
2021-04-20 22:54:36 +00:00
|
|
|
fallthrough;
|
2019-10-19 16:09:46 +00:00
|
|
|
default:
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2019-10-19 16:09:47 +00:00
|
|
|
if (allocfork == XFS_COW_FORK) {
|
|
|
|
trace_xfs_iomap_alloc(ip, offset, count, allocfork, &cmap);
|
2019-10-19 16:09:46 +00:00
|
|
|
goto found_cow;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flag newly allocated delalloc blocks with IOMAP_F_NEW so we punch
|
|
|
|
* them out if the write happens to fail.
|
|
|
|
*/
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2019-10-19 16:09:47 +00:00
|
|
|
trace_xfs_iomap_alloc(ip, offset, count, allocfork, &imap);
|
2019-10-19 16:09:46 +00:00
|
|
|
return xfs_bmbt_to_iomap(ip, iomap, &imap, IOMAP_F_NEW);
|
|
|
|
|
|
|
|
found_imap:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
return xfs_bmbt_to_iomap(ip, iomap, &imap, 0);
|
|
|
|
|
|
|
|
found_cow:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
if (imap.br_startoff <= offset_fsb) {
|
|
|
|
error = xfs_bmbt_to_iomap(ip, srcmap, &imap, 0);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
} else {
|
|
|
|
xfs_trim_extent(&cmap, offset_fsb,
|
|
|
|
imap.br_startoff - offset_fsb);
|
|
|
|
}
|
|
|
|
return xfs_bmbt_to_iomap(ip, iomap, &cmap, IOMAP_F_SHARED);
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2016-06-20 23:53:44 +00:00
|
|
|
static int
|
2019-10-19 16:09:46 +00:00
|
|
|
xfs_buffered_write_iomap_end(
|
|
|
|
struct inode *inode,
|
2016-06-20 23:53:44 +00:00
|
|
|
loff_t offset,
|
|
|
|
loff_t length,
|
2017-03-08 17:58:08 +00:00
|
|
|
ssize_t written,
|
2019-10-19 16:09:46 +00:00
|
|
|
unsigned flags,
|
2017-03-08 17:58:08 +00:00
|
|
|
struct iomap *iomap)
|
2016-06-20 23:53:44 +00:00
|
|
|
{
|
2019-10-19 16:09:46 +00:00
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
2016-06-20 23:53:44 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
xfs_fileoff_t start_fsb;
|
|
|
|
xfs_fileoff_t end_fsb;
|
|
|
|
int error = 0;
|
|
|
|
|
2019-10-19 16:09:46 +00:00
|
|
|
if (iomap->type != IOMAP_DELALLOC)
|
|
|
|
return 0;
|
|
|
|
|
2017-03-08 17:58:08 +00:00
|
|
|
/*
|
|
|
|
* Behave as if the write failed if drop writes is enabled. Set the NEW
|
|
|
|
* flag to force delalloc cleanup.
|
|
|
|
*/
|
2017-06-21 00:54:48 +00:00
|
|
|
if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_DROP_WRITES)) {
|
2017-03-08 17:58:08 +00:00
|
|
|
iomap->flags |= IOMAP_F_NEW;
|
2017-02-14 06:48:17 +00:00
|
|
|
written = 0;
|
2017-03-08 17:58:08 +00:00
|
|
|
}
|
2017-02-14 06:48:17 +00:00
|
|
|
|
2017-02-17 01:19:12 +00:00
|
|
|
/*
|
|
|
|
* start_fsb refers to the first unused block after a short write. If
|
|
|
|
* nothing was written, round offset down to point at the first block in
|
|
|
|
* the range.
|
|
|
|
*/
|
|
|
|
if (unlikely(!written))
|
|
|
|
start_fsb = XFS_B_TO_FSBT(mp, offset);
|
|
|
|
else
|
|
|
|
start_fsb = XFS_B_TO_FSB(mp, offset + written);
|
2016-06-20 23:53:44 +00:00
|
|
|
end_fsb = XFS_B_TO_FSB(mp, offset + length);
|
|
|
|
|
|
|
|
/*
|
2017-03-08 17:58:08 +00:00
|
|
|
* Trim delalloc blocks if they were allocated by this write and we
|
|
|
|
* didn't manage to write the whole range.
|
2016-06-20 23:53:44 +00:00
|
|
|
*
|
|
|
|
* We don't need to care about racing delalloc as we hold i_mutex
|
|
|
|
* across the reserve/allocate/unreserve calls. If there are delalloc
|
|
|
|
* blocks in the range, they are ours.
|
|
|
|
*/
|
2017-03-08 17:58:08 +00:00
|
|
|
if ((iomap->flags & IOMAP_F_NEW) && start_fsb < end_fsb) {
|
2017-02-17 01:19:12 +00:00
|
|
|
truncate_pagecache_range(VFS_I(ip), XFS_FSB_TO_B(mp, start_fsb),
|
|
|
|
XFS_FSB_TO_B(mp, end_fsb) - 1);
|
|
|
|
|
2016-06-20 23:53:44 +00:00
|
|
|
error = xfs_bmap_punch_delalloc_range(ip, start_fsb,
|
|
|
|
end_fsb - start_fsb);
|
|
|
|
if (error && !XFS_FORCED_SHUTDOWN(mp)) {
|
|
|
|
xfs_alert(mp, "%s: unable to clean up ino %lld",
|
|
|
|
__func__, ip->i_ino);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-10-19 16:09:46 +00:00
|
|
|
const struct iomap_ops xfs_buffered_write_iomap_ops = {
|
|
|
|
.iomap_begin = xfs_buffered_write_iomap_begin,
|
|
|
|
.iomap_end = xfs_buffered_write_iomap_end,
|
2016-06-20 23:53:44 +00:00
|
|
|
};
|
2016-08-16 22:45:30 +00:00
|
|
|
|
2019-10-19 16:09:45 +00:00
|
|
|
static int
|
|
|
|
xfs_read_iomap_begin(
|
|
|
|
struct inode *inode,
|
|
|
|
loff_t offset,
|
|
|
|
loff_t length,
|
|
|
|
unsigned flags,
|
|
|
|
struct iomap *iomap,
|
|
|
|
struct iomap *srcmap)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_bmbt_irec imap;
|
|
|
|
xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
|
|
|
xfs_fileoff_t end_fsb = xfs_iomap_end_fsb(mp, offset, length);
|
|
|
|
int nimaps = 1, error = 0;
|
|
|
|
bool shared = false;
|
|
|
|
unsigned lockmode;
|
|
|
|
|
|
|
|
ASSERT(!(flags & (IOMAP_WRITE | IOMAP_ZERO)));
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
error = xfs_ilock_for_iomap(ip, flags, &lockmode);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb, &imap,
|
|
|
|
&nimaps, 0);
|
|
|
|
if (!error && (flags & IOMAP_REPORT))
|
|
|
|
error = xfs_reflink_trim_around_shared(ip, &imap, &shared);
|
|
|
|
xfs_iunlock(ip, lockmode);
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
trace_xfs_iomap_found(ip, offset, length, XFS_DATA_FORK, &imap);
|
|
|
|
return xfs_bmbt_to_iomap(ip, iomap, &imap, shared ? IOMAP_F_SHARED : 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct iomap_ops xfs_read_iomap_ops = {
|
|
|
|
.iomap_begin = xfs_read_iomap_begin,
|
|
|
|
};
|
|
|
|
|
2019-02-18 17:38:46 +00:00
|
|
|
static int
|
|
|
|
xfs_seek_iomap_begin(
|
|
|
|
struct inode *inode,
|
|
|
|
loff_t offset,
|
|
|
|
loff_t length,
|
|
|
|
unsigned flags,
|
2019-10-18 23:44:10 +00:00
|
|
|
struct iomap *iomap,
|
|
|
|
struct iomap *srcmap)
|
2019-02-18 17:38:46 +00:00
|
|
|
{
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
|
|
|
xfs_fileoff_t end_fsb = XFS_B_TO_FSB(mp, offset + length);
|
|
|
|
xfs_fileoff_t cow_fsb = NULLFILEOFF, data_fsb = NULLFILEOFF;
|
|
|
|
struct xfs_iext_cursor icur;
|
|
|
|
struct xfs_bmbt_irec imap, cmap;
|
|
|
|
int error = 0;
|
|
|
|
unsigned lockmode;
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
lockmode = xfs_ilock_data_map_shared(ip);
|
2021-04-13 18:15:09 +00:00
|
|
|
error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2019-02-18 17:38:46 +00:00
|
|
|
|
|
|
|
if (xfs_iext_lookup_extent(ip, &ip->i_df, offset_fsb, &icur, &imap)) {
|
|
|
|
/*
|
|
|
|
* If we found a data extent we are done.
|
|
|
|
*/
|
|
|
|
if (imap.br_startoff <= offset_fsb)
|
|
|
|
goto done;
|
|
|
|
data_fsb = imap.br_startoff;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Fake a hole until the end of the file.
|
|
|
|
*/
|
2019-10-19 16:09:44 +00:00
|
|
|
data_fsb = xfs_iomap_end_fsb(mp, offset, length);
|
2019-02-18 17:38:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If a COW fork extent covers the hole, report it - capped to the next
|
|
|
|
* data fork extent:
|
|
|
|
*/
|
|
|
|
if (xfs_inode_has_cow_data(ip) &&
|
|
|
|
xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &cmap))
|
|
|
|
cow_fsb = cmap.br_startoff;
|
|
|
|
if (cow_fsb != NULLFILEOFF && cow_fsb <= offset_fsb) {
|
|
|
|
if (data_fsb < cow_fsb + cmap.br_blockcount)
|
|
|
|
end_fsb = min(end_fsb, data_fsb);
|
|
|
|
xfs_trim_extent(&cmap, offset_fsb, end_fsb);
|
2019-10-17 20:12:02 +00:00
|
|
|
error = xfs_bmbt_to_iomap(ip, iomap, &cmap, IOMAP_F_SHARED);
|
2019-02-18 17:38:46 +00:00
|
|
|
/*
|
|
|
|
* This is a COW extent, so we must probe the page cache
|
|
|
|
* because there could be dirty page cache being backed
|
|
|
|
* by this extent.
|
|
|
|
*/
|
|
|
|
iomap->type = IOMAP_UNWRITTEN;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Else report a hole, capped to the next found data or COW extent.
|
|
|
|
*/
|
|
|
|
if (cow_fsb != NULLFILEOFF && cow_fsb < data_fsb)
|
|
|
|
imap.br_blockcount = cow_fsb - offset_fsb;
|
|
|
|
else
|
|
|
|
imap.br_blockcount = data_fsb - offset_fsb;
|
|
|
|
imap.br_startoff = offset_fsb;
|
|
|
|
imap.br_startblock = HOLESTARTBLOCK;
|
|
|
|
imap.br_state = XFS_EXT_NORM;
|
|
|
|
done:
|
|
|
|
xfs_trim_extent(&imap, offset_fsb, end_fsb);
|
2019-10-17 20:12:02 +00:00
|
|
|
error = xfs_bmbt_to_iomap(ip, iomap, &imap, 0);
|
2019-02-18 17:38:46 +00:00
|
|
|
out_unlock:
|
|
|
|
xfs_iunlock(ip, lockmode);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct iomap_ops xfs_seek_iomap_ops = {
|
|
|
|
.iomap_begin = xfs_seek_iomap_begin,
|
|
|
|
};
|
|
|
|
|
2016-08-16 22:45:30 +00:00
|
|
|
static int
|
|
|
|
xfs_xattr_iomap_begin(
|
|
|
|
struct inode *inode,
|
|
|
|
loff_t offset,
|
|
|
|
loff_t length,
|
|
|
|
unsigned flags,
|
2019-10-18 23:44:10 +00:00
|
|
|
struct iomap *iomap,
|
|
|
|
struct iomap *srcmap)
|
2016-08-16 22:45:30 +00:00
|
|
|
{
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
|
|
|
xfs_fileoff_t end_fsb = XFS_B_TO_FSB(mp, offset + length);
|
|
|
|
struct xfs_bmbt_irec imap;
|
|
|
|
int nimaps = 1, error = 0;
|
|
|
|
unsigned lockmode;
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
|
|
|
return -EIO;
|
|
|
|
|
2017-04-06 23:00:39 +00:00
|
|
|
lockmode = xfs_ilock_attr_map_shared(ip);
|
2016-08-16 22:45:30 +00:00
|
|
|
|
|
|
|
/* if there are no attribute fork or extents, return ENOENT */
|
2020-05-18 17:27:22 +00:00
|
|
|
if (!XFS_IFORK_Q(ip) || !ip->i_afp->if_nextents) {
|
2016-08-16 22:45:30 +00:00
|
|
|
error = -ENOENT;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2020-05-18 17:28:05 +00:00
|
|
|
ASSERT(ip->i_afp->if_format != XFS_DINODE_FMT_LOCAL);
|
2016-08-16 22:45:30 +00:00
|
|
|
error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb, &imap,
|
2017-12-07 00:13:35 +00:00
|
|
|
&nimaps, XFS_BMAPI_ATTRFORK);
|
2016-08-16 22:45:30 +00:00
|
|
|
out_unlock:
|
|
|
|
xfs_iunlock(ip, lockmode);
|
|
|
|
|
2019-02-18 17:38:46 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
ASSERT(nimaps);
|
2019-10-17 20:12:02 +00:00
|
|
|
return xfs_bmbt_to_iomap(ip, iomap, &imap, 0);
|
2016-08-16 22:45:30 +00:00
|
|
|
}
|
|
|
|
|
2017-01-28 07:20:26 +00:00
|
|
|
const struct iomap_ops xfs_xattr_iomap_ops = {
|
2016-08-16 22:45:30 +00:00
|
|
|
.iomap_begin = xfs_xattr_iomap_begin,
|
|
|
|
};
|