2018-06-06 09:42:14 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2005-11-02 10:58:39 +07:00
|
|
|
* Copyright (c) 2000-2005 Silicon Graphics, Inc.
|
|
|
|
* All Rights Reserved.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
2010-02-15 16:44:46 +07:00
|
|
|
#include "xfs_fs.h"
|
2013-10-23 06:36:05 +07:00
|
|
|
#include "xfs_shared.h"
|
2013-10-23 06:51:50 +07:00
|
|
|
#include "xfs_format.h"
|
2013-10-23 06:50:10 +07:00
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
#include "xfs_mount.h"
|
2013-10-15 05:17:51 +07:00
|
|
|
#include "xfs_da_format.h"
|
|
|
|
#include "xfs_da_btree.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
#include "xfs_inode.h"
|
2013-10-23 06:50:10 +07:00
|
|
|
#include "xfs_trans.h"
|
2010-02-15 16:44:48 +07:00
|
|
|
#include "xfs_inode_item.h"
|
2010-02-15 16:44:46 +07:00
|
|
|
#include "xfs_bmap.h"
|
2013-08-12 17:49:45 +07:00
|
|
|
#include "xfs_bmap_util.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
#include "xfs_error.h"
|
2013-08-12 17:49:37 +07:00
|
|
|
#include "xfs_dir2.h"
|
2013-08-12 17:49:45 +07:00
|
|
|
#include "xfs_dir2_priv.h"
|
2008-12-03 19:55:34 +07:00
|
|
|
#include "xfs_ioctl.h"
|
2010-02-15 16:44:46 +07:00
|
|
|
#include "xfs_trace.h"
|
2013-10-23 06:50:10 +07:00
|
|
|
#include "xfs_log.h"
|
2014-07-24 16:49:28 +07:00
|
|
|
#include "xfs_icache.h"
|
2015-02-16 07:59:50 +07:00
|
|
|
#include "xfs_pnfs.h"
|
2016-06-21 06:53:44 +07:00
|
|
|
#include "xfs_iomap.h"
|
2016-10-03 23:11:37 +07:00
|
|
|
#include "xfs_reflink.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#include <linux/dcache.h>
|
2011-01-14 19:07:43 +07:00
|
|
|
#include <linux/falloc.h>
|
2012-08-21 16:11:57 +07:00
|
|
|
#include <linux/pagevec.h>
|
2015-05-23 04:13:32 +07:00
|
|
|
#include <linux/backing-dev.h>
|
2017-11-01 22:36:47 +07:00
|
|
|
#include <linux/mman.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-09-28 01:29:37 +07:00
|
|
|
static const struct vm_operations_struct xfs_file_vm_ops;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2015-02-02 05:53:56 +07:00
|
|
|
int
|
|
|
|
xfs_update_prealloc_flags(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
enum xfs_prealloc_flags flags)
|
|
|
|
{
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
int error;
|
|
|
|
|
2016-04-06 06:19:55 +07:00
|
|
|
error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_writeid,
|
|
|
|
0, 0, 0, &tp);
|
|
|
|
if (error)
|
2015-02-02 05:53:56 +07:00
|
|
|
return error;
|
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
|
|
|
|
|
|
|
|
if (!(flags & XFS_PREALLOC_INVISIBLE)) {
|
2016-02-09 12:54:58 +07:00
|
|
|
VFS_I(ip)->i_mode &= ~S_ISUID;
|
|
|
|
if (VFS_I(ip)->i_mode & S_IXGRP)
|
|
|
|
VFS_I(ip)->i_mode &= ~S_ISGID;
|
2015-02-02 05:53:56 +07:00
|
|
|
xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & XFS_PREALLOC_SET)
|
|
|
|
ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
|
|
|
|
if (flags & XFS_PREALLOC_CLEAR)
|
|
|
|
ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
|
|
|
|
|
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
if (flags & XFS_PREALLOC_SYNC)
|
|
|
|
xfs_trans_set_sync(tp);
|
2015-06-04 10:48:08 +07:00
|
|
|
return xfs_trans_commit(tp);
|
2015-02-02 05:53:56 +07:00
|
|
|
}
|
|
|
|
|
2011-10-02 21:25:16 +07:00
|
|
|
/*
|
|
|
|
* Fsync operations on directories are much simpler than on regular files,
|
|
|
|
* as there is no file data to flush, and thus also no need for explicit
|
|
|
|
* cache flush operations, and there are no non-transaction metadata updates
|
|
|
|
* on directories either.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_dir_fsync(
|
|
|
|
struct file *file,
|
|
|
|
loff_t start,
|
|
|
|
loff_t end,
|
|
|
|
int datasync)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip = XFS_I(file->f_mapping->host);
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
xfs_lsn_t lsn = 0;
|
|
|
|
|
|
|
|
trace_xfs_dir_fsync(ip);
|
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_SHARED);
|
|
|
|
if (xfs_ipincount(ip))
|
|
|
|
lsn = ip->i_itemp->ili_last_lsn;
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_SHARED);
|
|
|
|
|
|
|
|
if (!lsn)
|
|
|
|
return 0;
|
2018-03-14 13:15:28 +07:00
|
|
|
return xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
|
2011-10-02 21:25:16 +07:00
|
|
|
}
|
|
|
|
|
2010-02-15 16:44:48 +07:00
|
|
|
STATIC int
|
|
|
|
xfs_file_fsync(
|
|
|
|
struct file *file,
|
2011-07-17 07:44:56 +07:00
|
|
|
loff_t start,
|
|
|
|
loff_t end,
|
2010-02-15 16:44:48 +07:00
|
|
|
int datasync)
|
|
|
|
{
|
2010-05-26 22:53:25 +07:00
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
2011-06-16 19:02:23 +07:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2010-02-15 16:44:48 +07:00
|
|
|
int error = 0;
|
|
|
|
int log_flushed = 0;
|
2011-09-19 21:55:51 +07:00
|
|
|
xfs_lsn_t lsn = 0;
|
2010-02-15 16:44:48 +07:00
|
|
|
|
2010-06-24 08:57:09 +07:00
|
|
|
trace_xfs_file_fsync(ip);
|
2010-02-15 16:44:48 +07:00
|
|
|
|
2017-07-06 18:02:30 +07:00
|
|
|
error = file_write_and_wait_range(file, start, end);
|
2011-07-17 07:44:56 +07:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2011-06-16 19:02:23 +07:00
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
2014-06-22 12:04:54 +07:00
|
|
|
return -EIO;
|
2010-02-15 16:44:48 +07:00
|
|
|
|
|
|
|
xfs_iflags_clear(ip, XFS_ITRUNCATED);
|
|
|
|
|
2016-12-09 12:49:54 +07:00
|
|
|
/*
|
|
|
|
* If we have an RT and/or log subvolume we need to make sure to flush
|
|
|
|
* the write cache the device used for file data first. This is to
|
|
|
|
* ensure newly written file data make it to disk before logging the new
|
|
|
|
* inode size in case of an extending write.
|
|
|
|
*/
|
|
|
|
if (XFS_IS_REALTIME_INODE(ip))
|
|
|
|
xfs_blkdev_issue_flush(mp->m_rtdev_targp);
|
|
|
|
else if (mp->m_logdev_targp != mp->m_ddev_targp)
|
|
|
|
xfs_blkdev_issue_flush(mp->m_ddev_targp);
|
2011-06-16 19:02:23 +07:00
|
|
|
|
2010-02-15 16:44:48 +07:00
|
|
|
/*
|
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 09:14:59 +07:00
|
|
|
* All metadata updates are logged, which means that we just have to
|
|
|
|
* flush the log up to the latest LSN that touched the inode. If we have
|
|
|
|
* concurrent fsync/fdatasync() calls, we need them to all block on the
|
|
|
|
* log force before we clear the ili_fsync_fields field. This ensures
|
|
|
|
* that we don't get a racing sync operation that does not wait for the
|
|
|
|
* metadata to hit the journal before returning. If we race with
|
|
|
|
* clearing the ili_fsync_fields, then all that will happen is the log
|
|
|
|
* force will do nothing as the lsn will already be on disk. We can't
|
|
|
|
* race with setting ili_fsync_fields because that is done under
|
|
|
|
* XFS_ILOCK_EXCL, and that can't happen because we hold the lock shared
|
|
|
|
* until after the ili_fsync_fields is cleared.
|
2010-02-15 16:44:48 +07:00
|
|
|
*/
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_SHARED);
|
2012-02-29 16:53:55 +07:00
|
|
|
if (xfs_ipincount(ip)) {
|
|
|
|
if (!datasync ||
|
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 09:14:59 +07:00
|
|
|
(ip->i_itemp->ili_fsync_fields & ~XFS_ILOG_TIMESTAMP))
|
2012-02-29 16:53:55 +07:00
|
|
|
lsn = ip->i_itemp->ili_last_lsn;
|
|
|
|
}
|
2010-02-15 16:44:48 +07:00
|
|
|
|
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 09:14:59 +07:00
|
|
|
if (lsn) {
|
2018-03-14 13:15:28 +07:00
|
|
|
error = xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, &log_flushed);
|
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 09:14:59 +07:00
|
|
|
ip->i_itemp->ili_fsync_fields = 0;
|
|
|
|
}
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_SHARED);
|
2011-09-19 21:55:51 +07:00
|
|
|
|
2011-06-16 19:02:23 +07:00
|
|
|
/*
|
|
|
|
* If we only have a single device, and the log force about was
|
|
|
|
* a no-op we might have to flush the data device cache here.
|
|
|
|
* This can only happen for fdatasync/O_DSYNC if we were overwriting
|
|
|
|
* an already allocated file and thus do not have any metadata to
|
|
|
|
* commit.
|
|
|
|
*/
|
2016-12-09 12:49:54 +07:00
|
|
|
if (!log_flushed && !XFS_IS_REALTIME_INODE(ip) &&
|
|
|
|
mp->m_logdev_targp == mp->m_ddev_targp)
|
2011-06-16 19:02:23 +07:00
|
|
|
xfs_blkdev_issue_flush(mp->m_ddev_targp);
|
2010-02-15 16:44:48 +07:00
|
|
|
|
2014-06-25 11:58:08 +07:00
|
|
|
return error;
|
2010-02-15 16:44:48 +07:00
|
|
|
}
|
|
|
|
|
2010-02-15 16:44:47 +07:00
|
|
|
STATIC ssize_t
|
2016-07-20 08:35:42 +07:00
|
|
|
xfs_file_dio_aio_read(
|
2010-02-15 16:44:46 +07:00
|
|
|
struct kiocb *iocb,
|
2014-04-03 01:37:59 +07:00
|
|
|
struct iov_iter *to)
|
2010-02-15 16:44:46 +07:00
|
|
|
{
|
2016-11-30 10:37:15 +07:00
|
|
|
struct xfs_inode *ip = XFS_I(file_inode(iocb->ki_filp));
|
2016-07-20 08:35:42 +07:00
|
|
|
size_t count = iov_iter_count(to);
|
2016-11-30 10:37:15 +07:00
|
|
|
ssize_t ret;
|
2010-02-15 16:44:46 +07:00
|
|
|
|
2016-07-20 08:35:42 +07:00
|
|
|
trace_xfs_file_direct_read(ip, count, iocb->ki_pos);
|
2010-02-15 16:44:46 +07:00
|
|
|
|
2016-07-20 08:36:57 +07:00
|
|
|
if (!count)
|
|
|
|
return 0; /* skip atime */
|
2010-02-15 16:44:46 +07:00
|
|
|
|
2016-10-03 05:47:34 +07:00
|
|
|
file_accessed(iocb->ki_filp);
|
|
|
|
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_ilock(ip, XFS_IOLOCK_SHARED);
|
2016-11-30 10:37:15 +07:00
|
|
|
ret = iomap_dio_rw(iocb, to, &xfs_iomap_ops, NULL);
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
|
2016-11-30 10:37:15 +07:00
|
|
|
|
2016-07-20 08:38:55 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-07-22 06:50:55 +07:00
|
|
|
static noinline ssize_t
|
2016-07-20 08:38:55 +07:00
|
|
|
xfs_file_dax_read(
|
|
|
|
struct kiocb *iocb,
|
|
|
|
struct iov_iter *to)
|
|
|
|
{
|
2016-09-19 08:28:38 +07:00
|
|
|
struct xfs_inode *ip = XFS_I(iocb->ki_filp->f_mapping->host);
|
2016-07-20 08:38:55 +07:00
|
|
|
size_t count = iov_iter_count(to);
|
|
|
|
ssize_t ret = 0;
|
|
|
|
|
|
|
|
trace_xfs_file_dax_read(ip, count, iocb->ki_pos);
|
|
|
|
|
|
|
|
if (!count)
|
|
|
|
return 0; /* skip atime */
|
|
|
|
|
2017-10-24 08:31:50 +07:00
|
|
|
if (iocb->ki_flags & IOCB_NOWAIT) {
|
|
|
|
if (!xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED))
|
2017-06-20 19:05:48 +07:00
|
|
|
return -EAGAIN;
|
2017-10-24 08:31:50 +07:00
|
|
|
} else {
|
2017-06-20 19:05:48 +07:00
|
|
|
xfs_ilock(ip, XFS_IOLOCK_SHARED);
|
|
|
|
}
|
2017-10-24 08:31:50 +07:00
|
|
|
|
2016-11-08 07:32:46 +07:00
|
|
|
ret = dax_iomap_rw(iocb, to, &xfs_iomap_ops);
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
|
2016-07-20 08:35:42 +07:00
|
|
|
|
2016-07-20 08:36:57 +07:00
|
|
|
file_accessed(iocb->ki_filp);
|
2016-07-20 08:35:42 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC ssize_t
|
|
|
|
xfs_file_buffered_aio_read(
|
|
|
|
struct kiocb *iocb,
|
|
|
|
struct iov_iter *to)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip = XFS_I(file_inode(iocb->ki_filp));
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
trace_xfs_file_buffered_read(ip, iov_iter_count(to), iocb->ki_pos);
|
2010-02-15 16:44:46 +07:00
|
|
|
|
2017-10-24 08:31:50 +07:00
|
|
|
if (iocb->ki_flags & IOCB_NOWAIT) {
|
|
|
|
if (!xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED))
|
2017-08-29 21:13:20 +07:00
|
|
|
return -EAGAIN;
|
2017-10-24 08:31:50 +07:00
|
|
|
} else {
|
2017-08-29 21:13:20 +07:00
|
|
|
xfs_ilock(ip, XFS_IOLOCK_SHARED);
|
|
|
|
}
|
2014-04-03 01:37:59 +07:00
|
|
|
ret = generic_file_read_iter(iocb, to);
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
|
2016-07-20 08:35:42 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC ssize_t
|
|
|
|
xfs_file_read_iter(
|
|
|
|
struct kiocb *iocb,
|
|
|
|
struct iov_iter *to)
|
|
|
|
{
|
2016-07-20 08:38:55 +07:00
|
|
|
struct inode *inode = file_inode(iocb->ki_filp);
|
|
|
|
struct xfs_mount *mp = XFS_I(inode)->i_mount;
|
2016-07-20 08:35:42 +07:00
|
|
|
ssize_t ret = 0;
|
|
|
|
|
|
|
|
XFS_STATS_INC(mp, xs_read_calls);
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
|
|
|
return -EIO;
|
|
|
|
|
2016-07-20 08:38:55 +07:00
|
|
|
if (IS_DAX(inode))
|
|
|
|
ret = xfs_file_dax_read(iocb, to);
|
|
|
|
else if (iocb->ki_flags & IOCB_DIRECT)
|
2016-07-20 08:35:42 +07:00
|
|
|
ret = xfs_file_dio_aio_read(iocb, to);
|
2016-07-20 08:31:42 +07:00
|
|
|
else
|
2016-07-20 08:35:42 +07:00
|
|
|
ret = xfs_file_buffered_aio_read(iocb, to);
|
2010-02-15 16:44:46 +07:00
|
|
|
|
|
|
|
if (ret > 0)
|
2015-10-12 14:21:22 +07:00
|
|
|
XFS_STATS_ADD(mp, xs_read_bytes, ret);
|
2010-02-15 16:44:46 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-01-11 06:23:42 +07:00
|
|
|
/*
|
|
|
|
* Common pre-write limit and setup checks.
|
|
|
|
*
|
2011-12-19 03:00:13 +07:00
|
|
|
* Called with the iolocked held either shared and exclusive according to
|
|
|
|
* @iolock, and returns with it held. Might upgrade the iolock to exclusive
|
|
|
|
* if called for a direct write beyond i_size.
|
2011-01-11 06:23:42 +07:00
|
|
|
*/
|
|
|
|
STATIC ssize_t
|
|
|
|
xfs_file_aio_write_checks(
|
2015-04-08 01:25:18 +07:00
|
|
|
struct kiocb *iocb,
|
|
|
|
struct iov_iter *from,
|
2011-01-11 06:23:42 +07:00
|
|
|
int *iolock)
|
|
|
|
{
|
2015-04-08 01:25:18 +07:00
|
|
|
struct file *file = iocb->ki_filp;
|
2011-01-11 06:23:42 +07:00
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
2015-04-09 23:55:47 +07:00
|
|
|
ssize_t error = 0;
|
2015-04-08 01:25:18 +07:00
|
|
|
size_t count = iov_iter_count(from);
|
2015-10-12 12:02:05 +07:00
|
|
|
bool drained_dio = false;
|
2018-03-14 13:15:32 +07:00
|
|
|
loff_t isize;
|
2011-01-11 06:23:42 +07:00
|
|
|
|
xfs: don't serialise adjacent concurrent direct IO appending writes
For append write workloads, extending the file requires a certain
amount of exclusive locking to be done up front to ensure sanity in
things like ensuring that we've zeroed any allocated regions
between the old EOF and the start of the new IO.
For single threads, this typically isn't a problem, and for large
IOs we don't serialise enough for it to be a problem for two
threads on really fast block devices. However for smaller IO and
larger thread counts we have a problem.
Take 4 concurrent sequential, single block sized and aligned IOs.
After the first IO is submitted but before it completes, we end up
with this state:
IO 1 IO 2 IO 3 IO 4
+-------+-------+-------+-------+
^ ^
| |
| |
| |
| \- ip->i_new_size
\- ip->i_size
And the IO is done without exclusive locking because offset <=
ip->i_size. When we submit IO 2, we see offset > ip->i_size, and
grab the IO lock exclusive, because there is a chance we need to do
EOF zeroing. However, there is already an IO in progress that avoids
the need for IO zeroing because offset <= ip->i_new_size. hence we
could avoid holding the IO lock exlcusive for this. Hence after
submission of the second IO, we'd end up this state:
IO 1 IO 2 IO 3 IO 4
+-------+-------+-------+-------+
^ ^
| |
| |
| |
| \- ip->i_new_size
\- ip->i_size
There is no need to grab the i_mutex of the IO lock in exclusive
mode if we don't need to invalidate the page cache. Taking these
locks on every direct IO effective serialises them as taking the IO
lock in exclusive mode has to wait for all shared holders to drop
the lock. That only happens when IO is complete, so effective it
prevents dispatch of concurrent direct IO writes to the same inode.
And so you can see that for the third concurrent IO, we'd avoid
exclusive locking for the same reason we avoided the exclusive lock
for the second IO.
Fixing this is a bit more complex than that, because we need to hold
a write-submission local value of ip->i_new_size to that clearing
the value is only done if no other thread has updated it before our
IO completes.....
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Alex Elder <aelder@sgi.com>
2011-08-25 14:17:02 +07:00
|
|
|
restart:
|
2015-04-09 23:55:47 +07:00
|
|
|
error = generic_write_checks(iocb, from);
|
|
|
|
if (error <= 0)
|
2011-01-11 06:23:42 +07:00
|
|
|
return error;
|
|
|
|
|
2018-03-21 04:42:38 +07:00
|
|
|
error = xfs_break_layouts(inode, iolock, BREAK_WRITE);
|
2015-02-16 07:59:50 +07:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2016-11-30 10:33:25 +07:00
|
|
|
/*
|
|
|
|
* For changing security info in file_remove_privs() we need i_rwsem
|
|
|
|
* exclusively.
|
|
|
|
*/
|
2015-05-21 21:05:56 +07:00
|
|
|
if (*iolock == XFS_IOLOCK_SHARED && !IS_NOSEC(inode)) {
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_iunlock(ip, *iolock);
|
2015-05-21 21:05:56 +07:00
|
|
|
*iolock = XFS_IOLOCK_EXCL;
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_ilock(ip, *iolock);
|
2015-05-21 21:05:56 +07:00
|
|
|
goto restart;
|
|
|
|
}
|
2011-01-11 06:23:42 +07:00
|
|
|
/*
|
|
|
|
* If the offset is beyond the size of the file, we need to zero any
|
|
|
|
* blocks that fall between the existing EOF and the start of this
|
2011-12-19 03:00:12 +07:00
|
|
|
* write. If zeroing is needed and we are currently holding the
|
2012-03-27 21:34:47 +07:00
|
|
|
* iolock shared, we need to update it to exclusive which implies
|
|
|
|
* having to redo all checks before.
|
2015-04-16 19:03:07 +07:00
|
|
|
*
|
|
|
|
* We need to serialise against EOF updates that occur in IO
|
|
|
|
* completions here. We want to make sure that nobody is changing the
|
|
|
|
* size while we do this check until we have placed an IO barrier (i.e.
|
|
|
|
* hold the XFS_IOLOCK_EXCL) that prevents new IO from being dispatched.
|
|
|
|
* The spinlock effectively forms a memory barrier once we have the
|
|
|
|
* XFS_IOLOCK_EXCL so we are guaranteed to see the latest EOF value
|
|
|
|
* and hence be able to correctly determine if we need to run zeroing.
|
2011-01-11 06:23:42 +07:00
|
|
|
*/
|
2015-04-16 19:03:07 +07:00
|
|
|
spin_lock(&ip->i_flags_lock);
|
2018-03-14 13:15:32 +07:00
|
|
|
isize = i_size_read(inode);
|
|
|
|
if (iocb->ki_pos > isize) {
|
2015-04-16 19:03:07 +07:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2015-10-12 12:02:05 +07:00
|
|
|
if (!drained_dio) {
|
|
|
|
if (*iolock == XFS_IOLOCK_SHARED) {
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_iunlock(ip, *iolock);
|
2015-10-12 12:02:05 +07:00
|
|
|
*iolock = XFS_IOLOCK_EXCL;
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_ilock(ip, *iolock);
|
2015-10-12 12:02:05 +07:00
|
|
|
iov_iter_reexpand(from, count);
|
|
|
|
}
|
2015-04-16 19:03:17 +07:00
|
|
|
/*
|
|
|
|
* We now have an IO submission barrier in place, but
|
|
|
|
* AIO can do EOF updates during IO completion and hence
|
|
|
|
* we now need to wait for all of them to drain. Non-AIO
|
|
|
|
* DIO will have drained before we are given the
|
|
|
|
* XFS_IOLOCK_EXCL, and so for most cases this wait is a
|
|
|
|
* no-op.
|
|
|
|
*/
|
|
|
|
inode_dio_wait(inode);
|
2015-10-12 12:02:05 +07:00
|
|
|
drained_dio = true;
|
xfs: don't serialise adjacent concurrent direct IO appending writes
For append write workloads, extending the file requires a certain
amount of exclusive locking to be done up front to ensure sanity in
things like ensuring that we've zeroed any allocated regions
between the old EOF and the start of the new IO.
For single threads, this typically isn't a problem, and for large
IOs we don't serialise enough for it to be a problem for two
threads on really fast block devices. However for smaller IO and
larger thread counts we have a problem.
Take 4 concurrent sequential, single block sized and aligned IOs.
After the first IO is submitted but before it completes, we end up
with this state:
IO 1 IO 2 IO 3 IO 4
+-------+-------+-------+-------+
^ ^
| |
| |
| |
| \- ip->i_new_size
\- ip->i_size
And the IO is done without exclusive locking because offset <=
ip->i_size. When we submit IO 2, we see offset > ip->i_size, and
grab the IO lock exclusive, because there is a chance we need to do
EOF zeroing. However, there is already an IO in progress that avoids
the need for IO zeroing because offset <= ip->i_new_size. hence we
could avoid holding the IO lock exlcusive for this. Hence after
submission of the second IO, we'd end up this state:
IO 1 IO 2 IO 3 IO 4
+-------+-------+-------+-------+
^ ^
| |
| |
| |
| \- ip->i_new_size
\- ip->i_size
There is no need to grab the i_mutex of the IO lock in exclusive
mode if we don't need to invalidate the page cache. Taking these
locks on every direct IO effective serialises them as taking the IO
lock in exclusive mode has to wait for all shared holders to drop
the lock. That only happens when IO is complete, so effective it
prevents dispatch of concurrent direct IO writes to the same inode.
And so you can see that for the third concurrent IO, we'd avoid
exclusive locking for the same reason we avoided the exclusive lock
for the second IO.
Fixing this is a bit more complex than that, because we need to hold
a write-submission local value of ip->i_new_size to that clearing
the value is only done if no other thread has updated it before our
IO completes.....
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Alex Elder <aelder@sgi.com>
2011-08-25 14:17:02 +07:00
|
|
|
goto restart;
|
|
|
|
}
|
2018-03-14 13:15:32 +07:00
|
|
|
|
|
|
|
trace_xfs_zero_eof(ip, isize, iocb->ki_pos - isize);
|
|
|
|
error = iomap_zero_range(inode, isize, iocb->ki_pos - isize,
|
|
|
|
NULL, &xfs_iomap_ops);
|
2012-03-27 21:34:47 +07:00
|
|
|
if (error)
|
|
|
|
return error;
|
2015-04-16 19:03:07 +07:00
|
|
|
} else
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2011-01-11 06:23:42 +07:00
|
|
|
|
2012-02-29 16:53:52 +07:00
|
|
|
/*
|
|
|
|
* Updating the timestamps will grab the ilock again from
|
|
|
|
* xfs_fs_dirty_inode, so we have to call it after dropping the
|
|
|
|
* lock above. Eventually we should look into a way to avoid
|
|
|
|
* the pointless lock roundtrip.
|
|
|
|
*/
|
2012-03-26 20:59:21 +07:00
|
|
|
if (likely(!(file->f_mode & FMODE_NOCMTIME))) {
|
|
|
|
error = file_update_time(file);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
2012-02-29 16:53:52 +07:00
|
|
|
|
2011-01-11 06:23:42 +07:00
|
|
|
/*
|
|
|
|
* If we're writing the file then make sure to clear the setuid and
|
|
|
|
* setgid bits if the process is not being run by root. This keeps
|
|
|
|
* people from modifying setuid and setgid binaries.
|
|
|
|
*/
|
2015-05-21 21:05:56 +07:00
|
|
|
if (!IS_NOSEC(inode))
|
|
|
|
return file_remove_privs(file);
|
|
|
|
return 0;
|
2011-01-11 06:23:42 +07:00
|
|
|
}
|
|
|
|
|
2016-11-30 10:37:15 +07:00
|
|
|
static int
|
|
|
|
xfs_dio_write_end_io(
|
|
|
|
struct kiocb *iocb,
|
|
|
|
ssize_t size,
|
|
|
|
unsigned flags)
|
|
|
|
{
|
|
|
|
struct inode *inode = file_inode(iocb->ki_filp);
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
loff_t offset = iocb->ki_pos;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
trace_xfs_end_io_direct_write(ip, offset, size);
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
if (size <= 0)
|
|
|
|
return size;
|
|
|
|
|
2018-05-03 02:54:52 +07:00
|
|
|
/*
|
|
|
|
* Capture amount written on completion as we can't reliably account
|
|
|
|
* for it on submission.
|
|
|
|
*/
|
|
|
|
XFS_STATS_ADD(ip->i_mount, xs_write_bytes, size);
|
|
|
|
|
2017-09-22 01:26:18 +07:00
|
|
|
if (flags & IOMAP_DIO_COW) {
|
|
|
|
error = xfs_reflink_end_cow(ip, offset, size);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unwritten conversion updates the in-core isize after extent
|
|
|
|
* conversion but before updating the on-disk size. Updating isize any
|
|
|
|
* earlier allows a racing dio read to find unwritten extents before
|
|
|
|
* they are converted.
|
|
|
|
*/
|
|
|
|
if (flags & IOMAP_DIO_UNWRITTEN)
|
|
|
|
return xfs_iomap_write_unwritten(ip, offset, size, true);
|
|
|
|
|
2016-11-30 10:37:15 +07:00
|
|
|
/*
|
|
|
|
* We need to update the in-core inode size here so that we don't end up
|
|
|
|
* with the on-disk inode size being outside the in-core inode size. We
|
|
|
|
* have no other method of updating EOF for AIO, so always do it here
|
|
|
|
* if necessary.
|
|
|
|
*
|
|
|
|
* We need to lock the test/set EOF update as we can be racing with
|
|
|
|
* other IO completions here to update the EOF. Failing to serialise
|
|
|
|
* here can result in EOF moving backwards and Bad Things Happen when
|
|
|
|
* that occurs.
|
|
|
|
*/
|
|
|
|
spin_lock(&ip->i_flags_lock);
|
|
|
|
if (offset + size > i_size_read(inode)) {
|
|
|
|
i_size_write(inode, offset + size);
|
2017-09-22 01:26:18 +07:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2016-11-30 10:37:15 +07:00
|
|
|
error = xfs_setfilesize(ip, offset, size);
|
2017-09-22 01:26:18 +07:00
|
|
|
} else {
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
|
|
|
}
|
2016-11-30 10:37:15 +07:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2011-01-11 06:15:36 +07:00
|
|
|
/*
|
|
|
|
* xfs_file_dio_aio_write - handle direct IO writes
|
|
|
|
*
|
|
|
|
* Lock the inode appropriately to prepare for and issue a direct IO write.
|
2011-01-11 06:22:40 +07:00
|
|
|
* By separating it from the buffered write path we remove all the tricky to
|
2011-01-11 06:15:36 +07:00
|
|
|
* follow locking changes and looping.
|
|
|
|
*
|
2011-01-11 06:22:40 +07:00
|
|
|
* If there are cached pages or we're extending the file, we need IOLOCK_EXCL
|
|
|
|
* until we're sure the bytes at the new EOF have been zeroed and/or the cached
|
|
|
|
* pages are flushed out.
|
|
|
|
*
|
|
|
|
* In most cases the direct IO writes will be done holding IOLOCK_SHARED
|
|
|
|
* allowing them to be done in parallel with reads and other direct IO writes.
|
|
|
|
* However, if the IO is not aligned to filesystem blocks, the direct IO layer
|
|
|
|
* needs to do sub-block zeroing and that requires serialisation against other
|
|
|
|
* direct IOs to the same block. In this case we need to serialise the
|
|
|
|
* submission of the unaligned IOs so that we don't get racing block zeroing in
|
|
|
|
* the dio layer. To avoid the problem with aio, we also need to wait for
|
|
|
|
* outstanding IOs to complete so that unwritten extent conversion is completed
|
|
|
|
* before we try to map the overlapping block. This is currently implemented by
|
2011-08-23 15:28:13 +07:00
|
|
|
* hitting it with a big hammer (i.e. inode_dio_wait()).
|
2011-01-11 06:22:40 +07:00
|
|
|
*
|
2011-01-11 06:15:36 +07:00
|
|
|
* Returns with locks held indicated by @iolock and errors indicated by
|
|
|
|
* negative return values.
|
|
|
|
*/
|
|
|
|
STATIC ssize_t
|
|
|
|
xfs_file_dio_aio_write(
|
|
|
|
struct kiocb *iocb,
|
2014-04-02 18:06:30 +07:00
|
|
|
struct iov_iter *from)
|
2011-01-11 06:15:36 +07:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
|
|
|
struct address_space *mapping = file->f_mapping;
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
ssize_t ret = 0;
|
2011-01-11 06:22:40 +07:00
|
|
|
int unaligned_io = 0;
|
2011-12-19 03:00:14 +07:00
|
|
|
int iolock;
|
2014-04-02 18:06:30 +07:00
|
|
|
size_t count = iov_iter_count(from);
|
2016-11-30 10:37:15 +07:00
|
|
|
struct xfs_buftarg *target = XFS_IS_REALTIME_INODE(ip) ?
|
2011-01-11 06:15:36 +07:00
|
|
|
mp->m_rtdev_targp : mp->m_ddev_targp;
|
|
|
|
|
xfs: allow logical-sector sized O_DIRECT
Some time ago, mkfs.xfs started picking the storage physical
sector size as the default filesystem "sector size" in order
to avoid RMW costs incurred by doing IOs at logical sector
size alignments.
However, this means that for a filesystem made with i.e.
a 4k sector size on an "advanced format" 4k/512 disk,
512-byte direct IOs are no longer allowed. This means
that XFS has essentially turned this AF drive into a hard
4K device, from the filesystem on up.
XFS's mkfs-specified "sector size" is really just controlling
the minimum size & alignment of filesystem metadata.
There is no real need to tightly couple XFS's minimal
metadata size to the minimum allowed direct IO size;
XFS can continue doing metadata in optimal sizes, but
still allow smaller DIOs for apps which issue them,
for whatever reason.
This patch adds a new field to the xfs_buftarg, so that
we now track 2 sizes:
1) The metadata sector size, which is the minimum unit and
alignment of IO which will be performed by metadata operations.
2) The device logical sector size
The first is used internally by the file system for metadata
alignment and IOs.
The second is used for the minimum allowed direct IO alignment.
This has passed xfstests on filesystems made with 4k sectors,
including when run under the patch I sent to ignore
XFS_IOC_DIOINFO, and issue 512 DIOs anyway. I also directly
tested end of block behavior on preallocated, sparse, and
existing files when we do a 512 IO into a 4k file on a
4k-sector filesystem, to be sure there were no unexpected
behaviors.
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2014-01-22 05:46:23 +07:00
|
|
|
/* DIO must be aligned to device logical sector size */
|
2016-07-20 08:38:55 +07:00
|
|
|
if ((iocb->ki_pos | count) & target->bt_logical_sectormask)
|
2014-06-22 12:04:54 +07:00
|
|
|
return -EINVAL;
|
2011-01-11 06:15:36 +07:00
|
|
|
|
xfs: don't serialise adjacent concurrent direct IO appending writes
For append write workloads, extending the file requires a certain
amount of exclusive locking to be done up front to ensure sanity in
things like ensuring that we've zeroed any allocated regions
between the old EOF and the start of the new IO.
For single threads, this typically isn't a problem, and for large
IOs we don't serialise enough for it to be a problem for two
threads on really fast block devices. However for smaller IO and
larger thread counts we have a problem.
Take 4 concurrent sequential, single block sized and aligned IOs.
After the first IO is submitted but before it completes, we end up
with this state:
IO 1 IO 2 IO 3 IO 4
+-------+-------+-------+-------+
^ ^
| |
| |
| |
| \- ip->i_new_size
\- ip->i_size
And the IO is done without exclusive locking because offset <=
ip->i_size. When we submit IO 2, we see offset > ip->i_size, and
grab the IO lock exclusive, because there is a chance we need to do
EOF zeroing. However, there is already an IO in progress that avoids
the need for IO zeroing because offset <= ip->i_new_size. hence we
could avoid holding the IO lock exlcusive for this. Hence after
submission of the second IO, we'd end up this state:
IO 1 IO 2 IO 3 IO 4
+-------+-------+-------+-------+
^ ^
| |
| |
| |
| \- ip->i_new_size
\- ip->i_size
There is no need to grab the i_mutex of the IO lock in exclusive
mode if we don't need to invalidate the page cache. Taking these
locks on every direct IO effective serialises them as taking the IO
lock in exclusive mode has to wait for all shared holders to drop
the lock. That only happens when IO is complete, so effective it
prevents dispatch of concurrent direct IO writes to the same inode.
And so you can see that for the third concurrent IO, we'd avoid
exclusive locking for the same reason we avoided the exclusive lock
for the second IO.
Fixing this is a bit more complex than that, because we need to hold
a write-submission local value of ip->i_new_size to that clearing
the value is only done if no other thread has updated it before our
IO completes.....
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Alex Elder <aelder@sgi.com>
2011-08-25 14:17:02 +07:00
|
|
|
/*
|
2016-10-20 11:44:14 +07:00
|
|
|
* Don't take the exclusive iolock here unless the I/O is unaligned to
|
|
|
|
* the file system block size. We don't need to consider the EOF
|
|
|
|
* extension case here because xfs_file_aio_write_checks() will relock
|
|
|
|
* the inode as necessary for EOF zeroing cases and fill out the new
|
|
|
|
* inode size as appropriate.
|
xfs: don't serialise adjacent concurrent direct IO appending writes
For append write workloads, extending the file requires a certain
amount of exclusive locking to be done up front to ensure sanity in
things like ensuring that we've zeroed any allocated regions
between the old EOF and the start of the new IO.
For single threads, this typically isn't a problem, and for large
IOs we don't serialise enough for it to be a problem for two
threads on really fast block devices. However for smaller IO and
larger thread counts we have a problem.
Take 4 concurrent sequential, single block sized and aligned IOs.
After the first IO is submitted but before it completes, we end up
with this state:
IO 1 IO 2 IO 3 IO 4
+-------+-------+-------+-------+
^ ^
| |
| |
| |
| \- ip->i_new_size
\- ip->i_size
And the IO is done without exclusive locking because offset <=
ip->i_size. When we submit IO 2, we see offset > ip->i_size, and
grab the IO lock exclusive, because there is a chance we need to do
EOF zeroing. However, there is already an IO in progress that avoids
the need for IO zeroing because offset <= ip->i_new_size. hence we
could avoid holding the IO lock exlcusive for this. Hence after
submission of the second IO, we'd end up this state:
IO 1 IO 2 IO 3 IO 4
+-------+-------+-------+-------+
^ ^
| |
| |
| |
| \- ip->i_new_size
\- ip->i_size
There is no need to grab the i_mutex of the IO lock in exclusive
mode if we don't need to invalidate the page cache. Taking these
locks on every direct IO effective serialises them as taking the IO
lock in exclusive mode has to wait for all shared holders to drop
the lock. That only happens when IO is complete, so effective it
prevents dispatch of concurrent direct IO writes to the same inode.
And so you can see that for the third concurrent IO, we'd avoid
exclusive locking for the same reason we avoided the exclusive lock
for the second IO.
Fixing this is a bit more complex than that, because we need to hold
a write-submission local value of ip->i_new_size to that clearing
the value is only done if no other thread has updated it before our
IO completes.....
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Alex Elder <aelder@sgi.com>
2011-08-25 14:17:02 +07:00
|
|
|
*/
|
2016-10-20 11:44:14 +07:00
|
|
|
if ((iocb->ki_pos & mp->m_blockmask) ||
|
|
|
|
((iocb->ki_pos + count) & mp->m_blockmask)) {
|
|
|
|
unaligned_io = 1;
|
2017-02-07 04:00:54 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We can't properly handle unaligned direct I/O to reflink
|
|
|
|
* files yet, as we can't unshare a partial block.
|
|
|
|
*/
|
2019-02-19 00:38:49 +07:00
|
|
|
if (xfs_is_cow_inode(ip)) {
|
2017-02-07 04:00:54 +07:00
|
|
|
trace_xfs_reflink_bounce_dio_write(ip, iocb->ki_pos, count);
|
|
|
|
return -EREMCHG;
|
|
|
|
}
|
2011-12-19 03:00:14 +07:00
|
|
|
iolock = XFS_IOLOCK_EXCL;
|
2016-10-20 11:44:14 +07:00
|
|
|
} else {
|
2011-12-19 03:00:14 +07:00
|
|
|
iolock = XFS_IOLOCK_SHARED;
|
2011-08-27 21:42:53 +07:00
|
|
|
}
|
2011-01-11 06:15:36 +07:00
|
|
|
|
2017-10-24 08:31:50 +07:00
|
|
|
if (iocb->ki_flags & IOCB_NOWAIT) {
|
2019-04-17 22:49:36 +07:00
|
|
|
/* unaligned dio always waits, bail */
|
|
|
|
if (unaligned_io)
|
|
|
|
return -EAGAIN;
|
2017-10-24 08:31:50 +07:00
|
|
|
if (!xfs_ilock_nowait(ip, iolock))
|
2017-06-20 19:05:48 +07:00
|
|
|
return -EAGAIN;
|
2017-10-24 08:31:50 +07:00
|
|
|
} else {
|
2017-06-20 19:05:48 +07:00
|
|
|
xfs_ilock(ip, iolock);
|
|
|
|
}
|
2016-10-20 11:44:14 +07:00
|
|
|
|
2015-04-08 01:25:18 +07:00
|
|
|
ret = xfs_file_aio_write_checks(iocb, from, &iolock);
|
2011-01-11 06:23:42 +07:00
|
|
|
if (ret)
|
2011-12-19 03:00:14 +07:00
|
|
|
goto out;
|
2015-04-08 01:25:18 +07:00
|
|
|
count = iov_iter_count(from);
|
2011-01-11 06:15:36 +07:00
|
|
|
|
2011-01-11 06:22:40 +07:00
|
|
|
/*
|
2019-03-26 07:01:45 +07:00
|
|
|
* If we are doing unaligned IO, we can't allow any other overlapping IO
|
|
|
|
* in-flight at the same time or we risk data corruption. Wait for all
|
|
|
|
* other IO to drain before we submit. If the IO is aligned, demote the
|
|
|
|
* iolock if we had to take the exclusive lock in
|
|
|
|
* xfs_file_aio_write_checks() for other reasons.
|
2011-01-11 06:22:40 +07:00
|
|
|
*/
|
2017-06-20 19:05:48 +07:00
|
|
|
if (unaligned_io) {
|
2019-03-26 07:01:45 +07:00
|
|
|
inode_dio_wait(inode);
|
2017-06-20 19:05:48 +07:00
|
|
|
} else if (iolock == XFS_IOLOCK_EXCL) {
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_ilock_demote(ip, XFS_IOLOCK_EXCL);
|
2011-12-19 03:00:14 +07:00
|
|
|
iolock = XFS_IOLOCK_SHARED;
|
2011-01-11 06:15:36 +07:00
|
|
|
}
|
|
|
|
|
2016-07-20 08:31:42 +07:00
|
|
|
trace_xfs_file_direct_write(ip, count, iocb->ki_pos);
|
2016-11-30 10:37:15 +07:00
|
|
|
ret = iomap_dio_rw(iocb, from, &xfs_iomap_ops, xfs_dio_write_end_io);
|
2019-03-26 07:01:45 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If unaligned, this is the only IO in-flight. If it has not yet
|
|
|
|
* completed, wait on it before we release the iolock to prevent
|
|
|
|
* subsequent overlapping IO.
|
|
|
|
*/
|
|
|
|
if (ret == -EIOCBQUEUED && unaligned_io)
|
|
|
|
inode_dio_wait(inode);
|
2011-12-19 03:00:14 +07:00
|
|
|
out:
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_iunlock(ip, iolock);
|
2011-12-19 03:00:14 +07:00
|
|
|
|
2015-06-04 06:18:53 +07:00
|
|
|
/*
|
2016-07-20 08:38:55 +07:00
|
|
|
* No fallback to buffered IO on errors for XFS, direct IO will either
|
|
|
|
* complete fully or fail.
|
2015-06-04 06:18:53 +07:00
|
|
|
*/
|
2016-07-20 08:38:55 +07:00
|
|
|
ASSERT(ret < 0 || ret == count);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-07-22 06:50:55 +07:00
|
|
|
static noinline ssize_t
|
2016-07-20 08:38:55 +07:00
|
|
|
xfs_file_dax_write(
|
|
|
|
struct kiocb *iocb,
|
|
|
|
struct iov_iter *from)
|
|
|
|
{
|
2016-09-19 08:28:38 +07:00
|
|
|
struct inode *inode = iocb->ki_filp->f_mapping->host;
|
2016-07-20 08:38:55 +07:00
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
2016-09-19 08:24:50 +07:00
|
|
|
int iolock = XFS_IOLOCK_EXCL;
|
2016-09-19 08:28:38 +07:00
|
|
|
ssize_t ret, error = 0;
|
|
|
|
size_t count;
|
|
|
|
loff_t pos;
|
2016-07-20 08:38:55 +07:00
|
|
|
|
2017-10-24 08:31:50 +07:00
|
|
|
if (iocb->ki_flags & IOCB_NOWAIT) {
|
|
|
|
if (!xfs_ilock_nowait(ip, iolock))
|
2017-06-20 19:05:48 +07:00
|
|
|
return -EAGAIN;
|
2017-10-24 08:31:50 +07:00
|
|
|
} else {
|
2017-06-20 19:05:48 +07:00
|
|
|
xfs_ilock(ip, iolock);
|
|
|
|
}
|
|
|
|
|
2016-07-20 08:38:55 +07:00
|
|
|
ret = xfs_file_aio_write_checks(iocb, from, &iolock);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2016-09-19 08:28:38 +07:00
|
|
|
pos = iocb->ki_pos;
|
|
|
|
count = iov_iter_count(from);
|
2016-08-17 05:31:33 +07:00
|
|
|
|
2016-09-19 08:28:38 +07:00
|
|
|
trace_xfs_file_dax_write(ip, count, pos);
|
2016-11-08 07:32:46 +07:00
|
|
|
ret = dax_iomap_rw(iocb, from, &xfs_iomap_ops);
|
2016-09-19 08:28:38 +07:00
|
|
|
if (ret > 0 && iocb->ki_pos > i_size_read(inode)) {
|
|
|
|
i_size_write(inode, iocb->ki_pos);
|
|
|
|
error = xfs_setfilesize(ip, pos, ret);
|
2016-07-20 08:38:55 +07:00
|
|
|
}
|
|
|
|
out:
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_iunlock(ip, iolock);
|
2018-05-03 02:54:52 +07:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
if (ret > 0) {
|
|
|
|
XFS_STATS_ADD(ip->i_mount, xs_write_bytes, ret);
|
|
|
|
|
|
|
|
/* Handle various SYNC-type writes */
|
|
|
|
ret = generic_write_sync(iocb, ret);
|
|
|
|
}
|
|
|
|
return ret;
|
2011-01-11 06:15:36 +07:00
|
|
|
}
|
|
|
|
|
2010-02-15 16:44:47 +07:00
|
|
|
STATIC ssize_t
|
2011-01-11 06:17:30 +07:00
|
|
|
xfs_file_buffered_aio_write(
|
2010-02-15 16:44:46 +07:00
|
|
|
struct kiocb *iocb,
|
2014-04-02 18:06:30 +07:00
|
|
|
struct iov_iter *from)
|
2010-02-15 16:44:46 +07:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
|
|
|
struct address_space *mapping = file->f_mapping;
|
|
|
|
struct inode *inode = mapping->host;
|
2010-02-15 16:44:47 +07:00
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
2011-01-11 06:17:30 +07:00
|
|
|
ssize_t ret;
|
|
|
|
int enospc = 0;
|
2017-01-28 14:22:56 +07:00
|
|
|
int iolock;
|
2010-02-15 16:44:46 +07:00
|
|
|
|
2017-08-29 21:13:20 +07:00
|
|
|
if (iocb->ki_flags & IOCB_NOWAIT)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2017-01-28 14:22:56 +07:00
|
|
|
write_retry:
|
|
|
|
iolock = XFS_IOLOCK_EXCL;
|
2016-11-30 10:33:25 +07:00
|
|
|
xfs_ilock(ip, iolock);
|
2010-02-15 16:44:46 +07:00
|
|
|
|
2015-04-08 01:25:18 +07:00
|
|
|
ret = xfs_file_aio_write_checks(iocb, from, &iolock);
|
2011-01-11 06:23:42 +07:00
|
|
|
if (ret)
|
2011-12-19 03:00:14 +07:00
|
|
|
goto out;
|
2010-02-15 16:44:46 +07:00
|
|
|
|
|
|
|
/* We can write back this queue in page reclaim */
|
2015-01-14 16:42:36 +07:00
|
|
|
current->backing_dev_info = inode_to_bdi(inode);
|
2010-02-15 16:44:46 +07:00
|
|
|
|
2016-07-20 08:31:42 +07:00
|
|
|
trace_xfs_file_buffered_write(ip, iov_iter_count(from), iocb->ki_pos);
|
2016-06-21 06:53:44 +07:00
|
|
|
ret = iomap_file_buffered_write(iocb, from, &xfs_iomap_ops);
|
2014-02-12 10:25:22 +07:00
|
|
|
if (likely(ret >= 0))
|
2015-04-08 01:25:18 +07:00
|
|
|
iocb->ki_pos += ret;
|
2014-07-24 16:49:28 +07:00
|
|
|
|
2011-01-11 06:17:30 +07:00
|
|
|
/*
|
2014-07-24 16:49:28 +07:00
|
|
|
* If we hit a space limit, try to free up some lingering preallocated
|
|
|
|
* space before returning an error. In the case of ENOSPC, first try to
|
|
|
|
* write back all dirty inodes to free up some of the excess reserved
|
|
|
|
* metadata space. This reduces the chances that the eofblocks scan
|
|
|
|
* waits on dirty mappings. Since xfs_flush_inodes() is serialized, this
|
|
|
|
* also behaves as a filter to prevent too many eofblocks scans from
|
|
|
|
* running at the same time.
|
2011-01-11 06:17:30 +07:00
|
|
|
*/
|
2014-07-24 16:49:28 +07:00
|
|
|
if (ret == -EDQUOT && !enospc) {
|
2017-01-28 14:22:56 +07:00
|
|
|
xfs_iunlock(ip, iolock);
|
2014-07-24 16:49:28 +07:00
|
|
|
enospc = xfs_inode_free_quota_eofblocks(ip);
|
|
|
|
if (enospc)
|
|
|
|
goto write_retry;
|
2016-10-03 23:11:46 +07:00
|
|
|
enospc = xfs_inode_free_quota_cowblocks(ip);
|
|
|
|
if (enospc)
|
|
|
|
goto write_retry;
|
2017-01-28 14:22:56 +07:00
|
|
|
iolock = 0;
|
2014-07-24 16:49:28 +07:00
|
|
|
} else if (ret == -ENOSPC && !enospc) {
|
|
|
|
struct xfs_eofblocks eofb = {0};
|
|
|
|
|
2011-01-11 06:17:30 +07:00
|
|
|
enospc = 1;
|
2012-10-08 17:56:04 +07:00
|
|
|
xfs_flush_inodes(ip->i_mount);
|
2017-01-28 14:22:56 +07:00
|
|
|
|
|
|
|
xfs_iunlock(ip, iolock);
|
2014-07-24 16:49:28 +07:00
|
|
|
eofb.eof_flags = XFS_EOF_FLAGS_SYNC;
|
|
|
|
xfs_icache_free_eofblocks(ip->i_mount, &eofb);
|
2017-06-21 04:36:19 +07:00
|
|
|
xfs_icache_free_cowblocks(ip->i_mount, &eofb);
|
2012-10-08 17:56:04 +07:00
|
|
|
goto write_retry;
|
2010-02-15 16:44:46 +07:00
|
|
|
}
|
2011-12-19 03:00:14 +07:00
|
|
|
|
2010-02-15 16:44:46 +07:00
|
|
|
current->backing_dev_info = NULL;
|
2011-12-19 03:00:14 +07:00
|
|
|
out:
|
2017-01-28 14:22:56 +07:00
|
|
|
if (iolock)
|
|
|
|
xfs_iunlock(ip, iolock);
|
2018-05-03 02:54:52 +07:00
|
|
|
|
|
|
|
if (ret > 0) {
|
|
|
|
XFS_STATS_ADD(ip->i_mount, xs_write_bytes, ret);
|
|
|
|
/* Handle various SYNC-type writes */
|
|
|
|
ret = generic_write_sync(iocb, ret);
|
|
|
|
}
|
2011-01-11 06:17:30 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC ssize_t
|
2014-04-04 01:20:23 +07:00
|
|
|
xfs_file_write_iter(
|
2011-01-11 06:17:30 +07:00
|
|
|
struct kiocb *iocb,
|
2014-04-04 01:20:23 +07:00
|
|
|
struct iov_iter *from)
|
2011-01-11 06:17:30 +07:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
|
|
|
struct address_space *mapping = file->f_mapping;
|
|
|
|
struct inode *inode = mapping->host;
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
ssize_t ret;
|
2014-04-04 01:20:23 +07:00
|
|
|
size_t ocount = iov_iter_count(from);
|
2011-01-11 06:17:30 +07:00
|
|
|
|
2015-10-12 14:21:22 +07:00
|
|
|
XFS_STATS_INC(ip->i_mount, xs_write_calls);
|
2011-01-11 06:17:30 +07:00
|
|
|
|
|
|
|
if (ocount == 0)
|
|
|
|
return 0;
|
|
|
|
|
2014-04-04 01:20:23 +07:00
|
|
|
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
|
|
|
|
return -EIO;
|
2011-01-11 06:17:30 +07:00
|
|
|
|
2016-07-20 08:38:55 +07:00
|
|
|
if (IS_DAX(inode))
|
2018-05-03 02:54:52 +07:00
|
|
|
return xfs_file_dax_write(iocb, from);
|
|
|
|
|
|
|
|
if (iocb->ki_flags & IOCB_DIRECT) {
|
2016-10-03 23:11:37 +07:00
|
|
|
/*
|
|
|
|
* Allow a directio write to fall back to a buffered
|
|
|
|
* write *only* in the case that we're doing a reflink
|
|
|
|
* CoW. In all other directio scenarios we do not
|
|
|
|
* allow an operation to fall back to buffered mode.
|
|
|
|
*/
|
2014-04-04 01:20:23 +07:00
|
|
|
ret = xfs_file_dio_aio_write(iocb, from);
|
2018-05-03 02:54:52 +07:00
|
|
|
if (ret != -EREMCHG)
|
|
|
|
return ret;
|
2016-10-03 23:11:37 +07:00
|
|
|
}
|
2010-02-15 16:44:46 +07:00
|
|
|
|
2018-05-03 02:54:52 +07:00
|
|
|
return xfs_file_buffered_aio_write(iocb, from);
|
2010-02-15 16:44:46 +07:00
|
|
|
}
|
|
|
|
|
2018-05-10 05:47:49 +07:00
|
|
|
static void
|
|
|
|
xfs_wait_dax_page(
|
2018-08-10 22:48:18 +07:00
|
|
|
struct inode *inode)
|
2018-05-10 05:47:49 +07:00
|
|
|
{
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
|
|
|
|
xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
|
|
|
|
schedule();
|
|
|
|
xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xfs_break_dax_layouts(
|
|
|
|
struct inode *inode,
|
2018-08-10 22:48:18 +07:00
|
|
|
bool *retry)
|
2018-05-10 05:47:49 +07:00
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
ASSERT(xfs_isilocked(XFS_I(inode), XFS_MMAPLOCK_EXCL));
|
|
|
|
|
|
|
|
page = dax_layout_busy_page(inode->i_mapping);
|
|
|
|
if (!page)
|
|
|
|
return 0;
|
|
|
|
|
2018-08-10 22:48:18 +07:00
|
|
|
*retry = true;
|
2018-05-10 05:47:49 +07:00
|
|
|
return ___wait_var_event(&page->_refcount,
|
|
|
|
atomic_read(&page->_refcount) == 1, TASK_INTERRUPTIBLE,
|
2018-08-10 22:48:18 +07:00
|
|
|
0, 0, xfs_wait_dax_page(inode));
|
2018-05-10 05:47:49 +07:00
|
|
|
}
|
|
|
|
|
2018-03-21 04:42:38 +07:00
|
|
|
int
|
|
|
|
xfs_break_layouts(
|
|
|
|
struct inode *inode,
|
|
|
|
uint *iolock,
|
|
|
|
enum layout_break_reason reason)
|
|
|
|
{
|
|
|
|
bool retry;
|
2018-05-10 05:47:49 +07:00
|
|
|
int error;
|
2018-03-21 04:42:38 +07:00
|
|
|
|
|
|
|
ASSERT(xfs_isilocked(XFS_I(inode), XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL));
|
|
|
|
|
2018-05-10 05:47:49 +07:00
|
|
|
do {
|
|
|
|
retry = false;
|
|
|
|
switch (reason) {
|
|
|
|
case BREAK_UNMAP:
|
2018-07-12 12:26:36 +07:00
|
|
|
error = xfs_break_dax_layouts(inode, &retry);
|
2018-05-10 05:47:49 +07:00
|
|
|
if (error || retry)
|
|
|
|
break;
|
|
|
|
/* fall through */
|
|
|
|
case BREAK_WRITE:
|
|
|
|
error = xfs_break_leased_layouts(inode, iolock, &retry);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
error = -EINVAL;
|
|
|
|
}
|
|
|
|
} while (error == 0 && retry);
|
|
|
|
|
|
|
|
return error;
|
2018-03-21 04:42:38 +07:00
|
|
|
}
|
|
|
|
|
2015-03-25 11:08:56 +07:00
|
|
|
#define XFS_FALLOC_FL_SUPPORTED \
|
|
|
|
(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE | \
|
|
|
|
FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE | \
|
2016-10-03 23:11:43 +07:00
|
|
|
FALLOC_FL_INSERT_RANGE | FALLOC_FL_UNSHARE_RANGE)
|
2015-03-25 11:08:56 +07:00
|
|
|
|
2011-01-14 19:07:43 +07:00
|
|
|
STATIC long
|
|
|
|
xfs_file_fallocate(
|
2013-10-12 14:55:07 +07:00
|
|
|
struct file *file,
|
|
|
|
int mode,
|
|
|
|
loff_t offset,
|
|
|
|
loff_t len)
|
2011-01-14 19:07:43 +07:00
|
|
|
{
|
2013-10-12 14:55:07 +07:00
|
|
|
struct inode *inode = file_inode(file);
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
long error;
|
2015-02-02 05:53:56 +07:00
|
|
|
enum xfs_prealloc_flags flags = 0;
|
2018-03-13 04:12:29 +07:00
|
|
|
uint iolock = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
|
2013-10-12 14:55:07 +07:00
|
|
|
loff_t new_size = 0;
|
2017-10-10 01:38:54 +07:00
|
|
|
bool do_file_insert = false;
|
2011-01-14 19:07:43 +07:00
|
|
|
|
2013-10-12 14:55:07 +07:00
|
|
|
if (!S_ISREG(inode->i_mode))
|
|
|
|
return -EINVAL;
|
2015-03-25 11:08:56 +07:00
|
|
|
if (mode & ~XFS_FALLOC_FL_SUPPORTED)
|
2011-01-14 19:07:43 +07:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2015-02-16 07:59:50 +07:00
|
|
|
xfs_ilock(ip, iolock);
|
2018-03-21 04:42:38 +07:00
|
|
|
error = xfs_break_layouts(inode, &iolock, BREAK_UNMAP);
|
2015-02-16 07:59:50 +07:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2013-10-12 14:55:07 +07:00
|
|
|
if (mode & FALLOC_FL_PUNCH_HOLE) {
|
|
|
|
error = xfs_free_file_space(ip, offset, len);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2014-02-24 06:58:19 +07:00
|
|
|
} else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
|
2017-02-28 05:28:32 +07:00
|
|
|
unsigned int blksize_mask = i_blocksize(inode) - 1;
|
2014-02-24 06:58:19 +07:00
|
|
|
|
|
|
|
if (offset & blksize_mask || len & blksize_mask) {
|
2014-06-25 11:58:08 +07:00
|
|
|
error = -EINVAL;
|
2014-02-24 06:58:19 +07:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2014-04-12 20:56:41 +07:00
|
|
|
/*
|
|
|
|
* There is no need to overlap collapse range with EOF,
|
|
|
|
* in which case it is effectively a truncate operation
|
|
|
|
*/
|
|
|
|
if (offset + len >= i_size_read(inode)) {
|
2014-06-25 11:58:08 +07:00
|
|
|
error = -EINVAL;
|
2014-04-12 20:56:41 +07:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2014-02-24 06:58:19 +07:00
|
|
|
new_size = i_size_read(inode) - len;
|
|
|
|
|
|
|
|
error = xfs_collapse_file_space(ip, offset, len);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2015-03-25 11:08:56 +07:00
|
|
|
} else if (mode & FALLOC_FL_INSERT_RANGE) {
|
2018-04-17 13:07:45 +07:00
|
|
|
unsigned int blksize_mask = i_blocksize(inode) - 1;
|
|
|
|
loff_t isize = i_size_read(inode);
|
2015-03-25 11:08:56 +07:00
|
|
|
|
|
|
|
if (offset & blksize_mask || len & blksize_mask) {
|
|
|
|
error = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2018-04-17 13:07:45 +07:00
|
|
|
/*
|
|
|
|
* New inode size must not exceed ->s_maxbytes, accounting for
|
|
|
|
* possible signed overflow.
|
|
|
|
*/
|
|
|
|
if (inode->i_sb->s_maxbytes - isize < len) {
|
2015-03-25 11:08:56 +07:00
|
|
|
error = -EFBIG;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2018-04-17 13:07:45 +07:00
|
|
|
new_size = isize + len;
|
2015-03-25 11:08:56 +07:00
|
|
|
|
|
|
|
/* Offset should be less than i_size */
|
2018-04-17 13:07:45 +07:00
|
|
|
if (offset >= isize) {
|
2015-03-25 11:08:56 +07:00
|
|
|
error = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2017-10-10 01:38:54 +07:00
|
|
|
do_file_insert = true;
|
2013-10-12 14:55:07 +07:00
|
|
|
} else {
|
2015-02-02 05:53:56 +07:00
|
|
|
flags |= XFS_PREALLOC_SET;
|
|
|
|
|
2013-10-12 14:55:07 +07:00
|
|
|
if (!(mode & FALLOC_FL_KEEP_SIZE) &&
|
|
|
|
offset + len > i_size_read(inode)) {
|
|
|
|
new_size = offset + len;
|
2014-06-25 11:58:08 +07:00
|
|
|
error = inode_newsize_ok(inode, new_size);
|
2013-10-12 14:55:07 +07:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2011-01-14 19:07:43 +07:00
|
|
|
|
2019-02-19 00:38:49 +07:00
|
|
|
if (mode & FALLOC_FL_ZERO_RANGE) {
|
2014-03-13 15:07:58 +07:00
|
|
|
error = xfs_zero_file_space(ip, offset, len);
|
2019-02-19 00:38:49 +07:00
|
|
|
} else if (mode & FALLOC_FL_UNSHARE_RANGE) {
|
|
|
|
error = xfs_reflink_unshare(ip, offset, len);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
if (!xfs_is_always_cow_inode(ip)) {
|
|
|
|
error = xfs_alloc_file_space(ip, offset, len,
|
|
|
|
XFS_BMAPI_PREALLOC);
|
2016-10-03 23:11:43 +07:00
|
|
|
}
|
2019-02-19 00:38:49 +07:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If always_cow mode we can't use preallocations and
|
|
|
|
* thus should not create them.
|
|
|
|
*/
|
|
|
|
if (xfs_is_always_cow_inode(ip)) {
|
|
|
|
error = -EOPNOTSUPP;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2014-03-13 15:07:58 +07:00
|
|
|
error = xfs_alloc_file_space(ip, offset, len,
|
|
|
|
XFS_BMAPI_PREALLOC);
|
2016-10-03 23:11:43 +07:00
|
|
|
}
|
2011-01-14 19:07:43 +07:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2013-10-12 14:55:07 +07:00
|
|
|
if (file->f_flags & O_DSYNC)
|
2015-02-02 05:53:56 +07:00
|
|
|
flags |= XFS_PREALLOC_SYNC;
|
|
|
|
|
|
|
|
error = xfs_update_prealloc_flags(ip, flags);
|
2011-01-14 19:07:43 +07:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
/* Change file size if needed */
|
|
|
|
if (new_size) {
|
|
|
|
struct iattr iattr;
|
|
|
|
|
|
|
|
iattr.ia_valid = ATTR_SIZE;
|
|
|
|
iattr.ia_size = new_size;
|
2016-05-26 19:46:43 +07:00
|
|
|
error = xfs_vn_setattr_size(file_dentry(file), &iattr);
|
2015-03-25 11:08:56 +07:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2011-01-14 19:07:43 +07:00
|
|
|
}
|
|
|
|
|
2015-03-25 11:08:56 +07:00
|
|
|
/*
|
|
|
|
* Perform hole insertion now that the file size has been
|
|
|
|
* updated so that if we crash during the operation we don't
|
|
|
|
* leave shifted extents past EOF and hence losing access to
|
|
|
|
* the data that is contained within them.
|
|
|
|
*/
|
|
|
|
if (do_file_insert)
|
|
|
|
error = xfs_insert_file_space(ip, offset, len);
|
|
|
|
|
2011-01-14 19:07:43 +07:00
|
|
|
out_unlock:
|
2015-02-16 07:59:50 +07:00
|
|
|
xfs_iunlock(ip, iolock);
|
2014-06-25 11:58:08 +07:00
|
|
|
return error;
|
2011-01-14 19:07:43 +07:00
|
|
|
}
|
|
|
|
|
2018-10-30 06:47:26 +07:00
|
|
|
|
2018-11-15 12:48:18 +07:00
|
|
|
STATIC loff_t
|
2018-10-30 06:41:21 +07:00
|
|
|
xfs_file_remap_range(
|
2018-10-30 06:47:26 +07:00
|
|
|
struct file *file_in,
|
|
|
|
loff_t pos_in,
|
|
|
|
struct file *file_out,
|
|
|
|
loff_t pos_out,
|
|
|
|
loff_t len,
|
|
|
|
unsigned int remap_flags)
|
2016-10-03 23:11:40 +07:00
|
|
|
{
|
2018-10-30 06:47:26 +07:00
|
|
|
struct inode *inode_in = file_inode(file_in);
|
|
|
|
struct xfs_inode *src = XFS_I(inode_in);
|
|
|
|
struct inode *inode_out = file_inode(file_out);
|
|
|
|
struct xfs_inode *dest = XFS_I(inode_out);
|
|
|
|
struct xfs_mount *mp = src->i_mount;
|
|
|
|
loff_t remapped = 0;
|
|
|
|
xfs_extlen_t cowextsize;
|
|
|
|
int ret;
|
|
|
|
|
2018-10-30 06:41:21 +07:00
|
|
|
if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
|
|
|
|
return -EINVAL;
|
2016-10-03 23:11:41 +07:00
|
|
|
|
2018-10-30 06:47:26 +07:00
|
|
|
if (!xfs_sb_version_hasreflink(&mp->m_sb))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
/* Prepare and then clone file data. */
|
|
|
|
ret = xfs_reflink_remap_prep(file_in, pos_in, file_out, pos_out,
|
|
|
|
&len, remap_flags);
|
|
|
|
if (ret < 0 || len == 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
trace_xfs_reflink_remap_range(src, pos_in, len, dest, pos_out);
|
|
|
|
|
|
|
|
ret = xfs_reflink_remap_blocks(src, pos_in, dest, pos_out, len,
|
|
|
|
&remapped);
|
|
|
|
if (ret)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Carry the cowextsize hint from src to dest if we're sharing the
|
|
|
|
* entire source file to the entire destination file, the source file
|
|
|
|
* has a cowextsize hint, and the destination file does not.
|
|
|
|
*/
|
|
|
|
cowextsize = 0;
|
|
|
|
if (pos_in == 0 && len == i_size_read(inode_in) &&
|
|
|
|
(src->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE) &&
|
|
|
|
pos_out == 0 && len >= i_size_read(inode_out) &&
|
|
|
|
!(dest->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE))
|
|
|
|
cowextsize = src->i_d.di_cowextsize;
|
|
|
|
|
|
|
|
ret = xfs_reflink_update_dest(dest, pos_out + len, cowextsize,
|
|
|
|
remap_flags);
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
xfs_reflink_remap_unlock(file_in, file_out);
|
|
|
|
if (ret)
|
|
|
|
trace_xfs_reflink_remap_range_error(dest, ret, _RET_IP_);
|
|
|
|
return remapped > 0 ? remapped : ret;
|
2016-10-03 23:11:40 +07:00
|
|
|
}
|
2011-01-14 19:07:43 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
STATIC int
|
2006-03-14 10:00:35 +07:00
|
|
|
xfs_file_open(
|
2005-04-17 05:20:36 +07:00
|
|
|
struct inode *inode,
|
2008-11-28 10:23:32 +07:00
|
|
|
struct file *file)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-11-28 10:23:32 +07:00
|
|
|
if (!(file->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EFBIG;
|
2008-11-28 10:23:32 +07:00
|
|
|
if (XFS_FORCED_SHUTDOWN(XFS_M(inode->i_sb)))
|
|
|
|
return -EIO;
|
2017-08-29 21:13:20 +07:00
|
|
|
file->f_mode |= FMODE_NOWAIT;
|
2008-11-28 10:23:32 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC int
|
|
|
|
xfs_dir_open(
|
|
|
|
struct inode *inode,
|
|
|
|
struct file *file)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
int mode;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = xfs_file_open(inode, file);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are any blocks, read-ahead block 0 as we're almost
|
|
|
|
* certain to have the next operation be a read there.
|
|
|
|
*/
|
2013-12-07 03:30:09 +07:00
|
|
|
mode = xfs_ilock_data_map_shared(ip);
|
2008-11-28 10:23:32 +07:00
|
|
|
if (ip->i_d.di_nextents > 0)
|
2017-02-03 06:13:58 +07:00
|
|
|
error = xfs_dir3_data_readahead(ip, 0, -1);
|
2008-11-28 10:23:32 +07:00
|
|
|
xfs_iunlock(ip, mode);
|
2017-02-03 06:13:58 +07:00
|
|
|
return error;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
STATIC int
|
2006-03-14 10:00:35 +07:00
|
|
|
xfs_file_release(
|
2005-04-17 05:20:36 +07:00
|
|
|
struct inode *inode,
|
|
|
|
struct file *filp)
|
|
|
|
{
|
2014-06-25 11:58:08 +07:00
|
|
|
return xfs_release(XFS_I(inode));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
STATIC int
|
2006-03-14 10:00:35 +07:00
|
|
|
xfs_file_readdir(
|
2013-05-23 04:07:56 +07:00
|
|
|
struct file *file,
|
|
|
|
struct dir_context *ctx)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2013-05-23 04:07:56 +07:00
|
|
|
struct inode *inode = file_inode(file);
|
2007-08-29 07:58:01 +07:00
|
|
|
xfs_inode_t *ip = XFS_I(inode);
|
2007-08-28 10:58:24 +07:00
|
|
|
size_t bufsize;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The Linux API doesn't pass down the total size of the buffer
|
|
|
|
* we read into down to the filesystem. With the filldir concept
|
|
|
|
* it's not needed for correct information, but the XFS dir2 leaf
|
|
|
|
* code wants an estimate of the buffer size to calculate it's
|
|
|
|
* readahead window and size the buffers used for mapping to
|
|
|
|
* physical blocks.
|
|
|
|
*
|
|
|
|
* Try to give it an estimate that's good enough, maybe at some
|
|
|
|
* point we can change the ->readdir prototype to include the
|
2010-02-04 00:50:13 +07:00
|
|
|
* buffer size. For now we use the current glibc buffer size.
|
2007-08-28 10:58:24 +07:00
|
|
|
*/
|
2017-10-18 11:37:44 +07:00
|
|
|
bufsize = (size_t)min_t(loff_t, XFS_READDIR_BUFSIZE, ip->i_d.di_size);
|
2007-08-28 10:58:24 +07:00
|
|
|
|
2017-06-17 01:00:14 +07:00
|
|
|
return xfs_readdir(NULL, ip, ctx, bufsize);
|
2012-05-10 20:29:17 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
STATIC loff_t
|
|
|
|
xfs_file_llseek(
|
|
|
|
struct file *file,
|
|
|
|
loff_t offset,
|
2014-09-09 08:57:10 +07:00
|
|
|
int whence)
|
2012-05-10 20:29:17 +07:00
|
|
|
{
|
2017-06-30 01:43:21 +07:00
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(XFS_I(inode)->i_mount))
|
|
|
|
return -EIO;
|
|
|
|
|
2014-09-09 08:57:10 +07:00
|
|
|
switch (whence) {
|
2017-06-30 01:43:21 +07:00
|
|
|
default:
|
2014-09-09 08:57:10 +07:00
|
|
|
return generic_file_llseek(file, offset, whence);
|
2012-05-10 20:29:17 +07:00
|
|
|
case SEEK_HOLE:
|
2019-02-19 00:38:46 +07:00
|
|
|
offset = iomap_seek_hole(inode, offset, &xfs_seek_iomap_ops);
|
2017-06-30 01:43:21 +07:00
|
|
|
break;
|
2014-09-09 08:56:48 +07:00
|
|
|
case SEEK_DATA:
|
2019-02-19 00:38:46 +07:00
|
|
|
offset = iomap_seek_data(inode, offset, &xfs_seek_iomap_ops);
|
2017-06-30 01:43:21 +07:00
|
|
|
break;
|
2012-05-10 20:29:17 +07:00
|
|
|
}
|
2017-06-30 01:43:21 +07:00
|
|
|
|
|
|
|
if (offset < 0)
|
|
|
|
return offset;
|
|
|
|
return vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
|
2012-05-10 20:29:17 +07:00
|
|
|
}
|
|
|
|
|
2015-02-23 17:44:19 +07:00
|
|
|
/*
|
|
|
|
* Locking for serialisation of IO during page faults. This results in a lock
|
|
|
|
* ordering of:
|
|
|
|
*
|
|
|
|
* mmap_sem (MM)
|
2015-06-04 06:18:53 +07:00
|
|
|
* sb_start_pagefault(vfs, freeze)
|
2015-11-03 08:37:02 +07:00
|
|
|
* i_mmaplock (XFS - truncate serialisation)
|
2015-06-04 06:18:53 +07:00
|
|
|
* page_lock (MM)
|
|
|
|
* i_lock (XFS - extent map serialisation)
|
2015-02-23 17:44:19 +07:00
|
|
|
*/
|
2018-05-30 00:39:03 +07:00
|
|
|
static vm_fault_t
|
2017-08-30 00:08:41 +07:00
|
|
|
__xfs_filemap_fault(
|
|
|
|
struct vm_fault *vmf,
|
|
|
|
enum page_entry_size pe_size,
|
|
|
|
bool write_fault)
|
2015-02-23 17:44:19 +07:00
|
|
|
{
|
2017-02-25 05:56:41 +07:00
|
|
|
struct inode *inode = file_inode(vmf->vma->vm_file);
|
2017-08-30 00:08:41 +07:00
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
2018-05-30 00:39:03 +07:00
|
|
|
vm_fault_t ret;
|
2015-02-23 17:44:19 +07:00
|
|
|
|
2017-08-30 00:08:41 +07:00
|
|
|
trace_xfs_filemap_fault(ip, pe_size, write_fault);
|
2015-02-23 17:44:19 +07:00
|
|
|
|
2017-08-30 00:08:41 +07:00
|
|
|
if (write_fault) {
|
|
|
|
sb_start_pagefault(inode->i_sb);
|
|
|
|
file_update_time(vmf->vma->vm_file);
|
|
|
|
}
|
2015-02-23 17:44:19 +07:00
|
|
|
|
2017-08-30 00:08:41 +07:00
|
|
|
xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
|
2015-06-04 06:18:53 +07:00
|
|
|
if (IS_DAX(inode)) {
|
2017-11-01 22:36:47 +07:00
|
|
|
pfn_t pfn;
|
|
|
|
|
2018-01-08 04:38:43 +07:00
|
|
|
ret = dax_iomap_fault(vmf, pe_size, &pfn, NULL, &xfs_iomap_ops);
|
2017-11-01 22:36:47 +07:00
|
|
|
if (ret & VM_FAULT_NEEDDSYNC)
|
|
|
|
ret = dax_finish_sync_fault(vmf, pe_size, pfn);
|
2015-06-04 06:18:53 +07:00
|
|
|
} else {
|
2017-08-30 00:08:41 +07:00
|
|
|
if (write_fault)
|
|
|
|
ret = iomap_page_mkwrite(vmf, &xfs_iomap_ops);
|
|
|
|
else
|
|
|
|
ret = filemap_fault(vmf);
|
2015-06-04 06:18:53 +07:00
|
|
|
}
|
|
|
|
xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
|
|
|
|
|
2017-08-30 00:08:41 +07:00
|
|
|
if (write_fault)
|
|
|
|
sb_end_pagefault(inode->i_sb);
|
2015-06-04 06:18:53 +07:00
|
|
|
return ret;
|
2015-02-23 17:44:19 +07:00
|
|
|
}
|
|
|
|
|
2018-05-30 00:39:03 +07:00
|
|
|
static vm_fault_t
|
2015-06-04 06:18:53 +07:00
|
|
|
xfs_filemap_fault(
|
2015-02-23 17:44:54 +07:00
|
|
|
struct vm_fault *vmf)
|
|
|
|
{
|
2015-06-04 06:18:53 +07:00
|
|
|
/* DAX can shortcut the normal fault path on write faults! */
|
2017-08-30 00:08:41 +07:00
|
|
|
return __xfs_filemap_fault(vmf, PE_SIZE_PTE,
|
|
|
|
IS_DAX(file_inode(vmf->vma->vm_file)) &&
|
|
|
|
(vmf->flags & FAULT_FLAG_WRITE));
|
2015-06-04 06:18:53 +07:00
|
|
|
}
|
|
|
|
|
2018-05-30 00:39:03 +07:00
|
|
|
static vm_fault_t
|
mm,fs,dax: change ->pmd_fault to ->huge_fault
Patch series "1G transparent hugepage support for device dax", v2.
The following series implements support for 1G trasparent hugepage on
x86 for device dax. The bulk of the code was written by Mathew Wilcox a
while back supporting transparent 1G hugepage for fs DAX. I have
forward ported the relevant bits to 4.10-rc. The current submission has
only the necessary code to support device DAX.
Comments from Dan Williams: So the motivation and intended user of this
functionality mirrors the motivation and users of 1GB page support in
hugetlbfs. Given expected capacities of persistent memory devices an
in-memory database may want to reduce tlb pressure beyond what they can
already achieve with 2MB mappings of a device-dax file. We have
customer feedback to that effect as Willy mentioned in his previous
version of these patches [1].
[1]: https://lkml.org/lkml/2016/1/31/52
Comments from Nilesh @ Oracle:
There are applications which have a process model; and if you assume
10,000 processes attempting to mmap all the 6TB memory available on a
server; we are looking at the following:
processes : 10,000
memory : 6TB
pte @ 4k page size: 8 bytes / 4K of memory * #processes = 6TB / 4k * 8 * 10000 = 1.5GB * 80000 = 120,000GB
pmd @ 2M page size: 120,000 / 512 = ~240GB
pud @ 1G page size: 240GB / 512 = ~480MB
As you can see with 2M pages, this system will use up an exorbitant
amount of DRAM to hold the page tables; but the 1G pages finally brings
it down to a reasonable level. Memory sizes will keep increasing; so
this number will keep increasing.
An argument can be made to convert the applications from process model
to thread model, but in the real world that may not be always practical.
Hopefully this helps explain the use case where this is valuable.
This patch (of 3):
In preparation for adding the ability to handle PUD pages, convert
vm_operations_struct.pmd_fault to vm_operations_struct.huge_fault. The
vm_fault structure is extended to include a union of the different page
table pointers that may be needed, and three flag bits are reserved to
indicate which type of pointer is in the union.
[ross.zwisler@linux.intel.com: remove unused function ext4_dax_huge_fault()]
Link: http://lkml.kernel.org/r/1485813172-7284-1-git-send-email-ross.zwisler@linux.intel.com
[dave.jiang@intel.com: clear PMD or PUD size flags when in fall through path]
Link: http://lkml.kernel.org/r/148589842696.5820.16078080610311444794.stgit@djiang5-desk3.ch.intel.com
Link: http://lkml.kernel.org/r/148545058784.17912.6353162518188733642.stgit@djiang5-desk3.ch.intel.com
Signed-off-by: Matthew Wilcox <mawilcox@microsoft.com>
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Signed-off-by: Ross Zwisler <ross.zwisler@linux.intel.com>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Jan Kara <jack@suse.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Cc: Nilesh Choudhury <nilesh.choudhury@oracle.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Dave Jiang <dave.jiang@intel.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-02-25 05:56:59 +07:00
|
|
|
xfs_filemap_huge_fault(
|
2017-02-25 05:57:08 +07:00
|
|
|
struct vm_fault *vmf,
|
|
|
|
enum page_entry_size pe_size)
|
2015-09-09 04:59:06 +07:00
|
|
|
{
|
2017-08-30 00:08:41 +07:00
|
|
|
if (!IS_DAX(file_inode(vmf->vma->vm_file)))
|
2015-09-09 04:59:06 +07:00
|
|
|
return VM_FAULT_FALLBACK;
|
|
|
|
|
2017-08-30 00:08:41 +07:00
|
|
|
/* DAX can shortcut the normal fault path on write faults! */
|
|
|
|
return __xfs_filemap_fault(vmf, pe_size,
|
|
|
|
(vmf->flags & FAULT_FLAG_WRITE));
|
|
|
|
}
|
2015-09-09 04:59:06 +07:00
|
|
|
|
2018-05-30 00:39:03 +07:00
|
|
|
static vm_fault_t
|
2017-08-30 00:08:41 +07:00
|
|
|
xfs_filemap_page_mkwrite(
|
|
|
|
struct vm_fault *vmf)
|
|
|
|
{
|
|
|
|
return __xfs_filemap_fault(vmf, PE_SIZE_PTE, true);
|
2015-09-09 04:59:06 +07:00
|
|
|
}
|
|
|
|
|
2015-11-03 08:37:02 +07:00
|
|
|
/*
|
2017-11-01 22:36:46 +07:00
|
|
|
* pfn_mkwrite was originally intended to ensure we capture time stamp updates
|
|
|
|
* on write faults. In reality, it needs to serialise against truncate and
|
|
|
|
* prepare memory for writing so handle is as standard write fault.
|
2015-11-03 08:37:02 +07:00
|
|
|
*/
|
2018-05-30 00:39:03 +07:00
|
|
|
static vm_fault_t
|
2015-11-03 08:37:02 +07:00
|
|
|
xfs_filemap_pfn_mkwrite(
|
|
|
|
struct vm_fault *vmf)
|
|
|
|
{
|
|
|
|
|
2017-11-01 22:36:46 +07:00
|
|
|
return __xfs_filemap_fault(vmf, PE_SIZE_PTE, true);
|
2015-09-09 04:59:06 +07:00
|
|
|
}
|
|
|
|
|
2015-06-04 06:18:53 +07:00
|
|
|
static const struct vm_operations_struct xfs_file_vm_ops = {
|
|
|
|
.fault = xfs_filemap_fault,
|
mm,fs,dax: change ->pmd_fault to ->huge_fault
Patch series "1G transparent hugepage support for device dax", v2.
The following series implements support for 1G trasparent hugepage on
x86 for device dax. The bulk of the code was written by Mathew Wilcox a
while back supporting transparent 1G hugepage for fs DAX. I have
forward ported the relevant bits to 4.10-rc. The current submission has
only the necessary code to support device DAX.
Comments from Dan Williams: So the motivation and intended user of this
functionality mirrors the motivation and users of 1GB page support in
hugetlbfs. Given expected capacities of persistent memory devices an
in-memory database may want to reduce tlb pressure beyond what they can
already achieve with 2MB mappings of a device-dax file. We have
customer feedback to that effect as Willy mentioned in his previous
version of these patches [1].
[1]: https://lkml.org/lkml/2016/1/31/52
Comments from Nilesh @ Oracle:
There are applications which have a process model; and if you assume
10,000 processes attempting to mmap all the 6TB memory available on a
server; we are looking at the following:
processes : 10,000
memory : 6TB
pte @ 4k page size: 8 bytes / 4K of memory * #processes = 6TB / 4k * 8 * 10000 = 1.5GB * 80000 = 120,000GB
pmd @ 2M page size: 120,000 / 512 = ~240GB
pud @ 1G page size: 240GB / 512 = ~480MB
As you can see with 2M pages, this system will use up an exorbitant
amount of DRAM to hold the page tables; but the 1G pages finally brings
it down to a reasonable level. Memory sizes will keep increasing; so
this number will keep increasing.
An argument can be made to convert the applications from process model
to thread model, but in the real world that may not be always practical.
Hopefully this helps explain the use case where this is valuable.
This patch (of 3):
In preparation for adding the ability to handle PUD pages, convert
vm_operations_struct.pmd_fault to vm_operations_struct.huge_fault. The
vm_fault structure is extended to include a union of the different page
table pointers that may be needed, and three flag bits are reserved to
indicate which type of pointer is in the union.
[ross.zwisler@linux.intel.com: remove unused function ext4_dax_huge_fault()]
Link: http://lkml.kernel.org/r/1485813172-7284-1-git-send-email-ross.zwisler@linux.intel.com
[dave.jiang@intel.com: clear PMD or PUD size flags when in fall through path]
Link: http://lkml.kernel.org/r/148589842696.5820.16078080610311444794.stgit@djiang5-desk3.ch.intel.com
Link: http://lkml.kernel.org/r/148545058784.17912.6353162518188733642.stgit@djiang5-desk3.ch.intel.com
Signed-off-by: Matthew Wilcox <mawilcox@microsoft.com>
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Signed-off-by: Ross Zwisler <ross.zwisler@linux.intel.com>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Jan Kara <jack@suse.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Cc: Nilesh Choudhury <nilesh.choudhury@oracle.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Dave Jiang <dave.jiang@intel.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-02-25 05:56:59 +07:00
|
|
|
.huge_fault = xfs_filemap_huge_fault,
|
2015-06-04 06:18:53 +07:00
|
|
|
.map_pages = filemap_map_pages,
|
|
|
|
.page_mkwrite = xfs_filemap_page_mkwrite,
|
2015-11-03 08:37:02 +07:00
|
|
|
.pfn_mkwrite = xfs_filemap_pfn_mkwrite,
|
2015-06-04 06:18:53 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
STATIC int
|
|
|
|
xfs_file_mmap(
|
|
|
|
struct file *filp,
|
|
|
|
struct vm_area_struct *vma)
|
|
|
|
{
|
2017-11-01 22:36:47 +07:00
|
|
|
/*
|
|
|
|
* We don't support synchronous mappings for non-DAX files. At least
|
|
|
|
* until someone comes with a sensible use case.
|
|
|
|
*/
|
|
|
|
if (!IS_DAX(file_inode(filp)) && (vma->vm_flags & VM_SYNC))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2015-06-04 06:18:53 +07:00
|
|
|
file_accessed(filp);
|
|
|
|
vma->vm_ops = &xfs_file_vm_ops;
|
|
|
|
if (IS_DAX(file_inode(filp)))
|
2018-08-18 05:43:40 +07:00
|
|
|
vma->vm_flags |= VM_HUGEPAGE;
|
2015-06-04 06:18:53 +07:00
|
|
|
return 0;
|
2015-02-23 17:44:54 +07:00
|
|
|
}
|
|
|
|
|
2006-03-28 16:56:42 +07:00
|
|
|
const struct file_operations xfs_file_operations = {
|
2012-05-10 20:29:17 +07:00
|
|
|
.llseek = xfs_file_llseek,
|
2014-04-03 01:37:59 +07:00
|
|
|
.read_iter = xfs_file_read_iter,
|
2014-04-04 01:20:23 +07:00
|
|
|
.write_iter = xfs_file_write_iter,
|
2016-09-23 10:35:42 +07:00
|
|
|
.splice_read = generic_file_splice_read,
|
2014-04-05 15:27:08 +07:00
|
|
|
.splice_write = iter_file_splice_write,
|
2018-12-05 01:12:08 +07:00
|
|
|
.iopoll = iomap_dio_iopoll,
|
2006-03-14 10:00:35 +07:00
|
|
|
.unlocked_ioctl = xfs_file_ioctl,
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_COMPAT
|
2006-03-14 10:00:35 +07:00
|
|
|
.compat_ioctl = xfs_file_compat_ioctl,
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
2006-03-14 10:00:35 +07:00
|
|
|
.mmap = xfs_file_mmap,
|
2017-11-01 22:36:47 +07:00
|
|
|
.mmap_supported_flags = MAP_SYNC,
|
2006-03-14 10:00:35 +07:00
|
|
|
.open = xfs_file_open,
|
|
|
|
.release = xfs_file_release,
|
|
|
|
.fsync = xfs_file_fsync,
|
2016-10-08 06:59:59 +07:00
|
|
|
.get_unmapped_area = thp_get_unmapped_area,
|
2011-01-14 19:07:43 +07:00
|
|
|
.fallocate = xfs_file_fallocate,
|
2018-10-30 06:41:21 +07:00
|
|
|
.remap_file_range = xfs_file_remap_range,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2006-03-28 16:56:42 +07:00
|
|
|
const struct file_operations xfs_dir_file_operations = {
|
2008-11-28 10:23:32 +07:00
|
|
|
.open = xfs_dir_open,
|
2005-04-17 05:20:36 +07:00
|
|
|
.read = generic_read_dir,
|
2016-04-21 10:42:46 +07:00
|
|
|
.iterate_shared = xfs_file_readdir,
|
2008-08-24 18:24:41 +07:00
|
|
|
.llseek = generic_file_llseek,
|
2006-03-14 10:00:35 +07:00
|
|
|
.unlocked_ioctl = xfs_file_ioctl,
|
2005-05-06 20:44:46 +07:00
|
|
|
#ifdef CONFIG_COMPAT
|
2006-03-14 10:00:35 +07:00
|
|
|
.compat_ioctl = xfs_file_compat_ioctl,
|
2005-05-06 20:44:46 +07:00
|
|
|
#endif
|
2011-10-02 21:25:16 +07:00
|
|
|
.fsync = xfs_dir_fsync,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|