2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-11-01 20:58:39 -07:00
|
|
|
* Copyright (c) 2000-2005 Silicon Graphics, Inc.
|
|
|
|
* All Rights Reserved.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
2005-04-16 16:20:36 -06:00
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is distributed in the hope that it would be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
2010-02-15 02:44:46 -07:00
|
|
|
#include "xfs_fs.h"
|
2013-10-22 17:36:05 -06:00
|
|
|
#include "xfs_shared.h"
|
2013-10-22 17:51:50 -06:00
|
|
|
#include "xfs_format.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_mount.h"
|
2013-10-14 16:17:51 -06:00
|
|
|
#include "xfs_da_format.h"
|
|
|
|
#include "xfs_da_btree.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_inode.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_trans.h"
|
2010-02-15 02:44:48 -07:00
|
|
|
#include "xfs_inode_item.h"
|
2010-02-15 02:44:46 -07:00
|
|
|
#include "xfs_bmap.h"
|
2013-08-12 04:49:45 -06:00
|
|
|
#include "xfs_bmap_util.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_error.h"
|
2013-08-12 04:49:37 -06:00
|
|
|
#include "xfs_dir2.h"
|
2013-08-12 04:49:45 -06:00
|
|
|
#include "xfs_dir2_priv.h"
|
2008-12-03 05:55:34 -07:00
|
|
|
#include "xfs_ioctl.h"
|
2010-02-15 02:44:46 -07:00
|
|
|
#include "xfs_trace.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_log.h"
|
2014-07-24 03:49:28 -06:00
|
|
|
#include "xfs_icache.h"
|
2015-02-15 17:59:50 -07:00
|
|
|
#include "xfs_pnfs.h"
|
2016-06-20 17:53:44 -06:00
|
|
|
#include "xfs_iomap.h"
|
2016-10-03 10:11:37 -06:00
|
|
|
#include "xfs_reflink.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <linux/dcache.h>
|
2011-01-14 05:07:43 -07:00
|
|
|
#include <linux/falloc.h>
|
2012-08-21 03:11:57 -06:00
|
|
|
#include <linux/pagevec.h>
|
2015-05-22 15:13:32 -06:00
|
|
|
#include <linux/backing-dev.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-27 12:29:37 -06:00
|
|
|
static const struct vm_operations_struct xfs_file_vm_ops;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-01-11 17:37:10 -07:00
|
|
|
/*
|
|
|
|
* Locking primitives for read and write IO paths to ensure we consistently use
|
|
|
|
* and order the inode->i_mutex, ip->i_lock and ip->i_iolock.
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
xfs_rw_ilock(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
int type)
|
|
|
|
{
|
|
|
|
if (type & XFS_IOLOCK_EXCL)
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock(VFS_I(ip));
|
2011-01-11 17:37:10 -07:00
|
|
|
xfs_ilock(ip, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
xfs_rw_iunlock(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
int type)
|
|
|
|
{
|
|
|
|
xfs_iunlock(ip, type);
|
|
|
|
if (type & XFS_IOLOCK_EXCL)
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(VFS_I(ip));
|
2011-01-11 17:37:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
xfs_rw_ilock_demote(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
int type)
|
|
|
|
{
|
|
|
|
xfs_ilock_demote(ip, type);
|
|
|
|
if (type & XFS_IOLOCK_EXCL)
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(VFS_I(ip));
|
2011-01-11 17:37:10 -07:00
|
|
|
}
|
|
|
|
|
2010-02-15 02:44:46 -07:00
|
|
|
/*
|
2016-06-20 17:53:44 -06:00
|
|
|
* Clear the specified ranges to zero through either the pagecache or DAX.
|
|
|
|
* Holes and unwritten extents will be left as-is as they already are zeroed.
|
2010-02-15 02:44:46 -07:00
|
|
|
*/
|
2012-11-28 21:26:33 -07:00
|
|
|
int
|
2016-06-20 17:56:26 -06:00
|
|
|
xfs_zero_range(
|
2016-06-20 17:53:44 -06:00
|
|
|
struct xfs_inode *ip,
|
2016-06-20 17:56:26 -06:00
|
|
|
xfs_off_t pos,
|
|
|
|
xfs_off_t count,
|
|
|
|
bool *did_zero)
|
2010-02-15 02:44:46 -07:00
|
|
|
{
|
2016-06-20 17:55:18 -06:00
|
|
|
return iomap_zero_range(VFS_I(ip), pos, count, NULL, &xfs_iomap_ops);
|
2010-02-15 02:44:46 -07:00
|
|
|
}
|
|
|
|
|
2015-02-01 15: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-05 17:19:55 -06:00
|
|
|
error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_writeid,
|
|
|
|
0, 0, 0, &tp);
|
|
|
|
if (error)
|
2015-02-01 15: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-08 22: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-01 15: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-03 21:48:08 -06:00
|
|
|
return xfs_trans_commit(tp);
|
2015-02-01 15:53:56 -07:00
|
|
|
}
|
|
|
|
|
2011-10-02 08:25:16 -06: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;
|
2014-06-24 22:58:08 -06:00
|
|
|
return _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
|
2011-10-02 08:25:16 -06:00
|
|
|
}
|
|
|
|
|
2010-02-15 02:44:48 -07:00
|
|
|
STATIC int
|
|
|
|
xfs_file_fsync(
|
|
|
|
struct file *file,
|
2011-07-16 18:44:56 -06:00
|
|
|
loff_t start,
|
|
|
|
loff_t end,
|
2010-02-15 02:44:48 -07:00
|
|
|
int datasync)
|
|
|
|
{
|
2010-05-26 09:53:25 -06:00
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
2011-06-16 06:02:23 -06:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2010-02-15 02:44:48 -07:00
|
|
|
int error = 0;
|
|
|
|
int log_flushed = 0;
|
2011-09-19 08:55:51 -06:00
|
|
|
xfs_lsn_t lsn = 0;
|
2010-02-15 02:44:48 -07:00
|
|
|
|
2010-06-23 19:57:09 -06:00
|
|
|
trace_xfs_file_fsync(ip);
|
2010-02-15 02:44:48 -07:00
|
|
|
|
2011-07-16 18:44:56 -06:00
|
|
|
error = filemap_write_and_wait_range(inode->i_mapping, start, end);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2011-06-16 06:02:23 -06:00
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
2014-06-21 23:04:54 -06:00
|
|
|
return -EIO;
|
2010-02-15 02:44:48 -07:00
|
|
|
|
|
|
|
xfs_iflags_clear(ip, XFS_ITRUNCATED);
|
|
|
|
|
2011-06-16 06:02:23 -06:00
|
|
|
if (mp->m_flags & XFS_MOUNT_BARRIER) {
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2010-02-15 02: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-02 19: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 02:44:48 -07:00
|
|
|
*/
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_SHARED);
|
2012-02-29 02: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-02 19:14:59 -07:00
|
|
|
(ip->i_itemp->ili_fsync_fields & ~XFS_ILOG_TIMESTAMP))
|
2012-02-29 02:53:55 -07:00
|
|
|
lsn = ip->i_itemp->ili_last_lsn;
|
|
|
|
}
|
2010-02-15 02: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-02 19:14:59 -07:00
|
|
|
if (lsn) {
|
2011-09-19 08:55:51 -06: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-02 19:14:59 -07:00
|
|
|
ip->i_itemp->ili_fsync_fields = 0;
|
|
|
|
}
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_SHARED);
|
2011-09-19 08:55:51 -06:00
|
|
|
|
2011-06-16 06:02:23 -06: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.
|
|
|
|
*/
|
|
|
|
if ((mp->m_flags & XFS_MOUNT_BARRIER) &&
|
|
|
|
mp->m_logdev_targp == mp->m_ddev_targp &&
|
|
|
|
!XFS_IS_REALTIME_INODE(ip) &&
|
|
|
|
!log_flushed)
|
|
|
|
xfs_blkdev_issue_flush(mp->m_ddev_targp);
|
2010-02-15 02:44:48 -07:00
|
|
|
|
2014-06-24 22:58:08 -06:00
|
|
|
return error;
|
2010-02-15 02:44:48 -07:00
|
|
|
}
|
|
|
|
|
2010-02-15 02:44:47 -07:00
|
|
|
STATIC ssize_t
|
2016-07-19 19:35:42 -06:00
|
|
|
xfs_file_dio_aio_read(
|
2010-02-15 02:44:46 -07:00
|
|
|
struct kiocb *iocb,
|
2014-04-02 12:37:59 -06:00
|
|
|
struct iov_iter *to)
|
2010-02-15 02:44:46 -07:00
|
|
|
{
|
2016-07-19 19:35:42 -06:00
|
|
|
struct address_space *mapping = iocb->ki_filp->f_mapping;
|
|
|
|
struct inode *inode = mapping->host;
|
2010-02-15 02:44:47 -07:00
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
2016-07-19 19:36:57 -06:00
|
|
|
loff_t isize = i_size_read(inode);
|
2016-07-19 19:35:42 -06:00
|
|
|
size_t count = iov_iter_count(to);
|
2016-10-19 22:44:14 -06:00
|
|
|
loff_t end = iocb->ki_pos + count - 1;
|
2016-07-19 19:36:57 -06:00
|
|
|
struct iov_iter data;
|
2016-07-19 19:35:42 -06:00
|
|
|
struct xfs_buftarg *target;
|
2010-02-15 02:44:46 -07:00
|
|
|
ssize_t ret = 0;
|
|
|
|
|
2016-07-19 19:35:42 -06:00
|
|
|
trace_xfs_file_direct_read(ip, count, iocb->ki_pos);
|
2010-02-15 02:44:46 -07:00
|
|
|
|
2016-07-19 19:36:57 -06:00
|
|
|
if (!count)
|
|
|
|
return 0; /* skip atime */
|
2010-02-15 02:44:46 -07:00
|
|
|
|
2016-07-19 19:35:42 -06:00
|
|
|
if (XFS_IS_REALTIME_INODE(ip))
|
|
|
|
target = ip->i_mount->m_rtdev_targp;
|
|
|
|
else
|
|
|
|
target = ip->i_mount->m_ddev_targp;
|
2010-02-15 02:44:46 -07:00
|
|
|
|
2016-07-19 19:38:55 -06:00
|
|
|
/* DIO must be aligned to device logical sector size */
|
|
|
|
if ((iocb->ki_pos | count) & target->bt_logical_sectormask) {
|
|
|
|
if (iocb->ki_pos == isize)
|
|
|
|
return 0;
|
|
|
|
return -EINVAL;
|
2010-02-15 02:44:46 -07:00
|
|
|
}
|
|
|
|
|
2016-10-02 16:47:34 -06:00
|
|
|
file_accessed(iocb->ki_filp);
|
|
|
|
|
2011-08-25 01:17:01 -06:00
|
|
|
xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
|
2016-07-19 19:35:42 -06:00
|
|
|
if (mapping->nrpages) {
|
2016-10-19 22:44:14 -06:00
|
|
|
ret = filemap_write_and_wait_range(mapping, iocb->ki_pos, end);
|
|
|
|
if (ret)
|
|
|
|
goto out_unlock;
|
2011-01-11 17:37:10 -07:00
|
|
|
|
2015-08-18 18:35:04 -06:00
|
|
|
/*
|
2016-10-19 22:44:14 -06:00
|
|
|
* Invalidate whole pages. This can return an error if we fail
|
|
|
|
* to invalidate a page, but this should never happen on XFS.
|
|
|
|
* Warn if it does fail.
|
2015-08-18 18:35:04 -06:00
|
|
|
*/
|
2016-10-19 22:44:14 -06:00
|
|
|
ret = invalidate_inode_pages2_range(mapping,
|
|
|
|
iocb->ki_pos >> PAGE_SHIFT, end >> PAGE_SHIFT);
|
|
|
|
WARN_ON_ONCE(ret);
|
|
|
|
ret = 0;
|
2011-08-25 01:17:01 -06:00
|
|
|
}
|
2010-02-15 02:44:46 -07:00
|
|
|
|
2016-07-19 19:36:57 -06:00
|
|
|
data = *to;
|
2016-07-19 19:38:55 -06:00
|
|
|
ret = __blockdev_direct_IO(iocb, inode, target->bt_bdev, &data,
|
|
|
|
xfs_get_blocks_direct, NULL, NULL, 0);
|
2016-10-10 11:26:27 -06:00
|
|
|
if (ret >= 0) {
|
2016-07-19 19:38:55 -06:00
|
|
|
iocb->ki_pos += ret;
|
|
|
|
iov_iter_advance(to, ret);
|
2016-07-19 19:38:01 -06:00
|
|
|
}
|
2010-02-15 02:44:46 -07:00
|
|
|
|
2016-10-19 22:44:14 -06:00
|
|
|
out_unlock:
|
|
|
|
xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
|
2016-07-19 19:38:55 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-07-21 17:50:55 -06:00
|
|
|
static noinline ssize_t
|
2016-07-19 19:38:55 -06:00
|
|
|
xfs_file_dax_read(
|
|
|
|
struct kiocb *iocb,
|
|
|
|
struct iov_iter *to)
|
|
|
|
{
|
2016-09-18 19:28:38 -06:00
|
|
|
struct xfs_inode *ip = XFS_I(iocb->ki_filp->f_mapping->host);
|
2016-07-19 19:38:55 -06: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 */
|
|
|
|
|
|
|
|
xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
|
2016-09-18 19:28:38 -06:00
|
|
|
ret = iomap_dax_rw(iocb, to, &xfs_iomap_ops);
|
2016-07-19 19:35:42 -06:00
|
|
|
xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
|
|
|
|
|
2016-07-19 19:36:57 -06:00
|
|
|
file_accessed(iocb->ki_filp);
|
2016-07-19 19:35:42 -06: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 02:44:46 -07:00
|
|
|
|
2016-07-19 19:35:42 -06:00
|
|
|
xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
|
2014-04-02 12:37:59 -06:00
|
|
|
ret = generic_file_read_iter(iocb, to);
|
2016-07-19 19:35:42 -06:00
|
|
|
xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC ssize_t
|
|
|
|
xfs_file_read_iter(
|
|
|
|
struct kiocb *iocb,
|
|
|
|
struct iov_iter *to)
|
|
|
|
{
|
2016-07-19 19:38:55 -06:00
|
|
|
struct inode *inode = file_inode(iocb->ki_filp);
|
|
|
|
struct xfs_mount *mp = XFS_I(inode)->i_mount;
|
2016-07-19 19:35:42 -06:00
|
|
|
ssize_t ret = 0;
|
|
|
|
|
|
|
|
XFS_STATS_INC(mp, xs_read_calls);
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
|
|
|
return -EIO;
|
|
|
|
|
2016-07-19 19:38:55 -06:00
|
|
|
if (IS_DAX(inode))
|
|
|
|
ret = xfs_file_dax_read(iocb, to);
|
|
|
|
else if (iocb->ki_flags & IOCB_DIRECT)
|
2016-07-19 19:35:42 -06:00
|
|
|
ret = xfs_file_dio_aio_read(iocb, to);
|
2016-07-19 19:31:42 -06:00
|
|
|
else
|
2016-07-19 19:35:42 -06:00
|
|
|
ret = xfs_file_buffered_aio_read(iocb, to);
|
2010-02-15 02:44:46 -07:00
|
|
|
|
|
|
|
if (ret > 0)
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_ADD(mp, xs_read_bytes, ret);
|
2010-02-15 02:44:46 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-03-27 08:34:49 -06:00
|
|
|
* Zero any on disk space between the current EOF and the new, larger EOF.
|
|
|
|
*
|
|
|
|
* This handles the normal case of zeroing the remainder of the last block in
|
|
|
|
* the file and the unusual case of zeroing blocks out beyond the size of the
|
|
|
|
* file. This second case only happens with fixed size extents and when the
|
|
|
|
* system crashes before the inode size was updated but after blocks were
|
|
|
|
* allocated.
|
|
|
|
*
|
|
|
|
* Expects the iolock to be held exclusive, and will take the ilock internally.
|
2010-02-15 02:44:46 -07:00
|
|
|
*/
|
|
|
|
int /* error (positive) */
|
|
|
|
xfs_zero_eof(
|
2012-03-27 08:34:49 -06:00
|
|
|
struct xfs_inode *ip,
|
|
|
|
xfs_off_t offset, /* starting I/O offset */
|
2015-02-23 04:37:08 -07:00
|
|
|
xfs_fsize_t isize, /* current inode size */
|
|
|
|
bool *did_zeroing)
|
2010-02-15 02:44:46 -07:00
|
|
|
{
|
2012-03-27 08:34:49 -06:00
|
|
|
ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
|
2010-02-15 02:44:46 -07:00
|
|
|
ASSERT(offset > isize);
|
|
|
|
|
2015-10-11 23:02:08 -06:00
|
|
|
trace_xfs_zero_eof(ip, isize, offset - isize);
|
2016-06-20 17:57:26 -06:00
|
|
|
return xfs_zero_range(ip, isize, offset - isize, did_zeroing);
|
2010-02-15 02:44:46 -07:00
|
|
|
}
|
|
|
|
|
2011-01-10 16:23:42 -07:00
|
|
|
/*
|
|
|
|
* Common pre-write limit and setup checks.
|
|
|
|
*
|
2011-12-18 13: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-10 16:23:42 -07:00
|
|
|
*/
|
|
|
|
STATIC ssize_t
|
|
|
|
xfs_file_aio_write_checks(
|
2015-04-07 12:25:18 -06:00
|
|
|
struct kiocb *iocb,
|
|
|
|
struct iov_iter *from,
|
2011-01-10 16:23:42 -07:00
|
|
|
int *iolock)
|
|
|
|
{
|
2015-04-07 12:25:18 -06:00
|
|
|
struct file *file = iocb->ki_filp;
|
2011-01-10 16:23:42 -07:00
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
2015-04-09 10:55:47 -06:00
|
|
|
ssize_t error = 0;
|
2015-04-07 12:25:18 -06:00
|
|
|
size_t count = iov_iter_count(from);
|
2015-10-11 23:02:05 -06:00
|
|
|
bool drained_dio = false;
|
2011-01-10 16: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 01:17:02 -06:00
|
|
|
restart:
|
2015-04-09 10:55:47 -06:00
|
|
|
error = generic_write_checks(iocb, from);
|
|
|
|
if (error <= 0)
|
2011-01-10 16:23:42 -07:00
|
|
|
return error;
|
|
|
|
|
2015-04-12 19:38:29 -06:00
|
|
|
error = xfs_break_layouts(inode, iolock, true);
|
2015-02-15 17:59:50 -07:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2015-05-21 08:05:56 -06:00
|
|
|
/* For changing security info in file_remove_privs() we need i_mutex */
|
|
|
|
if (*iolock == XFS_IOLOCK_SHARED && !IS_NOSEC(inode)) {
|
|
|
|
xfs_rw_iunlock(ip, *iolock);
|
|
|
|
*iolock = XFS_IOLOCK_EXCL;
|
|
|
|
xfs_rw_ilock(ip, *iolock);
|
|
|
|
goto restart;
|
|
|
|
}
|
2011-01-10 16: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-18 13:00:12 -07:00
|
|
|
* write. If zeroing is needed and we are currently holding the
|
2012-03-27 08:34:47 -06:00
|
|
|
* iolock shared, we need to update it to exclusive which implies
|
|
|
|
* having to redo all checks before.
|
2015-04-16 06:03:07 -06: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-10 16:23:42 -07:00
|
|
|
*/
|
2015-04-16 06:03:07 -06:00
|
|
|
spin_lock(&ip->i_flags_lock);
|
2015-04-07 12:25:18 -06:00
|
|
|
if (iocb->ki_pos > i_size_read(inode)) {
|
2015-02-23 04:37:08 -07:00
|
|
|
bool zero = false;
|
|
|
|
|
2015-04-16 06:03:07 -06:00
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2015-10-11 23:02:05 -06:00
|
|
|
if (!drained_dio) {
|
|
|
|
if (*iolock == XFS_IOLOCK_SHARED) {
|
|
|
|
xfs_rw_iunlock(ip, *iolock);
|
|
|
|
*iolock = XFS_IOLOCK_EXCL;
|
|
|
|
xfs_rw_ilock(ip, *iolock);
|
|
|
|
iov_iter_reexpand(from, count);
|
|
|
|
}
|
2015-04-16 06:03:17 -06: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-11 23:02:05 -06: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 01:17:02 -06:00
|
|
|
goto restart;
|
|
|
|
}
|
2015-04-07 12:25:18 -06:00
|
|
|
error = xfs_zero_eof(ip, iocb->ki_pos, i_size_read(inode), &zero);
|
2012-03-27 08:34:47 -06:00
|
|
|
if (error)
|
|
|
|
return error;
|
2015-04-16 06:03:07 -06:00
|
|
|
} else
|
|
|
|
spin_unlock(&ip->i_flags_lock);
|
2011-01-10 16:23:42 -07:00
|
|
|
|
2012-02-29 02: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 07:59:21 -06:00
|
|
|
if (likely(!(file->f_mode & FMODE_NOCMTIME))) {
|
|
|
|
error = file_update_time(file);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
2012-02-29 02:53:52 -07:00
|
|
|
|
2011-01-10 16: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 08:05:56 -06:00
|
|
|
if (!IS_NOSEC(inode))
|
|
|
|
return file_remove_privs(file);
|
|
|
|
return 0;
|
2011-01-10 16:23:42 -07:00
|
|
|
}
|
|
|
|
|
2011-01-10 16: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-10 16:22:40 -07:00
|
|
|
* By separating it from the buffered write path we remove all the tricky to
|
2011-01-10 16:15:36 -07:00
|
|
|
* follow locking changes and looping.
|
|
|
|
*
|
2011-01-10 16: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 02:28:13 -06:00
|
|
|
* hitting it with a big hammer (i.e. inode_dio_wait()).
|
2011-01-10 16:22:40 -07:00
|
|
|
*
|
2011-01-10 16: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 05:06:30 -06:00
|
|
|
struct iov_iter *from)
|
2011-01-10 16: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-10 16:22:40 -07:00
|
|
|
int unaligned_io = 0;
|
2011-12-18 13:00:14 -07:00
|
|
|
int iolock;
|
2014-04-02 05:06:30 -06:00
|
|
|
size_t count = iov_iter_count(from);
|
2015-04-16 06:03:27 -06:00
|
|
|
loff_t end;
|
|
|
|
struct iov_iter data;
|
2011-01-10 16:15:36 -07:00
|
|
|
struct xfs_buftarg *target = XFS_IS_REALTIME_INODE(ip) ?
|
|
|
|
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-21 15:46:23 -07:00
|
|
|
/* DIO must be aligned to device logical sector size */
|
2016-07-19 19:38:55 -06:00
|
|
|
if ((iocb->ki_pos | count) & target->bt_logical_sectormask)
|
2014-06-21 23:04:54 -06:00
|
|
|
return -EINVAL;
|
2011-01-10 16: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 01:17:02 -06:00
|
|
|
/*
|
2016-10-19 22:44:14 -06: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 01:17:02 -06:00
|
|
|
*/
|
2016-10-19 22:44:14 -06:00
|
|
|
if ((iocb->ki_pos & mp->m_blockmask) ||
|
|
|
|
((iocb->ki_pos + count) & mp->m_blockmask)) {
|
|
|
|
unaligned_io = 1;
|
2017-02-06 14: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.
|
|
|
|
*/
|
|
|
|
if (xfs_is_reflink_inode(ip)) {
|
|
|
|
trace_xfs_reflink_bounce_dio_write(ip, iocb->ki_pos, count);
|
|
|
|
return -EREMCHG;
|
|
|
|
}
|
2011-12-18 13:00:14 -07:00
|
|
|
iolock = XFS_IOLOCK_EXCL;
|
2016-10-19 22:44:14 -06:00
|
|
|
} else {
|
2011-12-18 13:00:14 -07:00
|
|
|
iolock = XFS_IOLOCK_SHARED;
|
2011-08-27 08:42:53 -06:00
|
|
|
}
|
2011-01-10 16:15:36 -07:00
|
|
|
|
2016-10-19 22:44:14 -06:00
|
|
|
xfs_rw_ilock(ip, iolock);
|
|
|
|
|
2015-04-07 12:25:18 -06:00
|
|
|
ret = xfs_file_aio_write_checks(iocb, from, &iolock);
|
2011-01-10 16:23:42 -07:00
|
|
|
if (ret)
|
2011-12-18 13:00:14 -07:00
|
|
|
goto out;
|
2015-04-07 12:25:18 -06:00
|
|
|
count = iov_iter_count(from);
|
2016-04-07 09:51:57 -06:00
|
|
|
end = iocb->ki_pos + count - 1;
|
2011-01-10 16:15:36 -07:00
|
|
|
|
|
|
|
if (mapping->nrpages) {
|
2016-10-19 22:44:14 -06:00
|
|
|
ret = filemap_write_and_wait_range(mapping, iocb->ki_pos, end);
|
2011-01-10 16:15:36 -07:00
|
|
|
if (ret)
|
2011-12-18 13:00:14 -07:00
|
|
|
goto out;
|
2016-10-19 22:44:14 -06:00
|
|
|
|
2014-09-01 20:12:52 -06:00
|
|
|
/*
|
2015-08-18 18:35:04 -06:00
|
|
|
* Invalidate whole pages. This can return an error if we fail
|
|
|
|
* to invalidate a page, but this should never happen on XFS.
|
|
|
|
* Warn if it does fail.
|
2014-09-01 20:12:52 -06:00
|
|
|
*/
|
2016-10-19 22:44:14 -06:00
|
|
|
ret = invalidate_inode_pages2_range(mapping,
|
|
|
|
iocb->ki_pos >> PAGE_SHIFT, end >> PAGE_SHIFT);
|
2014-09-01 20:12:52 -06:00
|
|
|
WARN_ON_ONCE(ret);
|
|
|
|
ret = 0;
|
2011-01-10 16:15:36 -07:00
|
|
|
}
|
|
|
|
|
2011-01-10 16:22:40 -07:00
|
|
|
/*
|
|
|
|
* If we are doing unaligned IO, wait for all other IO to drain,
|
2016-10-19 22:44:14 -06:00
|
|
|
* otherwise demote the lock if we had to take the exclusive lock
|
|
|
|
* for other reasons in xfs_file_aio_write_checks.
|
2011-01-10 16:22:40 -07:00
|
|
|
*/
|
|
|
|
if (unaligned_io)
|
2011-08-23 02:28:13 -06:00
|
|
|
inode_dio_wait(inode);
|
2011-12-18 13:00:14 -07:00
|
|
|
else if (iolock == XFS_IOLOCK_EXCL) {
|
2011-01-10 16:15:36 -07:00
|
|
|
xfs_rw_ilock_demote(ip, XFS_IOLOCK_EXCL);
|
2011-12-18 13:00:14 -07:00
|
|
|
iolock = XFS_IOLOCK_SHARED;
|
2011-01-10 16:15:36 -07:00
|
|
|
}
|
|
|
|
|
2016-07-19 19:31:42 -06:00
|
|
|
trace_xfs_file_direct_write(ip, count, iocb->ki_pos);
|
2011-01-10 16:15:36 -07:00
|
|
|
|
2016-10-03 10:11:37 -06:00
|
|
|
/* If this is a block-aligned directio CoW, remap immediately. */
|
|
|
|
if (xfs_is_reflink_inode(ip) && !unaligned_io) {
|
|
|
|
ret = xfs_reflink_allocate_cow_range(ip, iocb->ki_pos, count);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-04-16 06:03:27 -06:00
|
|
|
data = *from;
|
2016-07-19 19:38:55 -06:00
|
|
|
ret = __blockdev_direct_IO(iocb, inode, target->bt_bdev, &data,
|
|
|
|
xfs_get_blocks_direct, xfs_end_io_direct_write,
|
|
|
|
NULL, DIO_ASYNC_EXTEND);
|
2015-04-16 06:03:27 -06:00
|
|
|
|
|
|
|
/* see generic_file_direct_write() for why this is necessary */
|
|
|
|
if (mapping->nrpages) {
|
|
|
|
invalidate_inode_pages2_range(mapping,
|
2016-04-07 09:51:57 -06:00
|
|
|
iocb->ki_pos >> PAGE_SHIFT,
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 06:29:47 -06:00
|
|
|
end >> PAGE_SHIFT);
|
2015-04-16 06:03:27 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret > 0) {
|
2016-04-07 09:51:57 -06:00
|
|
|
iocb->ki_pos += ret;
|
2015-04-16 06:03:27 -06:00
|
|
|
iov_iter_advance(from, ret);
|
|
|
|
}
|
2011-12-18 13:00:14 -07:00
|
|
|
out:
|
|
|
|
xfs_rw_iunlock(ip, iolock);
|
|
|
|
|
2015-06-03 17:18:53 -06:00
|
|
|
/*
|
2016-07-19 19:38:55 -06:00
|
|
|
* No fallback to buffered IO on errors for XFS, direct IO will either
|
|
|
|
* complete fully or fail.
|
2015-06-03 17:18:53 -06:00
|
|
|
*/
|
2016-07-19 19:38:55 -06:00
|
|
|
ASSERT(ret < 0 || ret == count);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-07-21 17:50:55 -06:00
|
|
|
static noinline ssize_t
|
2016-07-19 19:38:55 -06:00
|
|
|
xfs_file_dax_write(
|
|
|
|
struct kiocb *iocb,
|
|
|
|
struct iov_iter *from)
|
|
|
|
{
|
2016-09-18 19:28:38 -06:00
|
|
|
struct inode *inode = iocb->ki_filp->f_mapping->host;
|
2016-07-19 19:38:55 -06:00
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
2016-09-18 19:24:50 -06:00
|
|
|
int iolock = XFS_IOLOCK_EXCL;
|
2016-09-18 19:28:38 -06:00
|
|
|
ssize_t ret, error = 0;
|
|
|
|
size_t count;
|
|
|
|
loff_t pos;
|
2016-07-19 19:38:55 -06:00
|
|
|
|
|
|
|
xfs_rw_ilock(ip, iolock);
|
|
|
|
ret = xfs_file_aio_write_checks(iocb, from, &iolock);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2016-09-18 19:28:38 -06:00
|
|
|
pos = iocb->ki_pos;
|
|
|
|
count = iov_iter_count(from);
|
2016-08-16 16:31:33 -06:00
|
|
|
|
2016-09-18 19:28:38 -06:00
|
|
|
trace_xfs_file_dax_write(ip, count, pos);
|
2016-07-19 19:38:55 -06:00
|
|
|
|
2016-09-18 19:28:38 -06:00
|
|
|
ret = iomap_dax_rw(iocb, from, &xfs_iomap_ops);
|
|
|
|
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-19 19:38:55 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
xfs_rw_iunlock(ip, iolock);
|
2016-09-18 19:28:38 -06:00
|
|
|
return error ? error : ret;
|
2011-01-10 16:15:36 -07:00
|
|
|
}
|
|
|
|
|
2010-02-15 02:44:47 -07:00
|
|
|
STATIC ssize_t
|
2011-01-10 16:17:30 -07:00
|
|
|
xfs_file_buffered_aio_write(
|
2010-02-15 02:44:46 -07:00
|
|
|
struct kiocb *iocb,
|
2014-04-02 05:06:30 -06:00
|
|
|
struct iov_iter *from)
|
2010-02-15 02: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 02:44:47 -07:00
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
2011-01-10 16:17:30 -07:00
|
|
|
ssize_t ret;
|
|
|
|
int enospc = 0;
|
2017-01-28 00:22:56 -07:00
|
|
|
int iolock;
|
2010-02-15 02:44:46 -07:00
|
|
|
|
2017-01-28 00:22:56 -07:00
|
|
|
write_retry:
|
|
|
|
iolock = XFS_IOLOCK_EXCL;
|
2011-12-18 13:00:14 -07:00
|
|
|
xfs_rw_ilock(ip, iolock);
|
2010-02-15 02:44:46 -07:00
|
|
|
|
2015-04-07 12:25:18 -06:00
|
|
|
ret = xfs_file_aio_write_checks(iocb, from, &iolock);
|
2011-01-10 16:23:42 -07:00
|
|
|
if (ret)
|
2011-12-18 13:00:14 -07:00
|
|
|
goto out;
|
2010-02-15 02:44:46 -07:00
|
|
|
|
|
|
|
/* We can write back this queue in page reclaim */
|
2015-01-14 02:42:36 -07:00
|
|
|
current->backing_dev_info = inode_to_bdi(inode);
|
2010-02-15 02:44:46 -07:00
|
|
|
|
2016-07-19 19:31:42 -06:00
|
|
|
trace_xfs_file_buffered_write(ip, iov_iter_count(from), iocb->ki_pos);
|
2016-06-20 17:53:44 -06:00
|
|
|
ret = iomap_file_buffered_write(iocb, from, &xfs_iomap_ops);
|
2014-02-11 20:25:22 -07:00
|
|
|
if (likely(ret >= 0))
|
2015-04-07 12:25:18 -06:00
|
|
|
iocb->ki_pos += ret;
|
2014-07-24 03:49:28 -06:00
|
|
|
|
2011-01-10 16:17:30 -07:00
|
|
|
/*
|
2014-07-24 03:49:28 -06: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-10 16:17:30 -07:00
|
|
|
*/
|
2014-07-24 03:49:28 -06:00
|
|
|
if (ret == -EDQUOT && !enospc) {
|
2017-01-28 00:22:56 -07:00
|
|
|
xfs_rw_iunlock(ip, iolock);
|
2014-07-24 03:49:28 -06:00
|
|
|
enospc = xfs_inode_free_quota_eofblocks(ip);
|
|
|
|
if (enospc)
|
|
|
|
goto write_retry;
|
2016-10-03 10:11:46 -06:00
|
|
|
enospc = xfs_inode_free_quota_cowblocks(ip);
|
|
|
|
if (enospc)
|
|
|
|
goto write_retry;
|
2017-01-28 00:22:56 -07:00
|
|
|
iolock = 0;
|
2014-07-24 03:49:28 -06:00
|
|
|
} else if (ret == -ENOSPC && !enospc) {
|
|
|
|
struct xfs_eofblocks eofb = {0};
|
|
|
|
|
2011-01-10 16:17:30 -07:00
|
|
|
enospc = 1;
|
2012-10-08 04:56:04 -06:00
|
|
|
xfs_flush_inodes(ip->i_mount);
|
2017-01-28 00:22:56 -07:00
|
|
|
|
|
|
|
xfs_rw_iunlock(ip, iolock);
|
2014-07-24 03:49:28 -06:00
|
|
|
eofb.eof_flags = XFS_EOF_FLAGS_SYNC;
|
|
|
|
xfs_icache_free_eofblocks(ip->i_mount, &eofb);
|
2012-10-08 04:56:04 -06:00
|
|
|
goto write_retry;
|
2010-02-15 02:44:46 -07:00
|
|
|
}
|
2011-12-18 13:00:14 -07:00
|
|
|
|
2010-02-15 02:44:46 -07:00
|
|
|
current->backing_dev_info = NULL;
|
2011-12-18 13:00:14 -07:00
|
|
|
out:
|
2017-01-28 00:22:56 -07:00
|
|
|
if (iolock)
|
|
|
|
xfs_rw_iunlock(ip, iolock);
|
2011-01-10 16:17:30 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC ssize_t
|
2014-04-03 12:20:23 -06:00
|
|
|
xfs_file_write_iter(
|
2011-01-10 16:17:30 -07:00
|
|
|
struct kiocb *iocb,
|
2014-04-03 12:20:23 -06:00
|
|
|
struct iov_iter *from)
|
2011-01-10 16: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-03 12:20:23 -06:00
|
|
|
size_t ocount = iov_iter_count(from);
|
2011-01-10 16:17:30 -07:00
|
|
|
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(ip->i_mount, xs_write_calls);
|
2011-01-10 16:17:30 -07:00
|
|
|
|
|
|
|
if (ocount == 0)
|
|
|
|
return 0;
|
|
|
|
|
2014-04-03 12:20:23 -06:00
|
|
|
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
|
|
|
|
return -EIO;
|
2011-01-10 16:17:30 -07:00
|
|
|
|
2016-07-19 19:38:55 -06:00
|
|
|
if (IS_DAX(inode))
|
|
|
|
ret = xfs_file_dax_write(iocb, from);
|
2016-10-03 10:11:37 -06:00
|
|
|
else if (iocb->ki_flags & IOCB_DIRECT) {
|
|
|
|
/*
|
|
|
|
* 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-03 12:20:23 -06:00
|
|
|
ret = xfs_file_dio_aio_write(iocb, from);
|
2016-10-03 10:11:37 -06:00
|
|
|
if (ret == -EREMCHG)
|
|
|
|
goto buffered;
|
|
|
|
} else {
|
|
|
|
buffered:
|
2014-04-03 12:20:23 -06:00
|
|
|
ret = xfs_file_buffered_aio_write(iocb, from);
|
2016-10-03 10:11:37 -06:00
|
|
|
}
|
2010-02-15 02:44:46 -07:00
|
|
|
|
2011-12-18 13:00:14 -07:00
|
|
|
if (ret > 0) {
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_ADD(ip->i_mount, xs_write_bytes, ret);
|
2010-02-15 02:44:46 -07:00
|
|
|
|
2011-12-18 13:00:14 -07:00
|
|
|
/* Handle various SYNC-type writes */
|
2016-04-07 09:52:01 -06:00
|
|
|
ret = generic_write_sync(iocb, ret);
|
2010-02-15 02:44:46 -07:00
|
|
|
}
|
2011-01-10 16:13:53 -07:00
|
|
|
return ret;
|
2010-02-15 02:44:46 -07:00
|
|
|
}
|
|
|
|
|
2015-03-24 22:08:56 -06: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 10:11:43 -06:00
|
|
|
FALLOC_FL_INSERT_RANGE | FALLOC_FL_UNSHARE_RANGE)
|
2015-03-24 22:08:56 -06:00
|
|
|
|
2011-01-14 05:07:43 -07:00
|
|
|
STATIC long
|
|
|
|
xfs_file_fallocate(
|
2013-10-12 01:55:07 -06:00
|
|
|
struct file *file,
|
|
|
|
int mode,
|
|
|
|
loff_t offset,
|
|
|
|
loff_t len)
|
2011-01-14 05:07:43 -07:00
|
|
|
{
|
2013-10-12 01:55:07 -06:00
|
|
|
struct inode *inode = file_inode(file);
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
long error;
|
2015-02-01 15:53:56 -07:00
|
|
|
enum xfs_prealloc_flags flags = 0;
|
2015-02-15 17:59:50 -07:00
|
|
|
uint iolock = XFS_IOLOCK_EXCL;
|
2013-10-12 01:55:07 -06:00
|
|
|
loff_t new_size = 0;
|
2015-03-24 22:08:56 -06:00
|
|
|
bool do_file_insert = 0;
|
2011-01-14 05:07:43 -07:00
|
|
|
|
2013-10-12 01:55:07 -06:00
|
|
|
if (!S_ISREG(inode->i_mode))
|
|
|
|
return -EINVAL;
|
2015-03-24 22:08:56 -06:00
|
|
|
if (mode & ~XFS_FALLOC_FL_SUPPORTED)
|
2011-01-14 05:07:43 -07:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2015-02-15 17:59:50 -07:00
|
|
|
xfs_ilock(ip, iolock);
|
2015-04-12 19:38:29 -06:00
|
|
|
error = xfs_break_layouts(inode, &iolock, false);
|
2015-02-15 17:59:50 -07:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2015-02-23 03:45:32 -07:00
|
|
|
xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
|
|
|
|
iolock |= XFS_MMAPLOCK_EXCL;
|
|
|
|
|
2013-10-12 01:55:07 -06:00
|
|
|
if (mode & FALLOC_FL_PUNCH_HOLE) {
|
|
|
|
error = xfs_free_file_space(ip, offset, len);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2014-02-23 16:58:19 -07:00
|
|
|
} else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
|
2017-02-27 15:28:32 -07:00
|
|
|
unsigned int blksize_mask = i_blocksize(inode) - 1;
|
2014-02-23 16:58:19 -07:00
|
|
|
|
|
|
|
if (offset & blksize_mask || len & blksize_mask) {
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EINVAL;
|
2014-02-23 16:58:19 -07:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2014-04-12 07:56:41 -06: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-24 22:58:08 -06:00
|
|
|
error = -EINVAL;
|
2014-04-12 07:56:41 -06:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2014-02-23 16: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-24 22:08:56 -06:00
|
|
|
} else if (mode & FALLOC_FL_INSERT_RANGE) {
|
2017-02-27 15:28:32 -07:00
|
|
|
unsigned int blksize_mask = i_blocksize(inode) - 1;
|
2015-03-24 22:08:56 -06:00
|
|
|
|
|
|
|
new_size = i_size_read(inode) + len;
|
|
|
|
if (offset & blksize_mask || len & blksize_mask) {
|
|
|
|
error = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check the new inode size does not wrap through zero */
|
|
|
|
if (new_size > inode->i_sb->s_maxbytes) {
|
|
|
|
error = -EFBIG;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Offset should be less than i_size */
|
|
|
|
if (offset >= i_size_read(inode)) {
|
|
|
|
error = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
do_file_insert = 1;
|
2013-10-12 01:55:07 -06:00
|
|
|
} else {
|
2015-02-01 15:53:56 -07:00
|
|
|
flags |= XFS_PREALLOC_SET;
|
|
|
|
|
2013-10-12 01:55:07 -06:00
|
|
|
if (!(mode & FALLOC_FL_KEEP_SIZE) &&
|
|
|
|
offset + len > i_size_read(inode)) {
|
|
|
|
new_size = offset + len;
|
2014-06-24 22:58:08 -06:00
|
|
|
error = inode_newsize_ok(inode, new_size);
|
2013-10-12 01:55:07 -06:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2011-01-14 05:07:43 -07:00
|
|
|
|
2014-03-13 02:07:58 -06:00
|
|
|
if (mode & FALLOC_FL_ZERO_RANGE)
|
|
|
|
error = xfs_zero_file_space(ip, offset, len);
|
2016-10-03 10:11:43 -06:00
|
|
|
else {
|
|
|
|
if (mode & FALLOC_FL_UNSHARE_RANGE) {
|
|
|
|
error = xfs_reflink_unshare(ip, offset, len);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2014-03-13 02:07:58 -06:00
|
|
|
error = xfs_alloc_file_space(ip, offset, len,
|
|
|
|
XFS_BMAPI_PREALLOC);
|
2016-10-03 10:11:43 -06:00
|
|
|
}
|
2011-01-14 05:07:43 -07:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2013-10-12 01:55:07 -06:00
|
|
|
if (file->f_flags & O_DSYNC)
|
2015-02-01 15:53:56 -07:00
|
|
|
flags |= XFS_PREALLOC_SYNC;
|
|
|
|
|
|
|
|
error = xfs_update_prealloc_flags(ip, flags);
|
2011-01-14 05: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 06:46:43 -06:00
|
|
|
error = xfs_vn_setattr_size(file_dentry(file), &iattr);
|
2015-03-24 22:08:56 -06:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2011-01-14 05:07:43 -07:00
|
|
|
}
|
|
|
|
|
2015-03-24 22:08:56 -06: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 05:07:43 -07:00
|
|
|
out_unlock:
|
2015-02-15 17:59:50 -07:00
|
|
|
xfs_iunlock(ip, iolock);
|
2014-06-24 22:58:08 -06:00
|
|
|
return error;
|
2011-01-14 05:07:43 -07:00
|
|
|
}
|
|
|
|
|
2016-10-03 10:11:40 -06:00
|
|
|
STATIC ssize_t
|
|
|
|
xfs_file_copy_range(
|
|
|
|
struct file *file_in,
|
|
|
|
loff_t pos_in,
|
|
|
|
struct file *file_out,
|
|
|
|
loff_t pos_out,
|
|
|
|
size_t len,
|
|
|
|
unsigned int flags)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2016-10-19 22:50:07 -06:00
|
|
|
error = xfs_reflink_remap_range(file_in, pos_in, file_out, pos_out,
|
2016-10-03 10:11:41 -06:00
|
|
|
len, false);
|
2016-10-03 10:11:40 -06:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC int
|
|
|
|
xfs_file_clone_range(
|
|
|
|
struct file *file_in,
|
|
|
|
loff_t pos_in,
|
|
|
|
struct file *file_out,
|
|
|
|
loff_t pos_out,
|
|
|
|
u64 len)
|
|
|
|
{
|
2016-10-19 22:50:07 -06:00
|
|
|
return xfs_reflink_remap_range(file_in, pos_in, file_out, pos_out,
|
2016-10-03 10:11:41 -06:00
|
|
|
len, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC ssize_t
|
|
|
|
xfs_file_dedupe_range(
|
|
|
|
struct file *src_file,
|
|
|
|
u64 loff,
|
|
|
|
u64 len,
|
|
|
|
struct file *dst_file,
|
|
|
|
u64 dst_loff)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2016-10-19 22:50:07 -06:00
|
|
|
error = xfs_reflink_remap_range(src_file, loff, dst_file, dst_loff,
|
2016-10-03 10:11:41 -06:00
|
|
|
len, true);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
return len;
|
2016-10-03 10:11:40 -06:00
|
|
|
}
|
2011-01-14 05:07:43 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
STATIC int
|
2006-03-13 20:00:35 -07:00
|
|
|
xfs_file_open(
|
2005-04-16 16:20:36 -06:00
|
|
|
struct inode *inode,
|
2008-11-27 20:23:32 -07:00
|
|
|
struct file *file)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-11-27 20:23:32 -07:00
|
|
|
if (!(file->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFBIG;
|
2008-11-27 20:23:32 -07:00
|
|
|
if (XFS_FORCED_SHUTDOWN(XFS_M(inode->i_sb)))
|
|
|
|
return -EIO;
|
|
|
|
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-06 13:30:09 -07:00
|
|
|
mode = xfs_ilock_data_map_shared(ip);
|
2008-11-27 20:23:32 -07:00
|
|
|
if (ip->i_d.di_nextents > 0)
|
2017-02-02 16:13:58 -07:00
|
|
|
error = xfs_dir3_data_readahead(ip, 0, -1);
|
2008-11-27 20:23:32 -07:00
|
|
|
xfs_iunlock(ip, mode);
|
2017-02-02 16:13:58 -07:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
STATIC int
|
2006-03-13 20:00:35 -07:00
|
|
|
xfs_file_release(
|
2005-04-16 16:20:36 -06:00
|
|
|
struct inode *inode,
|
|
|
|
struct file *filp)
|
|
|
|
{
|
2014-06-24 22:58:08 -06:00
|
|
|
return xfs_release(XFS_I(inode));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
STATIC int
|
2006-03-13 20:00:35 -07:00
|
|
|
xfs_file_readdir(
|
2013-05-22 15:07:56 -06:00
|
|
|
struct file *file,
|
|
|
|
struct dir_context *ctx)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-05-22 15:07:56 -06:00
|
|
|
struct inode *inode = file_inode(file);
|
2007-08-28 18:58:01 -06:00
|
|
|
xfs_inode_t *ip = XFS_I(inode);
|
2007-08-27 21:58:24 -06: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-03 10:50:13 -07:00
|
|
|
* buffer size. For now we use the current glibc buffer size.
|
2007-08-27 21:58:24 -06:00
|
|
|
*/
|
2010-02-03 10:50:13 -07:00
|
|
|
bufsize = (size_t)min_t(loff_t, 32768, ip->i_d.di_size);
|
2007-08-27 21:58:24 -06:00
|
|
|
|
2014-11-30 14:25:28 -07:00
|
|
|
return xfs_readdir(ip, ctx, bufsize);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-08-21 03:11:57 -06:00
|
|
|
/*
|
|
|
|
* This type is designed to indicate the type of offset we would like
|
2014-09-08 19:56:48 -06:00
|
|
|
* to search from page cache for xfs_seek_hole_data().
|
2012-08-21 03:11:57 -06:00
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
HOLE_OFF = 0,
|
|
|
|
DATA_OFF,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lookup the desired type of offset from the given page.
|
|
|
|
*
|
|
|
|
* On success, return true and the offset argument will point to the
|
|
|
|
* start of the region that was found. Otherwise this function will
|
|
|
|
* return false and keep the offset argument unchanged.
|
|
|
|
*/
|
|
|
|
STATIC bool
|
|
|
|
xfs_lookup_buffer_offset(
|
|
|
|
struct page *page,
|
|
|
|
loff_t *offset,
|
|
|
|
unsigned int type)
|
|
|
|
{
|
|
|
|
loff_t lastoff = page_offset(page);
|
|
|
|
bool found = false;
|
|
|
|
struct buffer_head *bh, *head;
|
|
|
|
|
|
|
|
bh = head = page_buffers(page);
|
|
|
|
do {
|
|
|
|
/*
|
|
|
|
* Unwritten extents that have data in the page
|
|
|
|
* cache covering them can be identified by the
|
|
|
|
* BH_Unwritten state flag. Pages with multiple
|
|
|
|
* buffers might have a mix of holes, data and
|
|
|
|
* unwritten extents - any buffer with valid
|
|
|
|
* data in it should have BH_Uptodate flag set
|
|
|
|
* on it.
|
|
|
|
*/
|
|
|
|
if (buffer_unwritten(bh) ||
|
|
|
|
buffer_uptodate(bh)) {
|
|
|
|
if (type == DATA_OFF)
|
|
|
|
found = true;
|
|
|
|
} else {
|
|
|
|
if (type == HOLE_OFF)
|
|
|
|
found = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (found) {
|
|
|
|
*offset = lastoff;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
lastoff += bh->b_size;
|
|
|
|
} while ((bh = bh->b_this_page) != head);
|
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called to find out and return a data or hole offset
|
|
|
|
* from the page cache for unwritten extents according to the desired
|
2014-09-08 19:56:48 -06:00
|
|
|
* type for xfs_seek_hole_data().
|
2012-08-21 03:11:57 -06:00
|
|
|
*
|
|
|
|
* The argument offset is used to tell where we start to search from the
|
|
|
|
* page cache. Map is used to figure out the end points of the range to
|
|
|
|
* lookup pages.
|
|
|
|
*
|
|
|
|
* Return true if the desired type of offset was found, and the argument
|
|
|
|
* offset is filled with that address. Otherwise, return false and keep
|
|
|
|
* offset unchanged.
|
|
|
|
*/
|
|
|
|
STATIC bool
|
|
|
|
xfs_find_get_desired_pgoff(
|
|
|
|
struct inode *inode,
|
|
|
|
struct xfs_bmbt_irec *map,
|
|
|
|
unsigned int type,
|
|
|
|
loff_t *offset)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct pagevec pvec;
|
|
|
|
pgoff_t index;
|
|
|
|
pgoff_t end;
|
|
|
|
loff_t endoff;
|
|
|
|
loff_t startoff = *offset;
|
|
|
|
loff_t lastoff = startoff;
|
|
|
|
bool found = false;
|
|
|
|
|
|
|
|
pagevec_init(&pvec, 0);
|
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 06:29:47 -06:00
|
|
|
index = startoff >> PAGE_SHIFT;
|
2012-08-21 03:11:57 -06:00
|
|
|
endoff = XFS_FSB_TO_B(mp, map->br_startoff + map->br_blockcount);
|
2017-05-18 17:36:23 -06:00
|
|
|
end = (endoff - 1) >> PAGE_SHIFT;
|
2012-08-21 03:11:57 -06:00
|
|
|
do {
|
|
|
|
int want;
|
|
|
|
unsigned nr_pages;
|
|
|
|
unsigned int i;
|
|
|
|
|
2017-05-23 09:30:46 -06:00
|
|
|
want = min_t(pgoff_t, end - index, PAGEVEC_SIZE - 1) + 1;
|
2012-08-21 03:11:57 -06:00
|
|
|
nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
|
|
|
|
want);
|
|
|
|
/*
|
|
|
|
* No page mapped into given range. If we are searching holes
|
|
|
|
* and if this is the first time we got into the loop, it means
|
|
|
|
* that the given offset is landed in a hole, return it.
|
|
|
|
*
|
|
|
|
* If we have already stepped through some block buffers to find
|
|
|
|
* holes but they all contains data. In this case, the last
|
|
|
|
* offset is already updated and pointed to the end of the last
|
|
|
|
* mapped page, if it does not reach the endpoint to search,
|
|
|
|
* that means there should be a hole between them.
|
|
|
|
*/
|
|
|
|
if (nr_pages == 0) {
|
|
|
|
/* Data search found nothing */
|
|
|
|
if (type == DATA_OFF)
|
|
|
|
break;
|
|
|
|
|
|
|
|
ASSERT(type == HOLE_OFF);
|
|
|
|
if (lastoff == startoff || lastoff < endoff) {
|
|
|
|
found = true;
|
|
|
|
*offset = lastoff;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < nr_pages; i++) {
|
|
|
|
struct page *page = pvec.pages[i];
|
|
|
|
loff_t b_offset;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* At this point, the page may be truncated or
|
|
|
|
* invalidated (changing page->mapping to NULL),
|
|
|
|
* or even swizzled back from swapper_space to tmpfs
|
|
|
|
* file mapping. However, page->index will not change
|
|
|
|
* because we have a reference on the page.
|
|
|
|
*
|
2017-05-18 17:36:22 -06:00
|
|
|
* If current page offset is beyond where we've ended,
|
|
|
|
* we've found a hole.
|
2012-08-21 03:11:57 -06:00
|
|
|
*/
|
2017-05-18 17:36:22 -06:00
|
|
|
if (type == HOLE_OFF && lastoff < endoff &&
|
|
|
|
lastoff < page_offset(pvec.pages[i])) {
|
|
|
|
found = true;
|
|
|
|
*offset = lastoff;
|
2012-08-21 03:11:57 -06:00
|
|
|
goto out;
|
|
|
|
}
|
2017-05-18 17:36:22 -06:00
|
|
|
/* Searching done if the page index is out of range. */
|
|
|
|
if (page->index > end)
|
|
|
|
goto out;
|
2012-08-21 03:11:57 -06:00
|
|
|
|
|
|
|
lock_page(page);
|
|
|
|
/*
|
|
|
|
* Page truncated or invalidated(page->mapping == NULL).
|
|
|
|
* We can freely skip it and proceed to check the next
|
|
|
|
* page.
|
|
|
|
*/
|
|
|
|
if (unlikely(page->mapping != inode->i_mapping)) {
|
|
|
|
unlock_page(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!page_has_buffers(page)) {
|
|
|
|
unlock_page(page);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
found = xfs_lookup_buffer_offset(page, &b_offset, type);
|
|
|
|
if (found) {
|
|
|
|
/*
|
|
|
|
* The found offset may be less than the start
|
|
|
|
* point to search if this is the first time to
|
|
|
|
* come here.
|
|
|
|
*/
|
|
|
|
*offset = max_t(loff_t, startoff, b_offset);
|
|
|
|
unlock_page(page);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We either searching data but nothing was found, or
|
|
|
|
* searching hole but found a data buffer. In either
|
|
|
|
* case, probably the next page contains the desired
|
|
|
|
* things, update the last offset to it so.
|
|
|
|
*/
|
|
|
|
lastoff = page_offset(page) + PAGE_SIZE;
|
|
|
|
unlock_page(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The number of returned pages less than our desired, search
|
|
|
|
* done. In this case, nothing was found for searching data,
|
|
|
|
* but we found a hole behind the last offset.
|
|
|
|
*/
|
|
|
|
if (nr_pages < want) {
|
|
|
|
if (type == HOLE_OFF) {
|
|
|
|
*offset = lastoff;
|
|
|
|
found = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = pvec.pages[i - 1]->index + 1;
|
|
|
|
pagevec_release(&pvec);
|
|
|
|
} while (index <= end);
|
|
|
|
|
|
|
|
out:
|
|
|
|
pagevec_release(&pvec);
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2016-02-07 17:25:16 -07:00
|
|
|
/*
|
|
|
|
* caller must lock inode with xfs_ilock_data_map_shared,
|
|
|
|
* can we craft an appropriate ASSERT?
|
|
|
|
*
|
|
|
|
* end is because the VFS-level lseek interface is defined such that any
|
|
|
|
* offset past i_size shall return -ENXIO, but we use this for quota code
|
|
|
|
* which does not maintain i_size, and we want to SEEK_DATA past i_size.
|
|
|
|
*/
|
|
|
|
loff_t
|
|
|
|
__xfs_seek_hole_data(
|
|
|
|
struct inode *inode,
|
2014-09-08 19:56:48 -06:00
|
|
|
loff_t start,
|
2016-02-07 17:25:16 -07:00
|
|
|
loff_t end,
|
2014-09-08 19:56:48 -06:00
|
|
|
int whence)
|
2012-05-10 07:29:17 -06:00
|
|
|
{
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
loff_t uninitialized_var(offset);
|
|
|
|
xfs_fileoff_t fsbno;
|
2016-02-07 17:25:16 -07:00
|
|
|
xfs_filblks_t lastbno;
|
2012-05-10 07:29:17 -06:00
|
|
|
int error;
|
|
|
|
|
2016-02-07 17:25:16 -07:00
|
|
|
if (start >= end) {
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -ENXIO;
|
2016-02-07 17:25:16 -07:00
|
|
|
goto out_error;
|
2012-05-10 07:29:17 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to read extents from the first block indicated
|
|
|
|
* by fsbno to the end block of the file.
|
|
|
|
*/
|
2012-08-21 03:12:07 -06:00
|
|
|
fsbno = XFS_B_TO_FSBT(mp, start);
|
2016-02-07 17:25:16 -07:00
|
|
|
lastbno = XFS_B_TO_FSB(mp, end);
|
2014-09-08 19:56:48 -06:00
|
|
|
|
2012-08-21 03:12:07 -06:00
|
|
|
for (;;) {
|
|
|
|
struct xfs_bmbt_irec map[2];
|
|
|
|
int nmap = 2;
|
|
|
|
unsigned int i;
|
2012-05-10 07:29:17 -06:00
|
|
|
|
2016-02-07 17:25:16 -07:00
|
|
|
error = xfs_bmapi_read(ip, fsbno, lastbno - fsbno, map, &nmap,
|
2012-08-21 03:12:07 -06:00
|
|
|
XFS_BMAPI_ENTIRE);
|
|
|
|
if (error)
|
2016-02-07 17:25:16 -07:00
|
|
|
goto out_error;
|
2012-05-10 07:29:17 -06:00
|
|
|
|
2012-08-21 03:12:07 -06:00
|
|
|
/* No extents at given offset, must be beyond EOF */
|
|
|
|
if (nmap == 0) {
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -ENXIO;
|
2016-02-07 17:25:16 -07:00
|
|
|
goto out_error;
|
2012-08-21 03:12:07 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < nmap; i++) {
|
|
|
|
offset = max_t(loff_t, start,
|
|
|
|
XFS_FSB_TO_B(mp, map[i].br_startoff));
|
|
|
|
|
2014-09-08 19:56:48 -06:00
|
|
|
/* Landed in the hole we wanted? */
|
|
|
|
if (whence == SEEK_HOLE &&
|
|
|
|
map[i].br_startblock == HOLESTARTBLOCK)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Landed in the data extent we wanted? */
|
|
|
|
if (whence == SEEK_DATA &&
|
|
|
|
(map[i].br_startblock == DELAYSTARTBLOCK ||
|
|
|
|
(map[i].br_state == XFS_EXT_NORM &&
|
|
|
|
!isnullstartblock(map[i].br_startblock))))
|
2012-08-21 03:12:07 -06:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
2014-09-08 19:56:48 -06:00
|
|
|
* Landed in an unwritten extent, try to search
|
|
|
|
* for hole or data from page cache.
|
2012-08-21 03:12:07 -06:00
|
|
|
*/
|
|
|
|
if (map[i].br_state == XFS_EXT_UNWRITTEN) {
|
|
|
|
if (xfs_find_get_desired_pgoff(inode, &map[i],
|
2014-09-08 19:56:48 -06:00
|
|
|
whence == SEEK_HOLE ? HOLE_OFF : DATA_OFF,
|
|
|
|
&offset))
|
2012-08-21 03:12:07 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-09-08 19:56:48 -06:00
|
|
|
* We only received one extent out of the two requested. This
|
|
|
|
* means we've hit EOF and didn't find what we are looking for.
|
2012-08-21 03:12:07 -06:00
|
|
|
*/
|
2012-05-10 07:29:17 -06:00
|
|
|
if (nmap == 1) {
|
2014-09-08 19:56:48 -06:00
|
|
|
/*
|
|
|
|
* If we were looking for a hole, set offset to
|
|
|
|
* the end of the file (i.e., there is an implicit
|
|
|
|
* hole at the end of any file).
|
|
|
|
*/
|
|
|
|
if (whence == SEEK_HOLE) {
|
2016-02-07 17:25:16 -07:00
|
|
|
offset = end;
|
2014-09-08 19:56:48 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If we were looking for data, it's nowhere to be found
|
|
|
|
*/
|
|
|
|
ASSERT(whence == SEEK_DATA);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -ENXIO;
|
2016-02-07 17:25:16 -07:00
|
|
|
goto out_error;
|
2012-05-10 07:29:17 -06:00
|
|
|
}
|
|
|
|
|
2012-08-21 03:12:07 -06:00
|
|
|
ASSERT(i > 1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Nothing was found, proceed to the next round of search
|
2014-09-08 19:56:48 -06:00
|
|
|
* if the next reading offset is not at or beyond EOF.
|
2012-08-21 03:12:07 -06:00
|
|
|
*/
|
|
|
|
fsbno = map[i - 1].br_startoff + map[i - 1].br_blockcount;
|
|
|
|
start = XFS_FSB_TO_B(mp, fsbno);
|
2016-02-07 17:25:16 -07:00
|
|
|
if (start >= end) {
|
2014-09-08 19:56:48 -06:00
|
|
|
if (whence == SEEK_HOLE) {
|
2016-02-07 17:25:16 -07:00
|
|
|
offset = end;
|
2014-09-08 19:56:48 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
ASSERT(whence == SEEK_DATA);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -ENXIO;
|
2016-02-07 17:25:16 -07:00
|
|
|
goto out_error;
|
2012-08-21 03:12:07 -06:00
|
|
|
}
|
2012-05-10 07:29:17 -06:00
|
|
|
}
|
|
|
|
|
2012-08-21 03:12:18 -06:00
|
|
|
out:
|
|
|
|
/*
|
2014-09-08 19:56:48 -06:00
|
|
|
* If at this point we have found the hole we wanted, the returned
|
2012-08-21 03:12:18 -06:00
|
|
|
* offset may be bigger than the file size as it may be aligned to
|
2014-09-08 19:56:48 -06:00
|
|
|
* page boundary for unwritten extents. We need to deal with this
|
2012-08-21 03:12:18 -06:00
|
|
|
* situation in particular.
|
|
|
|
*/
|
2014-09-08 19:56:48 -06:00
|
|
|
if (whence == SEEK_HOLE)
|
2016-02-07 17:25:16 -07:00
|
|
|
offset = min_t(loff_t, offset, end);
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
|
|
|
|
out_error:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC loff_t
|
|
|
|
xfs_seek_hole_data(
|
|
|
|
struct file *file,
|
|
|
|
loff_t start,
|
|
|
|
int whence)
|
|
|
|
{
|
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
uint lock;
|
|
|
|
loff_t offset, end;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
lock = xfs_ilock_data_map_shared(ip);
|
|
|
|
|
|
|
|
end = i_size_read(inode);
|
|
|
|
offset = __xfs_seek_hole_data(inode, start, end, whence);
|
|
|
|
if (offset < 0) {
|
|
|
|
error = offset;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2013-06-24 22:02:13 -06:00
|
|
|
offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
|
2012-05-10 07:29:17 -06:00
|
|
|
|
|
|
|
out_unlock:
|
2013-12-06 13:30:08 -07:00
|
|
|
xfs_iunlock(ip, lock);
|
2012-05-10 07:29:17 -06:00
|
|
|
|
|
|
|
if (error)
|
2014-06-24 22:58:08 -06:00
|
|
|
return error;
|
2012-05-10 07:29:17 -06:00
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC loff_t
|
|
|
|
xfs_file_llseek(
|
|
|
|
struct file *file,
|
|
|
|
loff_t offset,
|
2014-09-08 19:57:10 -06:00
|
|
|
int whence)
|
2012-05-10 07:29:17 -06:00
|
|
|
{
|
2014-09-08 19:57:10 -06:00
|
|
|
switch (whence) {
|
2012-05-10 07:29:17 -06:00
|
|
|
case SEEK_END:
|
|
|
|
case SEEK_CUR:
|
|
|
|
case SEEK_SET:
|
2014-09-08 19:57:10 -06:00
|
|
|
return generic_file_llseek(file, offset, whence);
|
2012-05-10 07:29:17 -06:00
|
|
|
case SEEK_HOLE:
|
2014-09-08 19:56:48 -06:00
|
|
|
case SEEK_DATA:
|
2014-09-08 19:57:10 -06:00
|
|
|
return xfs_seek_hole_data(file, offset, whence);
|
2012-05-10 07:29:17 -06:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-23 03:44:19 -07:00
|
|
|
/*
|
|
|
|
* Locking for serialisation of IO during page faults. This results in a lock
|
|
|
|
* ordering of:
|
|
|
|
*
|
|
|
|
* mmap_sem (MM)
|
2015-06-03 17:18:53 -06:00
|
|
|
* sb_start_pagefault(vfs, freeze)
|
2015-11-02 18:37:02 -07:00
|
|
|
* i_mmaplock (XFS - truncate serialisation)
|
2015-06-03 17:18:53 -06:00
|
|
|
* page_lock (MM)
|
|
|
|
* i_lock (XFS - extent map serialisation)
|
2015-02-23 03:44:19 -07:00
|
|
|
*/
|
|
|
|
|
2015-02-23 03:44:54 -07:00
|
|
|
/*
|
|
|
|
* mmap()d file has taken write protection fault and is being made writable. We
|
|
|
|
* can set the page state up correctly for a writable page, which means we can
|
|
|
|
* do correct delalloc accounting (ENOSPC checking!) and unwritten extent
|
|
|
|
* mapping.
|
2015-02-23 03:44:19 -07:00
|
|
|
*/
|
|
|
|
STATIC int
|
2015-02-23 03:44:54 -07:00
|
|
|
xfs_filemap_page_mkwrite(
|
2015-02-23 03:44:19 -07:00
|
|
|
struct vm_area_struct *vma,
|
|
|
|
struct vm_fault *vmf)
|
|
|
|
{
|
2015-06-03 17:18:53 -06:00
|
|
|
struct inode *inode = file_inode(vma->vm_file);
|
2015-06-03 17:18:18 -06:00
|
|
|
int ret;
|
2015-02-23 03:44:19 -07:00
|
|
|
|
2015-06-03 17:18:53 -06:00
|
|
|
trace_xfs_filemap_page_mkwrite(XFS_I(inode));
|
2015-02-23 03:44:19 -07:00
|
|
|
|
2015-06-03 17:18:53 -06:00
|
|
|
sb_start_pagefault(inode->i_sb);
|
2015-06-03 17:18:18 -06:00
|
|
|
file_update_time(vma->vm_file);
|
2015-06-03 17:18:53 -06:00
|
|
|
xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
|
2015-02-23 03:44:19 -07:00
|
|
|
|
2015-06-03 17:18:53 -06:00
|
|
|
if (IS_DAX(inode)) {
|
2016-09-18 19:28:38 -06:00
|
|
|
ret = iomap_dax_fault(vma, vmf, &xfs_iomap_ops);
|
2015-06-03 17:18:53 -06:00
|
|
|
} else {
|
2016-06-20 17:53:44 -06:00
|
|
|
ret = iomap_page_mkwrite(vma, vmf, &xfs_iomap_ops);
|
2015-06-03 17:18:53 -06:00
|
|
|
ret = block_page_mkwrite_return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
|
|
|
|
sb_end_pagefault(inode->i_sb);
|
|
|
|
|
|
|
|
return ret;
|
2015-02-23 03:44:19 -07:00
|
|
|
}
|
|
|
|
|
2015-02-23 03:44:54 -07:00
|
|
|
STATIC int
|
2015-06-03 17:18:53 -06:00
|
|
|
xfs_filemap_fault(
|
2015-02-23 03:44:54 -07:00
|
|
|
struct vm_area_struct *vma,
|
|
|
|
struct vm_fault *vmf)
|
|
|
|
{
|
2015-07-28 19:48:00 -06:00
|
|
|
struct inode *inode = file_inode(vma->vm_file);
|
2015-06-03 17:18:53 -06:00
|
|
|
int ret;
|
2015-06-03 17:18:18 -06:00
|
|
|
|
2015-07-28 19:48:00 -06:00
|
|
|
trace_xfs_filemap_fault(XFS_I(inode));
|
2015-02-23 03:44:54 -07:00
|
|
|
|
2015-06-03 17:18:53 -06:00
|
|
|
/* DAX can shortcut the normal fault path on write faults! */
|
2015-07-28 19:48:00 -06:00
|
|
|
if ((vmf->flags & FAULT_FLAG_WRITE) && IS_DAX(inode))
|
2015-06-03 17:18:53 -06:00
|
|
|
return xfs_filemap_page_mkwrite(vma, vmf);
|
2015-02-23 03:44:54 -07:00
|
|
|
|
2015-07-28 19:48:00 -06:00
|
|
|
xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
|
|
|
|
if (IS_DAX(inode)) {
|
|
|
|
/*
|
|
|
|
* we do not want to trigger unwritten extent conversion on read
|
|
|
|
* faults - that is unnecessary overhead and would also require
|
|
|
|
* changes to xfs_get_blocks_direct() to map unwritten extent
|
|
|
|
* ioend for conversion on read-only mappings.
|
|
|
|
*/
|
2016-09-18 19:28:38 -06:00
|
|
|
ret = iomap_dax_fault(vma, vmf, &xfs_iomap_ops);
|
2015-07-28 19:48:00 -06:00
|
|
|
} else
|
|
|
|
ret = filemap_fault(vma, vmf);
|
|
|
|
xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
|
2015-02-23 03:44:54 -07:00
|
|
|
|
2015-06-03 17:18:53 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-11-02 18:37:02 -07:00
|
|
|
/*
|
|
|
|
* Similar to xfs_filemap_fault(), the DAX fault path can call into here on
|
|
|
|
* both read and write faults. Hence we need to handle both cases. There is no
|
|
|
|
* ->pmd_mkwrite callout for huge pages, so we have a single function here to
|
|
|
|
* handle both cases here. @flags carries the information on the type of fault
|
|
|
|
* occuring.
|
|
|
|
*/
|
2015-09-08 15:59:06 -06:00
|
|
|
STATIC int
|
|
|
|
xfs_filemap_pmd_fault(
|
|
|
|
struct vm_area_struct *vma,
|
|
|
|
unsigned long addr,
|
|
|
|
pmd_t *pmd,
|
|
|
|
unsigned int flags)
|
|
|
|
{
|
|
|
|
struct inode *inode = file_inode(vma->vm_file);
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!IS_DAX(inode))
|
|
|
|
return VM_FAULT_FALLBACK;
|
|
|
|
|
|
|
|
trace_xfs_filemap_pmd_fault(ip);
|
|
|
|
|
2015-11-02 18:37:02 -07:00
|
|
|
if (flags & FAULT_FLAG_WRITE) {
|
|
|
|
sb_start_pagefault(inode->i_sb);
|
|
|
|
file_update_time(vma->vm_file);
|
|
|
|
}
|
|
|
|
|
2015-09-08 15:59:06 -06:00
|
|
|
xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
|
2016-07-26 16:21:05 -06:00
|
|
|
ret = dax_pmd_fault(vma, addr, pmd, flags, xfs_get_blocks_dax_fault);
|
2015-09-08 15:59:06 -06:00
|
|
|
xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
|
|
|
|
|
2015-11-02 18:37:02 -07:00
|
|
|
if (flags & FAULT_FLAG_WRITE)
|
|
|
|
sb_end_pagefault(inode->i_sb);
|
2015-09-08 15:59:06 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-11-02 18:37:02 -07:00
|
|
|
/*
|
|
|
|
* pfn_mkwrite was originally inteneded to ensure we capture time stamp
|
|
|
|
* updates on write faults. In reality, it's need to serialise against
|
2016-01-22 16:10:56 -07:00
|
|
|
* truncate similar to page_mkwrite. Hence we cycle the XFS_MMAPLOCK_SHARED
|
|
|
|
* to ensure we serialise the fault barrier in place.
|
2015-11-02 18:37:02 -07:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_filemap_pfn_mkwrite(
|
|
|
|
struct vm_area_struct *vma,
|
|
|
|
struct vm_fault *vmf)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct inode *inode = file_inode(vma->vm_file);
|
|
|
|
struct xfs_inode *ip = XFS_I(inode);
|
|
|
|
int ret = VM_FAULT_NOPAGE;
|
|
|
|
loff_t size;
|
|
|
|
|
|
|
|
trace_xfs_filemap_pfn_mkwrite(ip);
|
|
|
|
|
|
|
|
sb_start_pagefault(inode->i_sb);
|
|
|
|
file_update_time(vma->vm_file);
|
|
|
|
|
|
|
|
/* check if the faulting page hasn't raced with truncate */
|
|
|
|
xfs_ilock(ip, XFS_MMAPLOCK_SHARED);
|
|
|
|
size = (i_size_read(inode) + PAGE_SIZE - 1) >> PAGE_SHIFT;
|
|
|
|
if (vmf->pgoff >= size)
|
|
|
|
ret = VM_FAULT_SIGBUS;
|
2016-01-22 16:10:56 -07:00
|
|
|
else if (IS_DAX(inode))
|
|
|
|
ret = dax_pfn_mkwrite(vma, vmf);
|
2015-11-02 18:37:02 -07:00
|
|
|
xfs_iunlock(ip, XFS_MMAPLOCK_SHARED);
|
|
|
|
sb_end_pagefault(inode->i_sb);
|
2015-09-08 15:59:06 -06:00
|
|
|
return ret;
|
2015-11-02 18:37:02 -07:00
|
|
|
|
2015-09-08 15:59:06 -06:00
|
|
|
}
|
|
|
|
|
2015-06-03 17:18:53 -06:00
|
|
|
static const struct vm_operations_struct xfs_file_vm_ops = {
|
|
|
|
.fault = xfs_filemap_fault,
|
2015-09-08 15:59:06 -06:00
|
|
|
.pmd_fault = xfs_filemap_pmd_fault,
|
2015-06-03 17:18:53 -06:00
|
|
|
.map_pages = filemap_map_pages,
|
|
|
|
.page_mkwrite = xfs_filemap_page_mkwrite,
|
2015-11-02 18:37:02 -07:00
|
|
|
.pfn_mkwrite = xfs_filemap_pfn_mkwrite,
|
2015-06-03 17:18:53 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
STATIC int
|
|
|
|
xfs_file_mmap(
|
|
|
|
struct file *filp,
|
|
|
|
struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
file_accessed(filp);
|
|
|
|
vma->vm_ops = &xfs_file_vm_ops;
|
|
|
|
if (IS_DAX(file_inode(filp)))
|
2015-09-08 15:59:06 -06:00
|
|
|
vma->vm_flags |= VM_MIXEDMAP | VM_HUGEPAGE;
|
2015-06-03 17:18:53 -06:00
|
|
|
return 0;
|
2015-02-23 03:44:54 -07:00
|
|
|
}
|
|
|
|
|
2006-03-28 02:56:42 -07:00
|
|
|
const struct file_operations xfs_file_operations = {
|
2012-05-10 07:29:17 -06:00
|
|
|
.llseek = xfs_file_llseek,
|
2014-04-02 12:37:59 -06:00
|
|
|
.read_iter = xfs_file_read_iter,
|
2014-04-03 12:20:23 -06:00
|
|
|
.write_iter = xfs_file_write_iter,
|
2016-09-22 21:35:42 -06:00
|
|
|
.splice_read = generic_file_splice_read,
|
2014-04-05 02:27:08 -06:00
|
|
|
.splice_write = iter_file_splice_write,
|
2006-03-13 20:00:35 -07:00
|
|
|
.unlocked_ioctl = xfs_file_ioctl,
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_COMPAT
|
2006-03-13 20:00:35 -07:00
|
|
|
.compat_ioctl = xfs_file_compat_ioctl,
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2006-03-13 20:00:35 -07:00
|
|
|
.mmap = xfs_file_mmap,
|
|
|
|
.open = xfs_file_open,
|
|
|
|
.release = xfs_file_release,
|
|
|
|
.fsync = xfs_file_fsync,
|
2016-10-07 17:59:59 -06:00
|
|
|
.get_unmapped_area = thp_get_unmapped_area,
|
2011-01-14 05:07:43 -07:00
|
|
|
.fallocate = xfs_file_fallocate,
|
2016-10-03 10:11:40 -06:00
|
|
|
.copy_file_range = xfs_file_copy_range,
|
|
|
|
.clone_file_range = xfs_file_clone_range,
|
2016-10-03 10:11:41 -06:00
|
|
|
.dedupe_file_range = xfs_file_dedupe_range,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2006-03-28 02:56:42 -07:00
|
|
|
const struct file_operations xfs_dir_file_operations = {
|
2008-11-27 20:23:32 -07:00
|
|
|
.open = xfs_dir_open,
|
2005-04-16 16:20:36 -06:00
|
|
|
.read = generic_read_dir,
|
2016-04-20 21:42:46 -06:00
|
|
|
.iterate_shared = xfs_file_readdir,
|
2008-08-24 05:24:41 -06:00
|
|
|
.llseek = generic_file_llseek,
|
2006-03-13 20:00:35 -07:00
|
|
|
.unlocked_ioctl = xfs_file_ioctl,
|
2005-05-06 07:44:46 -06:00
|
|
|
#ifdef CONFIG_COMPAT
|
2006-03-13 20:00:35 -07:00
|
|
|
.compat_ioctl = xfs_file_compat_ioctl,
|
2005-05-06 07:44:46 -06:00
|
|
|
#endif
|
2011-10-02 08:25:16 -06:00
|
|
|
.fsync = xfs_dir_fsync,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|