2019-05-31 08:09:56 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2006-01-16 16:50:04 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2006-05-18 19:09:15 +00:00
|
|
|
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
2019-06-03 11:40:01 +00:00
|
|
|
#include <linux/compat.h>
|
2006-01-16 16:50:04 +00:00
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/uio.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/mm.h>
|
2008-07-02 19:12:01 +00:00
|
|
|
#include <linux/mount.h>
|
2006-02-08 11:50:51 +00:00
|
|
|
#include <linux/fs.h>
|
2006-02-27 22:23:27 +00:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2011-01-14 12:07:43 +00:00
|
|
|
#include <linux/falloc.h>
|
|
|
|
#include <linux/swap.h>
|
2006-03-28 19:14:04 +00:00
|
|
|
#include <linux/crc32.h>
|
2006-11-30 15:14:32 +00:00
|
|
|
#include <linux/writeback.h>
|
2016-12-24 19:46:01 +00:00
|
|
|
#include <linux/uaccess.h>
|
2009-01-12 10:43:39 +00:00
|
|
|
#include <linux/dlm.h>
|
|
|
|
#include <linux/dlm_plock.h>
|
2014-08-20 16:44:45 +00:00
|
|
|
#include <linux/delay.h>
|
2018-06-24 14:04:04 +00:00
|
|
|
#include <linux/backing-dev.h>
|
2021-04-07 12:36:43 +00:00
|
|
|
#include <linux/fileattr.h>
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-27 22:23:27 +00:00
|
|
|
#include "incore.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
#include "bmap.h"
|
2018-06-24 14:04:04 +00:00
|
|
|
#include "aops.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
#include "dir.h"
|
|
|
|
#include "glock.h"
|
|
|
|
#include "glops.h"
|
|
|
|
#include "inode.h"
|
|
|
|
#include "log.h"
|
|
|
|
#include "meta_io.h"
|
|
|
|
#include "quota.h"
|
|
|
|
#include "rgrp.h"
|
|
|
|
#include "trans.h"
|
2006-02-27 22:23:27 +00:00
|
|
|
#include "util.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_llseek - seek to a location in a file
|
|
|
|
* @file: the file
|
|
|
|
* @offset: the offset
|
2012-12-17 23:59:39 +00:00
|
|
|
* @whence: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
|
|
|
* SEEK_END requires the glock for the file because it references the
|
|
|
|
* file's size.
|
|
|
|
*
|
|
|
|
* Returns: The new offset, or errno
|
|
|
|
*/
|
|
|
|
|
2012-12-17 23:59:39 +00:00
|
|
|
static loff_t gfs2_llseek(struct file *file, loff_t offset, int whence)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_holder i_gh;
|
|
|
|
loff_t error;
|
|
|
|
|
2012-12-17 23:59:39 +00:00
|
|
|
switch (whence) {
|
2017-03-15 18:12:59 +00:00
|
|
|
case SEEK_END:
|
2006-01-16 16:50:04 +00:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
|
|
|
|
&i_gh);
|
|
|
|
if (!error) {
|
2012-12-17 23:59:39 +00:00
|
|
|
error = generic_file_llseek(file, offset, whence);
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
|
|
|
}
|
2011-08-23 09:19:25 +00:00
|
|
|
break;
|
2017-03-15 18:12:59 +00:00
|
|
|
|
|
|
|
case SEEK_DATA:
|
|
|
|
error = gfs2_seek_data(file, offset);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SEEK_HOLE:
|
|
|
|
error = gfs2_seek_hole(file, offset);
|
|
|
|
break;
|
|
|
|
|
2011-08-23 09:19:25 +00:00
|
|
|
case SEEK_CUR:
|
|
|
|
case SEEK_SET:
|
2017-03-15 18:12:59 +00:00
|
|
|
/*
|
|
|
|
* These don't reference inode->i_size and don't depend on the
|
|
|
|
* block mapping, so we don't need the glock.
|
|
|
|
*/
|
2012-12-17 23:59:39 +00:00
|
|
|
error = generic_file_llseek(file, offset, whence);
|
2011-08-23 09:19:25 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error = -EINVAL;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-05-16 18:14:48 +00:00
|
|
|
* gfs2_readdir - Iterator for a directory
|
2006-01-16 16:50:04 +00:00
|
|
|
* @file: The directory to read from
|
2013-05-16 18:14:48 +00:00
|
|
|
* @ctx: What to feed directory entries to
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2013-05-16 18:14:48 +00:00
|
|
|
static int gfs2_readdir(struct file *file, struct dir_context *ctx)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-03-28 19:14:04 +00:00
|
|
|
struct inode *dir = file->f_mapping->host;
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *dip = GFS2_I(dir);
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_holder d_gh;
|
|
|
|
int error;
|
|
|
|
|
2013-05-16 18:14:48 +00:00
|
|
|
error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
|
|
|
|
if (error)
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
|
2013-05-16 18:14:48 +00:00
|
|
|
error = gfs2_dir_read(dir, ctx, &file->f_ra);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
gfs2_glock_dq_uninit(&d_gh);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2021-03-30 16:44:29 +00:00
|
|
|
/*
|
|
|
|
* struct fsflag_gfs2flag
|
2006-10-02 15:24:43 +00:00
|
|
|
*
|
2017-10-09 14:15:30 +00:00
|
|
|
* The FS_JOURNAL_DATA_FL flag maps to GFS2_DIF_INHERIT_JDATA for directories,
|
|
|
|
* and to GFS2_DIF_JDATA for non-directories.
|
2006-10-02 15:24:43 +00:00
|
|
|
*/
|
2017-10-09 14:15:30 +00:00
|
|
|
static struct {
|
|
|
|
u32 fsflag;
|
|
|
|
u32 gfsflag;
|
|
|
|
} fsflag_gfs2flag[] = {
|
|
|
|
{FS_SYNC_FL, GFS2_DIF_SYNC},
|
|
|
|
{FS_IMMUTABLE_FL, GFS2_DIF_IMMUTABLE},
|
|
|
|
{FS_APPEND_FL, GFS2_DIF_APPENDONLY},
|
|
|
|
{FS_NOATIME_FL, GFS2_DIF_NOATIME},
|
|
|
|
{FS_INDEX_FL, GFS2_DIF_EXHASH},
|
|
|
|
{FS_TOPDIR_FL, GFS2_DIF_TOPDIR},
|
|
|
|
{FS_JOURNAL_DATA_FL, GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA},
|
2006-03-31 20:01:28 +00:00
|
|
|
};
|
2006-03-28 19:14:04 +00:00
|
|
|
|
2019-07-01 15:25:34 +00:00
|
|
|
static inline u32 gfs2_gfsflags_to_fsflags(struct inode *inode, u32 gfsflags)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
u32 fsflags = 0;
|
|
|
|
|
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
gfsflags &= ~GFS2_DIF_JDATA;
|
|
|
|
else
|
|
|
|
gfsflags &= ~GFS2_DIF_INHERIT_JDATA;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(fsflag_gfs2flag); i++)
|
|
|
|
if (gfsflags & fsflag_gfs2flag[i].gfsflag)
|
|
|
|
fsflags |= fsflag_gfs2flag[i].fsflag;
|
|
|
|
return fsflags;
|
|
|
|
}
|
|
|
|
|
2021-04-07 12:36:43 +00:00
|
|
|
int gfs2_fileattr_get(struct dentry *dentry, struct fileattr *fa)
|
2006-03-28 19:14:04 +00:00
|
|
|
{
|
2021-04-07 12:36:43 +00:00
|
|
|
struct inode *inode = d_inode(dentry);
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2006-03-28 19:14:04 +00:00
|
|
|
struct gfs2_holder gh;
|
2019-07-01 15:25:34 +00:00
|
|
|
int error;
|
|
|
|
u32 fsflags;
|
2006-03-28 19:14:04 +00:00
|
|
|
|
2021-04-07 12:36:43 +00:00
|
|
|
if (d_is_special(dentry))
|
|
|
|
return -ENOTTY;
|
|
|
|
|
2008-09-18 12:53:59 +00:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
|
|
|
|
error = gfs2_glock_nq(&gh);
|
2006-03-28 19:14:04 +00:00
|
|
|
if (error)
|
2016-04-19 23:57:45 +00:00
|
|
|
goto out_uninit;
|
2006-09-25 13:26:04 +00:00
|
|
|
|
2019-07-01 15:25:34 +00:00
|
|
|
fsflags = gfs2_gfsflags_to_fsflags(inode, ip->i_diskflags);
|
2017-10-09 14:15:30 +00:00
|
|
|
|
2021-04-07 12:36:43 +00:00
|
|
|
fileattr_fill_flags(fa, fsflags);
|
2006-03-28 19:14:04 +00:00
|
|
|
|
2007-10-15 14:40:33 +00:00
|
|
|
gfs2_glock_dq(&gh);
|
2016-04-19 23:57:45 +00:00
|
|
|
out_uninit:
|
2006-03-28 19:14:04 +00:00
|
|
|
gfs2_holder_uninit(&gh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-11-08 17:51:06 +00:00
|
|
|
void gfs2_set_inode_flags(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
unsigned int flags = inode->i_flags;
|
|
|
|
|
2011-06-16 13:06:55 +00:00
|
|
|
flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_NOSEC);
|
|
|
|
if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode))
|
2015-05-05 17:25:48 +00:00
|
|
|
flags |= S_NOSEC;
|
2008-11-04 10:05:22 +00:00
|
|
|
if (ip->i_diskflags & GFS2_DIF_IMMUTABLE)
|
2006-11-08 17:51:06 +00:00
|
|
|
flags |= S_IMMUTABLE;
|
2008-11-04 10:05:22 +00:00
|
|
|
if (ip->i_diskflags & GFS2_DIF_APPENDONLY)
|
2006-11-08 17:51:06 +00:00
|
|
|
flags |= S_APPEND;
|
2008-11-04 10:05:22 +00:00
|
|
|
if (ip->i_diskflags & GFS2_DIF_NOATIME)
|
2006-11-08 17:51:06 +00:00
|
|
|
flags |= S_NOATIME;
|
2008-11-04 10:05:22 +00:00
|
|
|
if (ip->i_diskflags & GFS2_DIF_SYNC)
|
2006-11-08 17:51:06 +00:00
|
|
|
flags |= S_SYNC;
|
|
|
|
inode->i_flags = flags;
|
|
|
|
}
|
|
|
|
|
2006-03-28 19:14:04 +00:00
|
|
|
/* Flags that can be set by user space */
|
|
|
|
#define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA| \
|
|
|
|
GFS2_DIF_IMMUTABLE| \
|
|
|
|
GFS2_DIF_APPENDONLY| \
|
|
|
|
GFS2_DIF_NOATIME| \
|
|
|
|
GFS2_DIF_SYNC| \
|
2012-05-28 14:26:56 +00:00
|
|
|
GFS2_DIF_TOPDIR| \
|
2006-03-28 19:14:04 +00:00
|
|
|
GFS2_DIF_INHERIT_JDATA)
|
|
|
|
|
|
|
|
/**
|
2014-05-15 16:57:08 +00:00
|
|
|
* do_gfs2_set_flags - set flags on an inode
|
2021-05-20 12:52:46 +00:00
|
|
|
* @inode: The inode
|
2014-05-15 16:57:08 +00:00
|
|
|
* @reqflags: The flags to set
|
2006-03-28 19:14:04 +00:00
|
|
|
* @mask: Indicates which flags are valid
|
|
|
|
*
|
|
|
|
*/
|
2021-08-25 17:57:24 +00:00
|
|
|
static int do_gfs2_set_flags(struct inode *inode, u32 reqflags, u32 mask)
|
2006-03-28 19:14:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2006-03-28 19:14:04 +00:00
|
|
|
struct buffer_head *bh;
|
|
|
|
struct gfs2_holder gh;
|
|
|
|
int error;
|
2021-04-07 12:36:43 +00:00
|
|
|
u32 new_flags, flags;
|
2006-03-28 19:14:04 +00:00
|
|
|
|
2008-07-02 19:12:01 +00:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
|
|
|
|
if (error)
|
2021-04-07 12:36:43 +00:00
|
|
|
return error;
|
2010-05-24 13:36:48 +00:00
|
|
|
|
|
|
|
error = 0;
|
2008-11-04 10:05:22 +00:00
|
|
|
flags = ip->i_diskflags;
|
2006-04-04 18:29:30 +00:00
|
|
|
new_flags = (flags & ~mask) | (reqflags & mask);
|
2006-03-28 19:14:04 +00:00
|
|
|
if ((new_flags ^ flags) == 0)
|
|
|
|
goto out;
|
|
|
|
|
2006-05-12 21:07:56 +00:00
|
|
|
if (!IS_IMMUTABLE(inode)) {
|
2021-01-21 13:19:43 +00:00
|
|
|
error = gfs2_permission(&init_user_ns, inode, MAY_WRITE);
|
2006-05-12 21:07:56 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
}
|
2007-10-17 07:47:38 +00:00
|
|
|
if ((flags ^ new_flags) & GFS2_DIF_JDATA) {
|
2017-09-20 13:30:04 +00:00
|
|
|
if (new_flags & GFS2_DIF_JDATA)
|
2018-01-16 23:01:33 +00:00
|
|
|
gfs2_log_flush(sdp, ip->i_gl,
|
2018-01-08 15:34:17 +00:00
|
|
|
GFS2_LOG_HEAD_FLUSH_NORMAL |
|
|
|
|
GFS2_LFC_SET_FLAGS);
|
2007-10-17 07:47:38 +00:00
|
|
|
error = filemap_fdatawrite(inode->i_mapping);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
error = filemap_fdatawait(inode->i_mapping);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
2017-09-20 13:30:04 +00:00
|
|
|
if (new_flags & GFS2_DIF_JDATA)
|
|
|
|
gfs2_ordered_del_inode(ip);
|
2007-10-17 07:47:38 +00:00
|
|
|
}
|
2006-04-04 18:29:30 +00:00
|
|
|
error = gfs2_trans_begin(sdp, RES_DINODE, 0);
|
2006-03-28 19:14:04 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2006-04-04 18:29:30 +00:00
|
|
|
error = gfs2_meta_inode_buffer(ip, &bh);
|
|
|
|
if (error)
|
|
|
|
goto out_trans_end;
|
2017-09-22 13:29:19 +00:00
|
|
|
inode->i_ctime = current_time(inode);
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, bh);
|
2008-11-04 10:05:22 +00:00
|
|
|
ip->i_diskflags = new_flags;
|
2006-10-31 20:07:05 +00:00
|
|
|
gfs2_dinode_out(ip, bh->b_data);
|
2006-03-28 19:14:04 +00:00
|
|
|
brelse(bh);
|
2006-11-08 17:51:06 +00:00
|
|
|
gfs2_set_inode_flags(inode);
|
2007-10-17 07:47:38 +00:00
|
|
|
gfs2_set_aops(inode);
|
2006-04-04 18:29:30 +00:00
|
|
|
out_trans_end:
|
|
|
|
gfs2_trans_end(sdp);
|
2006-03-28 19:14:04 +00:00
|
|
|
out:
|
|
|
|
gfs2_glock_dq_uninit(&gh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2021-04-07 12:36:43 +00:00
|
|
|
int gfs2_fileattr_set(struct user_namespace *mnt_userns,
|
|
|
|
struct dentry *dentry, struct fileattr *fa)
|
2006-03-28 19:14:04 +00:00
|
|
|
{
|
2021-04-07 12:36:43 +00:00
|
|
|
struct inode *inode = d_inode(dentry);
|
|
|
|
u32 fsflags = fa->flags, gfsflags = 0;
|
2017-10-09 14:15:30 +00:00
|
|
|
u32 mask;
|
|
|
|
int i;
|
2010-05-24 13:36:48 +00:00
|
|
|
|
2021-04-07 12:36:43 +00:00
|
|
|
if (d_is_special(dentry))
|
|
|
|
return -ENOTTY;
|
|
|
|
|
|
|
|
if (fileattr_has_fsx(fa))
|
|
|
|
return -EOPNOTSUPP;
|
2010-05-24 13:36:48 +00:00
|
|
|
|
2017-10-09 14:15:30 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(fsflag_gfs2flag); i++) {
|
|
|
|
if (fsflags & fsflag_gfs2flag[i].fsflag) {
|
|
|
|
fsflags &= ~fsflag_gfs2flag[i].fsflag;
|
|
|
|
gfsflags |= fsflag_gfs2flag[i].gfsflag;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (fsflags || gfsflags & ~GFS2_FLAGS_USER_SET)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mask = GFS2_FLAGS_USER_SET;
|
|
|
|
if (S_ISDIR(inode->i_mode)) {
|
|
|
|
mask &= ~GFS2_DIF_JDATA;
|
|
|
|
} else {
|
|
|
|
/* The GFS2_DIF_TOPDIR flag is only valid for directories. */
|
|
|
|
if (gfsflags & GFS2_DIF_TOPDIR)
|
|
|
|
return -EINVAL;
|
|
|
|
mask &= ~(GFS2_DIF_TOPDIR | GFS2_DIF_INHERIT_JDATA);
|
2007-07-18 10:40:06 +00:00
|
|
|
}
|
2017-10-09 14:15:30 +00:00
|
|
|
|
2021-08-25 17:57:24 +00:00
|
|
|
return do_gfs2_set_flags(inode, gfsflags, mask);
|
2006-03-28 19:14:04 +00:00
|
|
|
}
|
|
|
|
|
2018-10-08 19:32:35 +00:00
|
|
|
static int gfs2_getlabel(struct file *filp, char __user *label)
|
|
|
|
{
|
|
|
|
struct inode *inode = file_inode(filp);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
|
|
|
|
|
|
|
if (copy_to_user(label, sdp->sd_sb.sb_locktable, GFS2_LOCKNAME_LEN))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-04-07 15:17:32 +00:00
|
|
|
static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
2006-03-28 19:14:04 +00:00
|
|
|
{
|
|
|
|
switch(cmd) {
|
2012-02-08 12:58:32 +00:00
|
|
|
case FITRIM:
|
|
|
|
return gfs2_fitrim(filp, (void __user *)arg);
|
2018-10-08 19:32:35 +00:00
|
|
|
case FS_IOC_GETFSLABEL:
|
|
|
|
return gfs2_getlabel(filp, (char __user *)arg);
|
2006-03-28 19:14:04 +00:00
|
|
|
}
|
2018-10-08 19:32:35 +00:00
|
|
|
|
2006-03-28 19:14:04 +00:00
|
|
|
return -ENOTTY;
|
|
|
|
}
|
|
|
|
|
2019-06-03 11:40:01 +00:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
static long gfs2_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
switch(cmd) {
|
|
|
|
/* Keep this list in sync with gfs2_ioctl */
|
|
|
|
case FITRIM:
|
|
|
|
case FS_IOC_GETFSLABEL:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
}
|
|
|
|
|
|
|
|
return gfs2_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define gfs2_compat_ioctl NULL
|
|
|
|
#endif
|
|
|
|
|
2012-07-26 10:30:54 +00:00
|
|
|
/**
|
|
|
|
* gfs2_size_hint - Give a hint to the size of a write request
|
2014-05-15 16:57:08 +00:00
|
|
|
* @filep: The struct file
|
2012-07-26 10:30:54 +00:00
|
|
|
* @offset: The file offset of the write
|
|
|
|
* @size: The length of the write
|
|
|
|
*
|
|
|
|
* When we are about to do a write, this function records the total
|
|
|
|
* write size in order to provide a suitable hint to the lower layers
|
|
|
|
* about how many blocks will be required.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void gfs2_size_hint(struct file *filep, loff_t offset, size_t size)
|
|
|
|
{
|
2013-01-23 22:07:38 +00:00
|
|
|
struct inode *inode = file_inode(filep);
|
2012-07-26 10:30:54 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
size_t blks = (size + sdp->sd_sb.sb_bsize - 1) >> sdp->sd_sb.sb_bsize_shift;
|
|
|
|
int hint = min_t(size_t, INT_MAX, blks);
|
|
|
|
|
2018-08-30 15:01:50 +00:00
|
|
|
if (hint > atomic_read(&ip->i_sizehint))
|
|
|
|
atomic_set(&ip->i_sizehint, hint);
|
2012-07-26 10:30:54 +00:00
|
|
|
}
|
|
|
|
|
2007-10-15 14:40:33 +00:00
|
|
|
/**
|
2019-07-01 21:54:38 +00:00
|
|
|
* gfs2_allocate_page_backing - Allocate blocks for a write fault
|
2007-10-15 14:40:33 +00:00
|
|
|
* @page: The (locked) page to allocate backing for
|
2019-11-07 18:06:14 +00:00
|
|
|
* @length: Size of the allocation
|
2007-10-15 14:40:33 +00:00
|
|
|
*
|
2019-07-01 21:54:38 +00:00
|
|
|
* We try to allocate all the blocks required for the page in one go. This
|
|
|
|
* might fail for various reasons, so we keep trying until all the blocks to
|
|
|
|
* back this page are allocated. If some of the blocks are already allocated,
|
|
|
|
* that is ok too.
|
2007-10-15 14:40:33 +00:00
|
|
|
*/
|
2019-11-07 18:06:14 +00:00
|
|
|
static int gfs2_allocate_page_backing(struct page *page, unsigned int length)
|
2007-10-15 14:40:33 +00:00
|
|
|
{
|
2019-07-01 21:54:38 +00:00
|
|
|
u64 pos = page_offset(page);
|
2007-10-15 14:40:33 +00:00
|
|
|
|
|
|
|
do {
|
2019-07-01 21:54:38 +00:00
|
|
|
struct iomap iomap = { };
|
|
|
|
|
2021-03-27 20:56:40 +00:00
|
|
|
if (gfs2_iomap_alloc(page->mapping->host, pos, length, &iomap))
|
2007-10-15 14:40:33 +00:00
|
|
|
return -EIO;
|
2019-07-01 21:54:38 +00:00
|
|
|
|
2019-11-07 18:06:14 +00:00
|
|
|
if (length < iomap.length)
|
|
|
|
iomap.length = length;
|
|
|
|
length -= iomap.length;
|
2019-07-01 21:54:38 +00:00
|
|
|
pos += iomap.length;
|
2019-11-07 18:06:14 +00:00
|
|
|
} while (length > 0);
|
2019-07-01 21:54:38 +00:00
|
|
|
|
2007-10-15 14:40:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_page_mkwrite - Make a shared, mmap()ed, page writable
|
2014-05-15 16:57:08 +00:00
|
|
|
* @vmf: The virtual memory fault containing the page to become writable
|
2007-10-15 14:40:33 +00:00
|
|
|
*
|
|
|
|
* When the page becomes writable, we need to ensure that we have
|
|
|
|
* blocks allocated on disk to back that page.
|
|
|
|
*/
|
|
|
|
|
2018-07-02 16:46:13 +00:00
|
|
|
static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf)
|
2007-10-15 14:40:33 +00:00
|
|
|
{
|
2009-03-31 22:23:21 +00:00
|
|
|
struct page *page = vmf->page;
|
2017-02-24 22:56:41 +00:00
|
|
|
struct inode *inode = file_inode(vmf->vma->vm_file);
|
2007-10-15 14:40:33 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2013-10-02 10:13:25 +00:00
|
|
|
struct gfs2_alloc_parms ap = { .aflags = 0, };
|
2019-11-06 14:09:25 +00:00
|
|
|
u64 offset = page_offset(page);
|
2007-10-15 14:40:33 +00:00
|
|
|
unsigned int data_blocks, ind_blocks, rblocks;
|
2021-05-13 12:30:31 +00:00
|
|
|
vm_fault_t ret = VM_FAULT_LOCKED;
|
2007-10-15 14:40:33 +00:00
|
|
|
struct gfs2_holder gh;
|
2019-11-06 14:09:25 +00:00
|
|
|
unsigned int length;
|
2011-09-07 14:12:51 +00:00
|
|
|
loff_t size;
|
2021-05-13 12:30:31 +00:00
|
|
|
int err;
|
2007-10-15 14:40:33 +00:00
|
|
|
|
2012-06-12 14:20:41 +00:00
|
|
|
sb_start_pagefault(inode->i_sb);
|
2011-09-07 14:12:51 +00:00
|
|
|
|
2008-09-18 12:53:59 +00:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
|
2021-05-13 12:30:31 +00:00
|
|
|
err = gfs2_glock_nq(&gh);
|
|
|
|
if (err) {
|
|
|
|
ret = block_page_mkwrite_return(err);
|
2013-05-28 14:04:44 +00:00
|
|
|
goto out_uninit;
|
2021-05-13 12:30:31 +00:00
|
|
|
}
|
2007-10-15 14:40:33 +00:00
|
|
|
|
2019-11-06 14:09:25 +00:00
|
|
|
/* Check page index against inode size */
|
|
|
|
size = i_size_read(inode);
|
|
|
|
if (offset >= size) {
|
2021-05-13 12:30:31 +00:00
|
|
|
ret = VM_FAULT_SIGBUS;
|
2019-11-06 14:09:25 +00:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2016-09-26 18:20:19 +00:00
|
|
|
/* Update file times before taking page lock */
|
2017-02-24 22:56:41 +00:00
|
|
|
file_update_time(vmf->vma->vm_file);
|
2016-09-26 18:20:19 +00:00
|
|
|
|
2019-11-06 14:09:25 +00:00
|
|
|
/* page is wholly or partially inside EOF */
|
2021-06-21 20:28:50 +00:00
|
|
|
if (size - offset < PAGE_SIZE)
|
|
|
|
length = size - offset;
|
2019-11-06 14:09:25 +00:00
|
|
|
else
|
|
|
|
length = PAGE_SIZE;
|
|
|
|
|
|
|
|
gfs2_size_hint(vmf->vma->vm_file, offset, length);
|
|
|
|
|
2009-03-19 13:15:44 +00:00
|
|
|
set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
|
|
|
|
set_bit(GIF_SW_PAGED, &ip->i_flags);
|
|
|
|
|
2019-11-06 14:09:25 +00:00
|
|
|
/*
|
|
|
|
* iomap_writepage / iomap_writepages currently don't support inline
|
|
|
|
* files, so always unstuff here.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!gfs2_is_stuffed(ip) &&
|
|
|
|
!gfs2_write_alloc_required(ip, offset, length)) {
|
2011-09-07 14:12:51 +00:00
|
|
|
lock_page(page);
|
|
|
|
if (!PageUptodate(page) || page->mapping != inode->i_mapping) {
|
2021-05-13 12:30:31 +00:00
|
|
|
ret = VM_FAULT_NOPAGE;
|
2011-09-07 14:12:51 +00:00
|
|
|
unlock_page(page);
|
|
|
|
}
|
2007-10-15 14:40:33 +00:00
|
|
|
goto out_unlock;
|
2011-09-07 14:12:51 +00:00
|
|
|
}
|
|
|
|
|
2021-05-13 12:30:31 +00:00
|
|
|
err = gfs2_rindex_update(sdp);
|
|
|
|
if (err) {
|
|
|
|
ret = block_page_mkwrite_return(err);
|
2008-01-10 15:18:55 +00:00
|
|
|
goto out_unlock;
|
2021-05-13 12:30:31 +00:00
|
|
|
}
|
2008-01-10 15:18:55 +00:00
|
|
|
|
2019-11-06 14:09:25 +00:00
|
|
|
gfs2_write_calc_reserv(ip, length, &data_blocks, &ind_blocks);
|
2013-10-02 10:13:25 +00:00
|
|
|
ap.target = data_blocks + ind_blocks;
|
2021-05-13 12:30:31 +00:00
|
|
|
err = gfs2_quota_lock_check(ip, &ap);
|
|
|
|
if (err) {
|
|
|
|
ret = block_page_mkwrite_return(err);
|
2015-03-18 17:03:41 +00:00
|
|
|
goto out_unlock;
|
2021-05-13 12:30:31 +00:00
|
|
|
}
|
|
|
|
err = gfs2_inplace_reserve(ip, &ap);
|
|
|
|
if (err) {
|
|
|
|
ret = block_page_mkwrite_return(err);
|
2007-10-15 14:40:33 +00:00
|
|
|
goto out_quota_unlock;
|
2021-05-13 12:30:31 +00:00
|
|
|
}
|
2007-10-15 14:40:33 +00:00
|
|
|
|
|
|
|
rblocks = RES_DINODE + ind_blocks;
|
|
|
|
if (gfs2_is_jdata(ip))
|
|
|
|
rblocks += data_blocks ? data_blocks : 1;
|
2010-09-27 21:00:04 +00:00
|
|
|
if (ind_blocks || data_blocks) {
|
2007-10-15 14:40:33 +00:00
|
|
|
rblocks += RES_STATFS + RES_QUOTA;
|
2012-07-30 13:53:19 +00:00
|
|
|
rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks);
|
2010-09-27 21:00:04 +00:00
|
|
|
}
|
2021-05-13 12:30:31 +00:00
|
|
|
err = gfs2_trans_begin(sdp, rblocks, 0);
|
|
|
|
if (err) {
|
|
|
|
ret = block_page_mkwrite_return(err);
|
2007-10-15 14:40:33 +00:00
|
|
|
goto out_trans_fail;
|
2021-05-13 12:30:31 +00:00
|
|
|
}
|
2007-10-15 14:40:33 +00:00
|
|
|
|
2021-06-17 21:04:14 +00:00
|
|
|
/* Unstuff, if required, and allocate backing blocks for page */
|
|
|
|
if (gfs2_is_stuffed(ip)) {
|
2021-06-17 19:36:50 +00:00
|
|
|
err = gfs2_unstuff_dinode(ip);
|
2021-06-17 21:04:14 +00:00
|
|
|
if (err) {
|
|
|
|
ret = block_page_mkwrite_return(err);
|
|
|
|
goto out_trans_end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-15 14:40:33 +00:00
|
|
|
lock_page(page);
|
2011-09-07 14:12:51 +00:00
|
|
|
/* If truncated, we must retry the operation, we may have raced
|
|
|
|
* with the glock demotion code.
|
|
|
|
*/
|
2021-05-13 12:30:31 +00:00
|
|
|
if (!PageUptodate(page) || page->mapping != inode->i_mapping) {
|
|
|
|
ret = VM_FAULT_NOPAGE;
|
2021-06-17 21:04:14 +00:00
|
|
|
goto out_page_locked;
|
2021-05-13 12:30:31 +00:00
|
|
|
}
|
2011-09-07 14:12:51 +00:00
|
|
|
|
2021-05-13 12:30:31 +00:00
|
|
|
err = gfs2_allocate_page_backing(page, length);
|
|
|
|
if (err)
|
|
|
|
ret = block_page_mkwrite_return(err);
|
2007-10-15 14:40:33 +00:00
|
|
|
|
2021-06-17 21:04:14 +00:00
|
|
|
out_page_locked:
|
2021-05-13 12:30:31 +00:00
|
|
|
if (ret != VM_FAULT_LOCKED)
|
2011-09-07 14:12:51 +00:00
|
|
|
unlock_page(page);
|
2021-06-17 21:04:14 +00:00
|
|
|
out_trans_end:
|
2007-10-15 14:40:33 +00:00
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
out_trans_fail:
|
|
|
|
gfs2_inplace_release(ip);
|
|
|
|
out_quota_unlock:
|
|
|
|
gfs2_quota_unlock(ip);
|
|
|
|
out_unlock:
|
|
|
|
gfs2_glock_dq(&gh);
|
2013-05-28 14:04:44 +00:00
|
|
|
out_uninit:
|
2007-10-15 14:40:33 +00:00
|
|
|
gfs2_holder_uninit(&gh);
|
2021-05-13 12:30:31 +00:00
|
|
|
if (ret == VM_FAULT_LOCKED) {
|
2011-09-07 14:12:51 +00:00
|
|
|
set_page_dirty(page);
|
mm: only enforce stable page writes if the backing device requires it
Create a helper function to check if a backing device requires stable
page writes and, if so, performs the necessary wait. Then, make it so
that all points in the memory manager that handle making pages writable
use the helper function. This should provide stable page write support
to most filesystems, while eliminating unnecessary waiting for devices
that don't require the feature.
Before this patchset, all filesystems would block, regardless of whether
or not it was necessary. ext3 would wait, but still generate occasional
checksum errors. The network filesystems were left to do their own
thing, so they'd wait too.
After this patchset, all the disk filesystems except ext3 and btrfs will
wait only if the hardware requires it. ext3 (if necessary) snapshots
pages instead of blocking, and btrfs provides its own bdi so the mm will
never wait. Network filesystems haven't been touched, so either they
provide their own stable page guarantees or they don't block at all.
The blocking behavior is back to what it was before 3.0 if you don't
have a disk requiring stable page writes.
Here's the result of using dbench to test latency on ext2:
3.8.0-rc3:
Operation Count AvgLat MaxLat
----------------------------------------
WriteX 109347 0.028 59.817
ReadX 347180 0.004 3.391
Flush 15514 29.828 287.283
Throughput 57.429 MB/sec 4 clients 4 procs max_latency=287.290 ms
3.8.0-rc3 + patches:
WriteX 105556 0.029 4.273
ReadX 335004 0.005 4.112
Flush 14982 30.540 298.634
Throughput 55.4496 MB/sec 4 clients 4 procs max_latency=298.650 ms
As you can see, the maximum write latency drops considerably with this
patch enabled. The other filesystems (ext3/ext4/xfs/btrfs) behave
similarly, but see the cover letter for those results.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Acked-by: Steven Whitehouse <swhiteho@redhat.com>
Reviewed-by: Jan Kara <jack@suse.cz>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Artem Bityutskiy <dedekind1@gmail.com>
Cc: Joel Becker <jlbec@evilplan.org>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Eric Van Hensbergen <ericvh@gmail.com>
Cc: Ron Minnich <rminnich@sandia.gov>
Cc: Latchesar Ionkov <lucho@ionkov.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-22 00:42:51 +00:00
|
|
|
wait_for_stable_page(page);
|
2011-09-07 14:12:51 +00:00
|
|
|
}
|
2012-06-12 14:20:41 +00:00
|
|
|
sb_end_pagefault(inode->i_sb);
|
2021-05-13 12:30:31 +00:00
|
|
|
return ret;
|
2007-10-15 14:40:33 +00:00
|
|
|
}
|
|
|
|
|
2020-07-01 17:25:19 +00:00
|
|
|
static vm_fault_t gfs2_fault(struct vm_fault *vmf)
|
|
|
|
{
|
|
|
|
struct inode *inode = file_inode(vmf->vma->vm_file);
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_holder gh;
|
|
|
|
vm_fault_t ret;
|
|
|
|
int err;
|
|
|
|
|
2021-06-01 20:53:27 +00:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
|
2020-07-01 17:25:19 +00:00
|
|
|
err = gfs2_glock_nq(&gh);
|
|
|
|
if (err) {
|
|
|
|
ret = block_page_mkwrite_return(err);
|
|
|
|
goto out_uninit;
|
|
|
|
}
|
|
|
|
ret = filemap_fault(vmf);
|
|
|
|
gfs2_glock_dq(&gh);
|
|
|
|
out_uninit:
|
|
|
|
gfs2_holder_uninit(&gh);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-09-27 18:29:37 +00:00
|
|
|
static const struct vm_operations_struct gfs2_vm_ops = {
|
2020-07-01 17:25:19 +00:00
|
|
|
.fault = gfs2_fault,
|
2014-04-07 22:37:19 +00:00
|
|
|
.map_pages = filemap_map_pages,
|
2007-10-15 14:40:33 +00:00
|
|
|
.page_mkwrite = gfs2_page_mkwrite,
|
|
|
|
};
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
2021-03-30 16:44:29 +00:00
|
|
|
* gfs2_mmap
|
2006-01-16 16:50:04 +00:00
|
|
|
* @file: The file to map
|
|
|
|
* @vma: The VMA which described the mapping
|
|
|
|
*
|
2009-04-29 12:59:35 +00:00
|
|
|
* There is no need to get a lock here unless we should be updating
|
|
|
|
* atime. We ignore any locking errors since the only consequence is
|
|
|
|
* a missed atime update (which will just be deferred until later).
|
|
|
|
*
|
|
|
|
* Returns: 0
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
|
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2011-02-02 14:48:10 +00:00
|
|
|
if (!(file->f_flags & O_NOATIME) &&
|
|
|
|
!IS_NOATIME(&ip->i_inode)) {
|
2009-04-29 12:59:35 +00:00
|
|
|
struct gfs2_holder i_gh;
|
|
|
|
int error;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2012-11-06 06:49:28 +00:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
|
|
|
|
&i_gh);
|
2011-02-02 14:48:10 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
2012-11-06 06:49:28 +00:00
|
|
|
/* grab lock to update inode */
|
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
|
|
|
file_accessed(file);
|
2009-04-29 12:59:35 +00:00
|
|
|
}
|
2007-10-15 14:40:33 +00:00
|
|
|
vma->vm_ops = &gfs2_vm_ops;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2009-04-29 12:59:35 +00:00
|
|
|
return 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-06-14 10:17:15 +00:00
|
|
|
* gfs2_open_common - This is common to open and atomic_open
|
|
|
|
* @inode: The inode being opened
|
|
|
|
* @file: The file being opened
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
2013-06-14 10:17:15 +00:00
|
|
|
* This maybe called under a glock or not depending upon how it has
|
|
|
|
* been called. We must always be called under a glock for regular
|
|
|
|
* files, however. For other file types, it does not matter whether
|
|
|
|
* we hold the glock or not.
|
|
|
|
*
|
|
|
|
* Returns: Error code or 0 for success
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
2013-06-14 10:17:15 +00:00
|
|
|
int gfs2_open_common(struct inode *inode, struct file *file)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
|
|
|
struct gfs2_file *fp;
|
2013-06-14 10:17:15 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (S_ISREG(inode->i_mode)) {
|
|
|
|
ret = generic_file_open(inode, file);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-06-14 10:17:15 +00:00
|
|
|
fp = kzalloc(sizeof(struct gfs2_file), GFP_NOFS);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!fp)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_init(&fp->f_fl_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-06-14 19:32:57 +00:00
|
|
|
gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
|
2006-02-27 22:23:27 +00:00
|
|
|
file->private_data = fp;
|
2020-02-27 18:47:53 +00:00
|
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
|
|
ret = gfs2_qa_get(GFS2_I(inode));
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
}
|
2013-06-14 10:17:15 +00:00
|
|
|
return 0;
|
2020-02-27 18:47:53 +00:00
|
|
|
|
|
|
|
fail:
|
|
|
|
kfree(file->private_data);
|
|
|
|
file->private_data = NULL;
|
|
|
|
return ret;
|
2013-06-14 10:17:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_open - open a file
|
|
|
|
* @inode: the inode to open
|
|
|
|
* @file: the struct file for this opening
|
|
|
|
*
|
|
|
|
* After atomic_open, this function is only used for opening files
|
|
|
|
* which are already cached. We must still get the glock for regular
|
|
|
|
* files to ensure that we have the file size uptodate for the large
|
|
|
|
* file check which is in the common code. That is only an issue for
|
|
|
|
* regular files though.
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_holder i_gh;
|
|
|
|
int error;
|
|
|
|
bool need_unlock = false;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-11-01 17:22:46 +00:00
|
|
|
if (S_ISREG(ip->i_inode.i_mode)) {
|
2006-01-16 16:50:04 +00:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
|
|
|
|
&i_gh);
|
|
|
|
if (error)
|
2013-06-14 10:17:15 +00:00
|
|
|
return error;
|
|
|
|
need_unlock = true;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-06-14 10:17:15 +00:00
|
|
|
error = gfs2_open_common(inode, file);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-06-14 10:17:15 +00:00
|
|
|
if (need_unlock)
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-04-11 16:56:41 +00:00
|
|
|
* gfs2_release - called to close a struct file
|
2006-01-16 16:50:04 +00:00
|
|
|
* @inode: the inode the struct file belongs to
|
|
|
|
* @file: the struct file being closed
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2012-04-11 16:56:41 +00:00
|
|
|
static int gfs2_release(struct inode *inode, struct file *file)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2012-06-06 10:17:59 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2012-07-19 12:12:40 +00:00
|
|
|
kfree(file->private_data);
|
2006-02-27 22:23:27 +00:00
|
|
|
file->private_data = NULL;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2022-01-18 14:30:18 +00:00
|
|
|
if (file->f_mode & FMODE_WRITE) {
|
|
|
|
if (gfs2_rs_active(&ip->i_res))
|
2021-12-10 13:43:36 +00:00
|
|
|
gfs2_rs_delete(ip);
|
2020-03-06 16:32:35 +00:00
|
|
|
gfs2_qa_put(ip);
|
2022-01-18 14:30:18 +00:00
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_fsync - sync the dirty data for a file (across the cluster)
|
2011-07-17 00:44:56 +00:00
|
|
|
* @file: the file that points to the dentry
|
|
|
|
* @start: the start position in the file to sync
|
|
|
|
* @end: the end position in the file to sync
|
2011-04-14 08:54:02 +00:00
|
|
|
* @datasync: set if we can ignore timestamp changes
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
2011-07-27 09:58:48 +00:00
|
|
|
* We split the data flushing here so that we don't wait for the data
|
|
|
|
* until after we've also sent the metadata to disk. Note that for
|
|
|
|
* data=ordered, we will write & wait for the data at the log flush
|
|
|
|
* stage anyway, so this is unlikely to make much of a difference
|
|
|
|
* except in the data=writeback case.
|
|
|
|
*
|
|
|
|
* If the fdatawrite fails due to any reason except -EIO, we will
|
|
|
|
* continue the remainder of the fsync, although we'll still report
|
|
|
|
* the error at the end. This is to match filemap_write_and_wait_range()
|
|
|
|
* behaviour.
|
2006-12-07 14:13:14 +00:00
|
|
|
*
|
2006-01-16 16:50:04 +00:00
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2011-07-17 00:44:56 +00:00
|
|
|
static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
|
|
|
|
int datasync)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2011-07-27 09:58:48 +00:00
|
|
|
struct address_space *mapping = file->f_mapping;
|
|
|
|
struct inode *inode = mapping->host;
|
2021-01-12 19:02:52 +00:00
|
|
|
int sync_state = inode->i_state & I_DIRTY;
|
2011-04-14 08:54:02 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2011-11-08 14:04:20 +00:00
|
|
|
int ret = 0, ret1 = 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2011-07-27 09:58:48 +00:00
|
|
|
if (mapping->nrpages) {
|
|
|
|
ret1 = filemap_fdatawrite_range(mapping, start, end);
|
|
|
|
if (ret1 == -EIO)
|
|
|
|
return ret1;
|
|
|
|
}
|
2011-07-17 00:44:56 +00:00
|
|
|
|
2013-09-03 21:59:42 +00:00
|
|
|
if (!gfs2_is_jdata(ip))
|
|
|
|
sync_state &= ~I_DIRTY_PAGES;
|
2011-04-14 08:54:02 +00:00
|
|
|
if (datasync)
|
2021-01-12 19:02:52 +00:00
|
|
|
sync_state &= ~I_DIRTY_SYNC;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2011-04-14 08:54:02 +00:00
|
|
|
if (sync_state) {
|
|
|
|
ret = sync_inode_metadata(inode, 1);
|
2011-09-07 09:33:25 +00:00
|
|
|
if (ret)
|
2011-04-14 08:54:02 +00:00
|
|
|
return ret;
|
2011-08-05 09:12:47 +00:00
|
|
|
if (gfs2_is_jdata(ip))
|
2017-07-07 19:20:53 +00:00
|
|
|
ret = file_write_and_wait(file);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2011-09-07 09:33:25 +00:00
|
|
|
gfs2_ail_flush(ip->i_gl, 1);
|
2006-11-30 15:14:32 +00:00
|
|
|
}
|
|
|
|
|
2011-07-27 09:58:48 +00:00
|
|
|
if (mapping->nrpages)
|
2017-07-07 19:20:53 +00:00
|
|
|
ret = file_fdatawait_range(file, start, end);
|
2011-07-27 09:58:48 +00:00
|
|
|
|
|
|
|
return ret ? ret : ret1;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2022-05-05 10:53:26 +00:00
|
|
|
static inline bool should_fault_in_pages(struct iov_iter *i,
|
2022-05-05 11:32:23 +00:00
|
|
|
struct kiocb *iocb,
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
size_t *prev_count,
|
|
|
|
size_t *window_size)
|
|
|
|
{
|
|
|
|
size_t count = iov_iter_count(i);
|
2022-03-07 22:30:03 +00:00
|
|
|
size_t size, offs;
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
|
2022-05-04 21:37:30 +00:00
|
|
|
if (!count)
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
return false;
|
|
|
|
if (!iter_is_iovec(i))
|
|
|
|
return false;
|
|
|
|
|
2022-03-07 22:30:03 +00:00
|
|
|
size = PAGE_SIZE;
|
2022-05-05 11:32:23 +00:00
|
|
|
offs = offset_in_page(iocb->ki_pos);
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
if (*prev_count != count || !*window_size) {
|
2022-03-07 22:30:03 +00:00
|
|
|
size_t nr_dirtied;
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
|
|
|
|
nr_dirtied = max(current->nr_dirtied_pause -
|
2022-03-07 22:30:03 +00:00
|
|
|
current->nr_dirtied, 8);
|
2022-05-05 11:32:23 +00:00
|
|
|
size = min_t(size_t, SZ_1M, nr_dirtied << PAGE_SHIFT);
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*prev_count = count;
|
2022-03-07 22:30:03 +00:00
|
|
|
*window_size = size - offs;
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-06-29 22:47:15 +00:00
|
|
|
static ssize_t gfs2_file_direct_read(struct kiocb *iocb, struct iov_iter *to,
|
|
|
|
struct gfs2_holder *gh)
|
2018-06-19 14:08:02 +00:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
|
|
|
struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
|
2021-07-12 11:40:38 +00:00
|
|
|
size_t prev_count = 0, window_size = 0;
|
2022-04-27 11:53:42 +00:00
|
|
|
size_t read = 0;
|
2018-06-19 14:08:02 +00:00
|
|
|
ssize_t ret;
|
|
|
|
|
2021-07-12 11:40:38 +00:00
|
|
|
/*
|
|
|
|
* In this function, we disable page faults when we're holding the
|
|
|
|
* inode glock while doing I/O. If a page fault occurs, we indicate
|
|
|
|
* that the inode glock may be dropped, fault in the pages manually,
|
|
|
|
* and retry.
|
|
|
|
*
|
|
|
|
* Unlike generic_file_read_iter, for reads, iomap_dio_rw can trigger
|
|
|
|
* physical as well as manual page faults, and we need to disable both
|
|
|
|
* kinds.
|
|
|
|
*
|
|
|
|
* For direct I/O, gfs2 takes the inode glock in deferred mode. This
|
|
|
|
* locking mode is compatible with other deferred holders, so multiple
|
|
|
|
* processes and nodes can do direct I/O to a file at the same time.
|
|
|
|
* There's no guarantee that reads or writes will be atomic. Any
|
|
|
|
* coordination among readers and writers needs to happen externally.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!iov_iter_count(to))
|
2018-06-19 14:08:02 +00:00
|
|
|
return 0; /* skip atime */
|
|
|
|
|
2020-06-29 22:47:15 +00:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, gh);
|
2021-07-12 11:40:38 +00:00
|
|
|
retry:
|
2020-06-29 22:47:15 +00:00
|
|
|
ret = gfs2_glock_nq(gh);
|
2018-06-19 14:08:02 +00:00
|
|
|
if (ret)
|
|
|
|
goto out_uninit;
|
2021-07-12 11:40:38 +00:00
|
|
|
pagefault_disable();
|
|
|
|
to->nofault = true;
|
|
|
|
ret = iomap_dio_rw(iocb, to, &gfs2_iomap_ops, NULL,
|
2022-05-05 20:11:11 +00:00
|
|
|
IOMAP_DIO_PARTIAL, NULL, read);
|
2021-07-12 11:40:38 +00:00
|
|
|
to->nofault = false;
|
|
|
|
pagefault_enable();
|
2022-05-05 10:53:26 +00:00
|
|
|
if (ret <= 0 && ret != -EFAULT)
|
|
|
|
goto out_unlock;
|
2022-04-26 21:31:06 +00:00
|
|
|
/* No increment (+=) because iomap_dio_rw returns a cumulative value. */
|
2021-07-12 11:40:38 +00:00
|
|
|
if (ret > 0)
|
2022-04-27 11:53:42 +00:00
|
|
|
read = ret;
|
2021-07-12 11:40:38 +00:00
|
|
|
|
2022-05-05 11:32:23 +00:00
|
|
|
if (should_fault_in_pages(to, iocb, &prev_count, &window_size)) {
|
2022-05-11 16:27:12 +00:00
|
|
|
gfs2_glock_dq(gh);
|
2022-05-05 10:37:49 +00:00
|
|
|
window_size -= fault_in_iov_iter_writeable(to, window_size);
|
2022-05-11 16:27:12 +00:00
|
|
|
if (window_size)
|
2022-03-17 13:20:38 +00:00
|
|
|
goto retry;
|
2021-07-12 11:40:38 +00:00
|
|
|
}
|
2022-05-05 10:53:26 +00:00
|
|
|
out_unlock:
|
2021-07-12 11:40:38 +00:00
|
|
|
if (gfs2_holder_queued(gh))
|
|
|
|
gfs2_glock_dq(gh);
|
2018-06-19 14:08:02 +00:00
|
|
|
out_uninit:
|
2020-06-29 22:47:15 +00:00
|
|
|
gfs2_holder_uninit(gh);
|
2022-04-26 21:31:06 +00:00
|
|
|
/* User space doesn't expect partial success. */
|
2021-07-12 11:40:38 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2022-04-27 11:53:42 +00:00
|
|
|
return read;
|
2018-06-19 14:08:02 +00:00
|
|
|
}
|
|
|
|
|
2020-06-29 22:47:15 +00:00
|
|
|
static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from,
|
|
|
|
struct gfs2_holder *gh)
|
2018-06-19 14:08:02 +00:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
|
|
|
struct inode *inode = file->f_mapping->host;
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2021-07-12 11:40:38 +00:00
|
|
|
size_t prev_count = 0, window_size = 0;
|
2022-04-27 11:53:42 +00:00
|
|
|
size_t written = 0;
|
2018-06-19 14:08:02 +00:00
|
|
|
ssize_t ret;
|
|
|
|
|
2021-07-12 11:40:38 +00:00
|
|
|
/*
|
|
|
|
* In this function, we disable page faults when we're holding the
|
|
|
|
* inode glock while doing I/O. If a page fault occurs, we indicate
|
|
|
|
* that the inode glock may be dropped, fault in the pages manually,
|
|
|
|
* and retry.
|
|
|
|
*
|
|
|
|
* For writes, iomap_dio_rw only triggers manual page faults, so we
|
|
|
|
* don't need to disable physical ones.
|
|
|
|
*/
|
|
|
|
|
2018-06-19 14:08:02 +00:00
|
|
|
/*
|
|
|
|
* Deferred lock, even if its a write, since we do no allocation on
|
|
|
|
* this path. All we need to change is the atime, and this lock mode
|
|
|
|
* ensures that other nodes have flushed their buffered read caches
|
|
|
|
* (i.e. their page cache entries for this inode). We do not,
|
|
|
|
* unfortunately, have the option of only flushing a range like the
|
|
|
|
* VFS does.
|
|
|
|
*/
|
2020-06-29 22:47:15 +00:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, gh);
|
2021-07-12 11:40:38 +00:00
|
|
|
retry:
|
2020-06-29 22:47:15 +00:00
|
|
|
ret = gfs2_glock_nq(gh);
|
2018-06-19 14:08:02 +00:00
|
|
|
if (ret)
|
|
|
|
goto out_uninit;
|
|
|
|
/* Silently fall back to buffered I/O when writing beyond EOF */
|
2021-07-12 11:40:38 +00:00
|
|
|
if (iocb->ki_pos + iov_iter_count(from) > i_size_read(&ip->i_inode))
|
2022-05-05 10:53:26 +00:00
|
|
|
goto out_unlock;
|
2018-06-19 14:08:02 +00:00
|
|
|
|
2021-07-12 11:40:38 +00:00
|
|
|
from->nofault = true;
|
|
|
|
ret = iomap_dio_rw(iocb, from, &gfs2_iomap_ops, NULL,
|
2022-05-05 20:11:11 +00:00
|
|
|
IOMAP_DIO_PARTIAL, NULL, written);
|
2021-07-12 11:40:38 +00:00
|
|
|
from->nofault = false;
|
2022-05-05 10:53:26 +00:00
|
|
|
if (ret <= 0) {
|
|
|
|
if (ret == -ENOTBLK)
|
|
|
|
ret = 0;
|
|
|
|
if (ret != -EFAULT)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2022-04-26 21:31:06 +00:00
|
|
|
/* No increment (+=) because iomap_dio_rw returns a cumulative value. */
|
2021-07-12 11:40:38 +00:00
|
|
|
if (ret > 0)
|
2022-04-27 11:53:42 +00:00
|
|
|
written = ret;
|
2021-07-12 11:40:38 +00:00
|
|
|
|
2022-05-05 11:32:23 +00:00
|
|
|
if (should_fault_in_pages(from, iocb, &prev_count, &window_size)) {
|
2022-05-11 16:27:12 +00:00
|
|
|
gfs2_glock_dq(gh);
|
2022-05-05 10:37:49 +00:00
|
|
|
window_size -= fault_in_iov_iter_readable(from, window_size);
|
2022-05-11 16:27:12 +00:00
|
|
|
if (window_size)
|
2022-03-17 13:20:38 +00:00
|
|
|
goto retry;
|
2021-07-12 11:40:38 +00:00
|
|
|
}
|
2022-05-05 10:53:26 +00:00
|
|
|
out_unlock:
|
2021-07-12 11:40:38 +00:00
|
|
|
if (gfs2_holder_queued(gh))
|
|
|
|
gfs2_glock_dq(gh);
|
2018-06-19 14:08:02 +00:00
|
|
|
out_uninit:
|
2020-06-29 22:47:15 +00:00
|
|
|
gfs2_holder_uninit(gh);
|
2022-04-26 21:31:06 +00:00
|
|
|
/* User space doesn't expect partial success. */
|
2021-07-12 11:40:38 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2022-04-27 11:53:42 +00:00
|
|
|
return written;
|
2018-06-19 14:08:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t gfs2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
|
|
|
|
{
|
2020-07-01 17:25:19 +00:00
|
|
|
struct gfs2_inode *ip;
|
|
|
|
struct gfs2_holder gh;
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
size_t prev_count = 0, window_size = 0;
|
2022-04-27 11:53:42 +00:00
|
|
|
size_t read = 0;
|
2018-06-19 14:08:02 +00:00
|
|
|
ssize_t ret;
|
|
|
|
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
/*
|
|
|
|
* In this function, we disable page faults when we're holding the
|
|
|
|
* inode glock while doing I/O. If a page fault occurs, we indicate
|
|
|
|
* that the inode glock may be dropped, fault in the pages manually,
|
|
|
|
* and retry.
|
|
|
|
*/
|
|
|
|
|
2022-03-24 21:40:20 +00:00
|
|
|
if (iocb->ki_flags & IOCB_DIRECT)
|
|
|
|
return gfs2_file_direct_read(iocb, to, &gh);
|
|
|
|
|
2022-03-14 17:32:02 +00:00
|
|
|
pagefault_disable();
|
2020-07-01 17:25:19 +00:00
|
|
|
iocb->ki_flags |= IOCB_NOIO;
|
|
|
|
ret = generic_file_read_iter(iocb, to);
|
|
|
|
iocb->ki_flags &= ~IOCB_NOIO;
|
2022-03-14 17:32:02 +00:00
|
|
|
pagefault_enable();
|
2020-07-01 17:25:19 +00:00
|
|
|
if (ret >= 0) {
|
|
|
|
if (!iov_iter_count(to))
|
|
|
|
return ret;
|
2022-04-27 11:53:42 +00:00
|
|
|
read = ret;
|
2022-03-14 17:32:02 +00:00
|
|
|
} else if (ret != -EFAULT) {
|
2020-07-01 17:25:19 +00:00
|
|
|
if (ret != -EAGAIN)
|
|
|
|
return ret;
|
|
|
|
if (iocb->ki_flags & IOCB_NOWAIT)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
ip = GFS2_I(iocb->ki_filp->f_mapping->host);
|
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
retry:
|
2020-07-01 17:25:19 +00:00
|
|
|
ret = gfs2_glock_nq(&gh);
|
|
|
|
if (ret)
|
|
|
|
goto out_uninit;
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
pagefault_disable();
|
2020-07-01 17:25:19 +00:00
|
|
|
ret = generic_file_read_iter(iocb, to);
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
pagefault_enable();
|
2022-05-05 10:53:26 +00:00
|
|
|
if (ret <= 0 && ret != -EFAULT)
|
|
|
|
goto out_unlock;
|
2020-07-01 17:25:19 +00:00
|
|
|
if (ret > 0)
|
2022-04-27 11:53:42 +00:00
|
|
|
read += ret;
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
|
2022-05-05 11:32:23 +00:00
|
|
|
if (should_fault_in_pages(to, iocb, &prev_count, &window_size)) {
|
2022-05-11 16:27:12 +00:00
|
|
|
gfs2_glock_dq(&gh);
|
2022-05-05 10:37:49 +00:00
|
|
|
window_size -= fault_in_iov_iter_writeable(to, window_size);
|
2022-05-11 16:27:12 +00:00
|
|
|
if (window_size)
|
2022-03-17 13:20:38 +00:00
|
|
|
goto retry;
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
}
|
2022-05-05 10:53:26 +00:00
|
|
|
out_unlock:
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
if (gfs2_holder_queued(&gh))
|
|
|
|
gfs2_glock_dq(&gh);
|
2020-07-01 17:25:19 +00:00
|
|
|
out_uninit:
|
|
|
|
gfs2_holder_uninit(&gh);
|
2022-04-27 11:53:42 +00:00
|
|
|
return read ? read : ret;
|
2018-06-19 14:08:02 +00:00
|
|
|
}
|
|
|
|
|
2021-08-25 19:54:18 +00:00
|
|
|
static ssize_t gfs2_file_buffered_write(struct kiocb *iocb,
|
|
|
|
struct iov_iter *from,
|
|
|
|
struct gfs2_holder *gh)
|
2021-05-13 14:13:54 +00:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
|
|
|
struct inode *inode = file_inode(file);
|
2021-08-11 19:50:14 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2021-08-25 19:54:18 +00:00
|
|
|
struct gfs2_holder *statfs_gh = NULL;
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
size_t prev_count = 0, window_size = 0;
|
2021-11-09 12:57:17 +00:00
|
|
|
size_t orig_count = iov_iter_count(from);
|
2022-04-27 11:53:42 +00:00
|
|
|
size_t written = 0;
|
2021-05-13 14:13:54 +00:00
|
|
|
ssize_t ret;
|
|
|
|
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
/*
|
|
|
|
* In this function, we disable page faults when we're holding the
|
|
|
|
* inode glock while doing I/O. If a page fault occurs, we indicate
|
|
|
|
* that the inode glock may be dropped, fault in the pages manually,
|
|
|
|
* and retry.
|
|
|
|
*/
|
|
|
|
|
2021-08-25 19:54:18 +00:00
|
|
|
if (inode == sdp->sd_rindex) {
|
|
|
|
statfs_gh = kmalloc(sizeof(*statfs_gh), GFP_NOFS);
|
|
|
|
if (!statfs_gh)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, gh);
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
retry:
|
2022-05-04 21:37:30 +00:00
|
|
|
if (should_fault_in_pages(from, iocb, &prev_count, &window_size)) {
|
|
|
|
window_size -= fault_in_iov_iter_readable(from, window_size);
|
|
|
|
if (!window_size) {
|
|
|
|
ret = -EFAULT;
|
2022-05-11 16:27:12 +00:00
|
|
|
goto out_uninit;
|
2022-05-04 21:37:30 +00:00
|
|
|
}
|
|
|
|
from->count = min(from->count, window_size);
|
|
|
|
}
|
2022-05-11 16:27:12 +00:00
|
|
|
ret = gfs2_glock_nq(gh);
|
|
|
|
if (ret)
|
|
|
|
goto out_uninit;
|
2022-05-04 21:37:30 +00:00
|
|
|
|
2021-08-11 19:50:14 +00:00
|
|
|
if (inode == sdp->sd_rindex) {
|
|
|
|
struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
|
|
|
|
|
|
|
|
ret = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,
|
2021-08-25 19:54:18 +00:00
|
|
|
GL_NOCACHE, statfs_gh);
|
2021-08-11 19:50:14 +00:00
|
|
|
if (ret)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2021-05-13 14:13:54 +00:00
|
|
|
current->backing_dev_info = inode_to_bdi(inode);
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
pagefault_disable();
|
2021-05-13 14:13:54 +00:00
|
|
|
ret = iomap_file_buffered_write(iocb, from, &gfs2_iomap_ops);
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
pagefault_enable();
|
2021-05-13 14:13:54 +00:00
|
|
|
current->backing_dev_info = NULL;
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
if (ret > 0) {
|
2021-05-13 14:13:54 +00:00
|
|
|
iocb->ki_pos += ret;
|
2022-04-27 11:53:42 +00:00
|
|
|
written += ret;
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
}
|
2021-08-11 19:50:14 +00:00
|
|
|
|
2021-08-25 19:54:18 +00:00
|
|
|
if (inode == sdp->sd_rindex)
|
|
|
|
gfs2_glock_dq_uninit(statfs_gh);
|
2021-08-11 19:50:14 +00:00
|
|
|
|
2022-05-05 10:53:26 +00:00
|
|
|
if (ret <= 0 && ret != -EFAULT)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2022-04-27 11:53:42 +00:00
|
|
|
from->count = orig_count - written;
|
2022-05-11 16:27:12 +00:00
|
|
|
if (should_fault_in_pages(from, iocb, &prev_count, &window_size)) {
|
|
|
|
gfs2_glock_dq(gh);
|
|
|
|
goto retry;
|
|
|
|
}
|
2021-08-11 19:50:14 +00:00
|
|
|
out_unlock:
|
gfs2: Fix mmap + page fault deadlocks for buffered I/O
In the .read_iter and .write_iter file operations, we're accessing
user-space memory while holding the inode glock. There is a possibility
that the memory is mapped to the same file, in which case we'd recurse
on the same glock.
We could detect and work around this simple case of recursive locking,
but more complex scenarios exist that involve multiple glocks,
processes, and cluster nodes, and working around all of those cases
isn't practical or even possible.
Avoid these kinds of problems by disabling page faults while holding the
inode glock. If a page fault would occur, we either end up with a
partial read or write or with -EFAULT if nothing could be read or
written. In either case, we know that we're not done with the
operation, so we indicate that we're willing to give up the inode glock
and then we fault in the missing pages. If that made us lose the inode
glock, we return a partial read or write. Otherwise, we resume the
operation.
This locking problem was originally reported by Jan Kara. Linus came up
with the idea of disabling page faults. Many thanks to Al Viro and
Matthew Wilcox for their feedback.
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2021-10-18 17:21:44 +00:00
|
|
|
if (gfs2_holder_queued(gh))
|
|
|
|
gfs2_glock_dq(gh);
|
2021-08-11 19:50:14 +00:00
|
|
|
out_uninit:
|
2021-08-25 19:54:18 +00:00
|
|
|
gfs2_holder_uninit(gh);
|
|
|
|
if (statfs_gh)
|
|
|
|
kfree(statfs_gh);
|
2022-04-27 11:53:42 +00:00
|
|
|
from->count = orig_count - written;
|
|
|
|
return written ? written : ret;
|
2021-05-13 14:13:54 +00:00
|
|
|
}
|
|
|
|
|
2009-12-08 10:25:33 +00:00
|
|
|
/**
|
2014-04-03 18:11:01 +00:00
|
|
|
* gfs2_file_write_iter - Perform a write to a file
|
2009-12-08 10:25:33 +00:00
|
|
|
* @iocb: The io context
|
2018-06-24 14:04:04 +00:00
|
|
|
* @from: The data to write
|
2009-12-08 10:25:33 +00:00
|
|
|
*
|
|
|
|
* We have to do a lock/unlock here to refresh the inode size for
|
|
|
|
* O_APPEND writes, otherwise we can land up writing at the wrong
|
|
|
|
* offset. There is still a race, but provided the app is using its
|
|
|
|
* own file locking, this will make O_APPEND work as expected.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2014-04-03 18:11:01 +00:00
|
|
|
static ssize_t gfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
|
2009-12-08 10:25:33 +00:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
2018-06-24 14:04:04 +00:00
|
|
|
struct inode *inode = file_inode(file);
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2020-06-29 22:47:15 +00:00
|
|
|
struct gfs2_holder gh;
|
2020-01-14 16:12:18 +00:00
|
|
|
ssize_t ret;
|
2012-06-06 10:17:59 +00:00
|
|
|
|
2014-04-03 18:11:01 +00:00
|
|
|
gfs2_size_hint(file, iocb->ki_pos, iov_iter_count(from));
|
2012-07-26 10:30:54 +00:00
|
|
|
|
2015-04-09 17:52:01 +00:00
|
|
|
if (iocb->ki_flags & IOCB_APPEND) {
|
2009-12-08 10:25:33 +00:00
|
|
|
ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
|
|
|
|
if (ret)
|
2020-03-06 16:51:41 +00:00
|
|
|
return ret;
|
2009-12-08 10:25:33 +00:00
|
|
|
gfs2_glock_dq_uninit(&gh);
|
|
|
|
}
|
|
|
|
|
2018-06-24 14:04:04 +00:00
|
|
|
inode_lock(inode);
|
|
|
|
ret = generic_write_checks(iocb, from);
|
|
|
|
if (ret <= 0)
|
2020-01-15 15:38:29 +00:00
|
|
|
goto out_unlock;
|
2018-06-24 14:04:04 +00:00
|
|
|
|
|
|
|
ret = file_remove_privs(file);
|
|
|
|
if (ret)
|
2020-01-15 15:38:29 +00:00
|
|
|
goto out_unlock;
|
2018-06-24 14:04:04 +00:00
|
|
|
|
|
|
|
ret = file_update_time(file);
|
|
|
|
if (ret)
|
2020-01-15 15:38:29 +00:00
|
|
|
goto out_unlock;
|
2018-06-24 14:04:04 +00:00
|
|
|
|
2018-06-19 14:08:02 +00:00
|
|
|
if (iocb->ki_flags & IOCB_DIRECT) {
|
|
|
|
struct address_space *mapping = file->f_mapping;
|
2020-01-14 16:12:18 +00:00
|
|
|
ssize_t buffered, ret2;
|
2018-06-19 14:08:02 +00:00
|
|
|
|
2020-06-29 22:47:15 +00:00
|
|
|
ret = gfs2_file_direct_write(iocb, from, &gh);
|
2020-01-14 16:12:18 +00:00
|
|
|
if (ret < 0 || !iov_iter_count(from))
|
2020-01-15 15:38:29 +00:00
|
|
|
goto out_unlock;
|
2018-06-19 14:08:02 +00:00
|
|
|
|
2020-01-14 16:12:18 +00:00
|
|
|
iocb->ki_flags |= IOCB_DSYNC;
|
2021-08-25 19:54:18 +00:00
|
|
|
buffered = gfs2_file_buffered_write(iocb, from, &gh);
|
2021-05-10 10:25:59 +00:00
|
|
|
if (unlikely(buffered <= 0)) {
|
|
|
|
if (!ret)
|
|
|
|
ret = buffered;
|
2020-01-15 15:38:29 +00:00
|
|
|
goto out_unlock;
|
2021-05-10 10:25:59 +00:00
|
|
|
}
|
2018-06-19 14:08:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to ensure that the page cache pages are written to
|
|
|
|
* disk and invalidated to preserve the expected O_DIRECT
|
2020-01-14 16:12:18 +00:00
|
|
|
* semantics. If the writeback or invalidate fails, only report
|
|
|
|
* the direct I/O range as we don't know if the buffered pages
|
|
|
|
* made it to disk.
|
2018-06-19 14:08:02 +00:00
|
|
|
*/
|
2020-01-14 16:12:18 +00:00
|
|
|
ret2 = generic_write_sync(iocb, buffered);
|
|
|
|
invalidate_mapping_pages(mapping,
|
|
|
|
(iocb->ki_pos - buffered) >> PAGE_SHIFT,
|
|
|
|
(iocb->ki_pos - 1) >> PAGE_SHIFT);
|
|
|
|
if (!ret || ret2 > 0)
|
|
|
|
ret += ret2;
|
2018-06-19 14:08:02 +00:00
|
|
|
} else {
|
2021-08-25 19:54:18 +00:00
|
|
|
ret = gfs2_file_buffered_write(iocb, from, &gh);
|
2021-05-13 14:13:54 +00:00
|
|
|
if (likely(ret > 0))
|
2020-01-14 16:12:18 +00:00
|
|
|
ret = generic_write_sync(iocb, ret);
|
2018-06-19 14:08:02 +00:00
|
|
|
}
|
2018-06-24 14:04:04 +00:00
|
|
|
|
2020-01-15 15:38:29 +00:00
|
|
|
out_unlock:
|
2018-06-24 14:04:04 +00:00
|
|
|
inode_unlock(inode);
|
2020-01-14 16:12:18 +00:00
|
|
|
return ret;
|
2009-12-08 10:25:33 +00:00
|
|
|
}
|
|
|
|
|
2011-01-14 12:07:43 +00:00
|
|
|
static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,
|
|
|
|
int mode)
|
|
|
|
{
|
2018-03-29 13:50:32 +00:00
|
|
|
struct super_block *sb = inode->i_sb;
|
2011-01-14 12:07:43 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2018-03-29 13:50:32 +00:00
|
|
|
loff_t end = offset + len;
|
2011-01-14 12:07:43 +00:00
|
|
|
struct buffer_head *dibh;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (unlikely(error))
|
2011-09-12 23:15:24 +00:00
|
|
|
return error;
|
2011-01-14 12:07:43 +00:00
|
|
|
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, dibh);
|
2011-01-14 12:07:43 +00:00
|
|
|
|
|
|
|
if (gfs2_is_stuffed(ip)) {
|
2021-06-17 19:36:50 +00:00
|
|
|
error = gfs2_unstuff_dinode(ip);
|
2011-01-14 12:07:43 +00:00
|
|
|
if (unlikely(error))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-03-29 13:50:32 +00:00
|
|
|
while (offset < end) {
|
2018-07-06 22:05:41 +00:00
|
|
|
struct iomap iomap = { };
|
|
|
|
|
2021-03-27 20:56:40 +00:00
|
|
|
error = gfs2_iomap_alloc(inode, offset, end - offset, &iomap);
|
2018-03-29 13:50:32 +00:00
|
|
|
if (error)
|
2011-09-12 23:15:24 +00:00
|
|
|
goto out;
|
2018-03-29 13:50:32 +00:00
|
|
|
offset = iomap.offset + iomap.length;
|
2018-06-24 09:43:49 +00:00
|
|
|
if (!(iomap.flags & IOMAP_F_NEW))
|
2011-09-12 23:15:24 +00:00
|
|
|
continue;
|
2018-03-29 13:50:32 +00:00
|
|
|
error = sb_issue_zeroout(sb, iomap.addr >> inode->i_blkbits,
|
|
|
|
iomap.length >> inode->i_blkbits,
|
|
|
|
GFP_NOFS);
|
|
|
|
if (error) {
|
|
|
|
fs_err(GFS2_SB(inode), "Failed to zero data buffers\n");
|
2011-01-14 12:07:43 +00:00
|
|
|
goto out;
|
2011-09-12 23:15:24 +00:00
|
|
|
}
|
2011-01-14 12:07:43 +00:00
|
|
|
}
|
|
|
|
out:
|
2011-09-12 23:15:24 +00:00
|
|
|
brelse(dibh);
|
2011-01-14 12:07:43 +00:00
|
|
|
return error;
|
|
|
|
}
|
2019-08-31 20:29:12 +00:00
|
|
|
|
2015-03-18 17:05:15 +00:00
|
|
|
/**
|
|
|
|
* calc_max_reserv() - Reverse of write_calc_reserv. Given a number of
|
|
|
|
* blocks, determine how many bytes can be written.
|
|
|
|
* @ip: The inode in question.
|
|
|
|
* @len: Max cap of bytes. What we return in *len must be <= this.
|
|
|
|
* @data_blocks: Compute and return the number of data blocks needed
|
|
|
|
* @ind_blocks: Compute and return the number of indirect blocks needed
|
|
|
|
* @max_blocks: The total blocks available to work with.
|
|
|
|
*
|
|
|
|
* Returns: void, but @len, @data_blocks and @ind_blocks are filled in.
|
|
|
|
*/
|
|
|
|
static void calc_max_reserv(struct gfs2_inode *ip, loff_t *len,
|
|
|
|
unsigned int *data_blocks, unsigned int *ind_blocks,
|
|
|
|
unsigned int max_blocks)
|
2011-01-14 12:07:43 +00:00
|
|
|
{
|
2015-03-18 17:05:15 +00:00
|
|
|
loff_t max = *len;
|
2011-01-14 12:07:43 +00:00
|
|
|
const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
|
|
|
unsigned int tmp, max_data = max_blocks - 3 * (sdp->sd_max_height - 1);
|
|
|
|
|
|
|
|
for (tmp = max_data; tmp > sdp->sd_diptrs;) {
|
|
|
|
tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);
|
|
|
|
max_data -= tmp;
|
|
|
|
}
|
2015-03-18 17:05:15 +00:00
|
|
|
|
2011-01-14 12:07:43 +00:00
|
|
|
*data_blocks = max_data;
|
|
|
|
*ind_blocks = max_blocks - max_data;
|
|
|
|
*len = ((loff_t)max_data - 3) << sdp->sd_sb.sb_bsize_shift;
|
|
|
|
if (*len > max) {
|
|
|
|
*len = max;
|
|
|
|
gfs2_write_calc_reserv(ip, max, data_blocks, ind_blocks);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-12 17:24:03 +00:00
|
|
|
static long __gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
|
2011-01-14 12:07:43 +00:00
|
|
|
{
|
2013-01-23 22:07:38 +00:00
|
|
|
struct inode *inode = file_inode(file);
|
2011-01-14 12:07:43 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2013-10-02 10:13:25 +00:00
|
|
|
struct gfs2_alloc_parms ap = { .aflags = 0, };
|
2011-01-14 12:07:43 +00:00
|
|
|
unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
|
2018-02-20 15:03:24 +00:00
|
|
|
loff_t bytes, max_bytes, max_blks;
|
2011-01-14 12:07:43 +00:00
|
|
|
int error;
|
2011-11-21 10:01:25 +00:00
|
|
|
const loff_t pos = offset;
|
|
|
|
const loff_t count = len;
|
2011-04-26 06:13:24 +00:00
|
|
|
loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1);
|
2011-01-14 12:07:43 +00:00
|
|
|
loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift;
|
2011-09-12 23:15:24 +00:00
|
|
|
loff_t max_chunk_size = UINT_MAX & bsize_mask;
|
2014-02-06 15:43:50 +00:00
|
|
|
|
2011-01-14 12:07:43 +00:00
|
|
|
next = (next + 1) << sdp->sd_sb.sb_bsize_shift;
|
|
|
|
|
2011-04-26 06:13:24 +00:00
|
|
|
offset &= bsize_mask;
|
2011-01-14 12:07:43 +00:00
|
|
|
|
|
|
|
len = next - offset;
|
|
|
|
bytes = sdp->sd_max_rg_data * sdp->sd_sb.sb_bsize / 2;
|
|
|
|
if (!bytes)
|
|
|
|
bytes = UINT_MAX;
|
2011-04-26 06:13:24 +00:00
|
|
|
bytes &= bsize_mask;
|
|
|
|
if (bytes == 0)
|
|
|
|
bytes = sdp->sd_sb.sb_bsize;
|
2011-01-14 12:07:43 +00:00
|
|
|
|
2012-07-26 10:30:54 +00:00
|
|
|
gfs2_size_hint(file, offset, len);
|
2012-07-19 12:12:40 +00:00
|
|
|
|
2015-03-18 17:05:15 +00:00
|
|
|
gfs2_write_calc_reserv(ip, PAGE_SIZE, &data_blocks, &ind_blocks);
|
|
|
|
ap.min_target = data_blocks + ind_blocks;
|
|
|
|
|
2011-01-14 12:07:43 +00:00
|
|
|
while (len > 0) {
|
|
|
|
if (len < bytes)
|
|
|
|
bytes = len;
|
2012-03-08 19:16:32 +00:00
|
|
|
if (!gfs2_write_alloc_required(ip, offset, bytes)) {
|
|
|
|
len -= bytes;
|
|
|
|
offset += bytes;
|
|
|
|
continue;
|
|
|
|
}
|
2015-03-18 17:05:15 +00:00
|
|
|
|
|
|
|
/* We need to determine how many bytes we can actually
|
|
|
|
* fallocate without exceeding quota or going over the
|
|
|
|
* end of the fs. We start off optimistically by assuming
|
|
|
|
* we can write max_bytes */
|
|
|
|
max_bytes = (len > max_chunk_size) ? max_chunk_size : len;
|
|
|
|
|
|
|
|
/* Since max_bytes is most likely a theoretical max, we
|
|
|
|
* calculate a more realistic 'bytes' to serve as a good
|
|
|
|
* starting point for the number of bytes we may be able
|
|
|
|
* to write */
|
2011-01-14 12:07:43 +00:00
|
|
|
gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks);
|
2013-10-02 10:13:25 +00:00
|
|
|
ap.target = data_blocks + ind_blocks;
|
2015-03-18 17:03:41 +00:00
|
|
|
|
|
|
|
error = gfs2_quota_lock_check(ip, &ap);
|
2011-01-14 12:07:43 +00:00
|
|
|
if (error)
|
2014-11-12 17:24:03 +00:00
|
|
|
return error;
|
2015-03-18 17:05:15 +00:00
|
|
|
/* ap.allowed tells us how many blocks quota will allow
|
|
|
|
* us to write. Check if this reduces max_blks */
|
2018-02-20 15:03:24 +00:00
|
|
|
max_blks = UINT_MAX;
|
|
|
|
if (ap.allowed)
|
2015-03-18 17:05:15 +00:00
|
|
|
max_blks = ap.allowed;
|
2011-01-14 12:07:43 +00:00
|
|
|
|
2013-10-02 10:13:25 +00:00
|
|
|
error = gfs2_inplace_reserve(ip, &ap);
|
2015-03-18 17:05:15 +00:00
|
|
|
if (error)
|
2011-01-14 12:07:43 +00:00
|
|
|
goto out_qunlock;
|
2015-03-18 17:05:15 +00:00
|
|
|
|
|
|
|
/* check if the selected rgrp limits our max_blks further */
|
2018-10-02 13:59:54 +00:00
|
|
|
if (ip->i_res.rs_reserved < max_blks)
|
|
|
|
max_blks = ip->i_res.rs_reserved;
|
2015-03-18 17:05:15 +00:00
|
|
|
|
|
|
|
/* Almost done. Calculate bytes that can be written using
|
|
|
|
* max_blks. We also recompute max_bytes, data_blocks and
|
|
|
|
* ind_blocks */
|
|
|
|
calc_max_reserv(ip, &max_bytes, &data_blocks,
|
|
|
|
&ind_blocks, max_blks);
|
2011-01-14 12:07:43 +00:00
|
|
|
|
|
|
|
rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA +
|
2012-07-30 13:53:19 +00:00
|
|
|
RES_RG_HDR + gfs2_rg_blocks(ip, data_blocks + ind_blocks);
|
2011-01-14 12:07:43 +00:00
|
|
|
if (gfs2_is_jdata(ip))
|
|
|
|
rblocks += data_blocks ? data_blocks : 1;
|
|
|
|
|
|
|
|
error = gfs2_trans_begin(sdp, rblocks,
|
2019-09-02 16:31:06 +00:00
|
|
|
PAGE_SIZE >> inode->i_blkbits);
|
2011-01-14 12:07:43 +00:00
|
|
|
if (error)
|
|
|
|
goto out_trans_fail;
|
|
|
|
|
|
|
|
error = fallocate_chunk(inode, offset, max_bytes, mode);
|
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
goto out_trans_fail;
|
|
|
|
|
|
|
|
len -= max_bytes;
|
|
|
|
offset += max_bytes;
|
|
|
|
gfs2_inplace_release(ip);
|
|
|
|
gfs2_quota_unlock(ip);
|
|
|
|
}
|
2011-11-21 10:01:25 +00:00
|
|
|
|
2019-08-08 18:29:54 +00:00
|
|
|
if (!(mode & FALLOC_FL_KEEP_SIZE) && (pos + count) > inode->i_size)
|
2014-11-12 17:24:04 +00:00
|
|
|
i_size_write(inode, pos + count);
|
2019-08-08 18:29:54 +00:00
|
|
|
file_update_time(file);
|
|
|
|
mark_inode_dirty(inode);
|
2014-11-12 17:24:04 +00:00
|
|
|
|
2016-04-07 15:52:00 +00:00
|
|
|
if ((file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host))
|
|
|
|
return vfs_fsync_range(file, pos, pos + count - 1,
|
|
|
|
(file->f_flags & __O_SYNC) ? 0 : 1);
|
|
|
|
return 0;
|
2011-01-14 12:07:43 +00:00
|
|
|
|
|
|
|
out_trans_fail:
|
|
|
|
gfs2_inplace_release(ip);
|
|
|
|
out_qunlock:
|
|
|
|
gfs2_quota_unlock(ip);
|
2014-11-12 17:24:03 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static long gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
|
|
|
|
{
|
|
|
|
struct inode *inode = file_inode(file);
|
2017-04-05 15:45:26 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2014-11-12 17:24:03 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_holder gh;
|
|
|
|
int ret;
|
|
|
|
|
2017-12-14 16:11:03 +00:00
|
|
|
if (mode & ~(FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE))
|
2017-04-05 15:45:26 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
/* fallocate is needed by gfs2_grow to reserve space in the rindex */
|
|
|
|
if (gfs2_is_jdata(ip) && inode != sdp->sd_rindex)
|
2014-11-12 17:24:03 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_lock(inode);
|
2014-11-12 17:24:03 +00:00
|
|
|
|
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
|
|
|
|
ret = gfs2_glock_nq(&gh);
|
|
|
|
if (ret)
|
|
|
|
goto out_uninit;
|
|
|
|
|
|
|
|
if (!(mode & FALLOC_FL_KEEP_SIZE) &&
|
|
|
|
(offset + len) > inode->i_size) {
|
|
|
|
ret = inode_newsize_ok(inode, offset + len);
|
|
|
|
if (ret)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = get_write_access(inode);
|
|
|
|
if (ret)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2017-12-14 16:11:03 +00:00
|
|
|
if (mode & FALLOC_FL_PUNCH_HOLE) {
|
|
|
|
ret = __gfs2_punch_hole(file, offset, len);
|
|
|
|
} else {
|
|
|
|
ret = __gfs2_fallocate(file, mode, offset, len);
|
|
|
|
if (ret)
|
|
|
|
gfs2_rs_deltree(&ip->i_res);
|
|
|
|
}
|
2015-07-16 13:28:04 +00:00
|
|
|
|
2014-11-12 17:24:03 +00:00
|
|
|
put_write_access(inode);
|
2011-01-14 12:07:43 +00:00
|
|
|
out_unlock:
|
2014-02-06 15:43:50 +00:00
|
|
|
gfs2_glock_dq(&gh);
|
2011-01-14 12:07:43 +00:00
|
|
|
out_uninit:
|
2014-02-06 15:43:50 +00:00
|
|
|
gfs2_holder_uninit(&gh);
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_unlock(inode);
|
2014-11-12 17:24:03 +00:00
|
|
|
return ret;
|
2011-01-14 12:07:43 +00:00
|
|
|
}
|
|
|
|
|
2015-02-24 13:22:28 +00:00
|
|
|
static ssize_t gfs2_file_splice_write(struct pipe_inode_info *pipe,
|
|
|
|
struct file *out, loff_t *ppos,
|
|
|
|
size_t len, unsigned int flags)
|
|
|
|
{
|
2020-02-27 18:47:53 +00:00
|
|
|
ssize_t ret;
|
2015-02-24 13:22:28 +00:00
|
|
|
|
|
|
|
gfs2_size_hint(out, *ppos, len);
|
|
|
|
|
2020-02-27 18:47:53 +00:00
|
|
|
ret = iter_file_splice_write(pipe, out, ppos, len, flags);
|
|
|
|
return ret;
|
2015-02-24 13:22:28 +00:00
|
|
|
}
|
|
|
|
|
2009-01-12 10:43:39 +00:00
|
|
|
#ifdef CONFIG_GFS2_FS_LOCKING_DLM
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/**
|
|
|
|
* gfs2_lock - acquire/release a posix lock on a file
|
|
|
|
* @file: the file pointer
|
|
|
|
* @cmd: either modify or retrieve lock state, possibly wait
|
|
|
|
* @fl: type and range of lock
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
|
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
|
2009-01-12 10:43:39 +00:00
|
|
|
struct lm_lockstruct *ls = &sdp->sd_lockstruct;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (!(fl->fl_flags & FL_POSIX))
|
|
|
|
return -ENOLCK;
|
2006-11-14 21:37:25 +00:00
|
|
|
if (cmd == F_CANCELLK) {
|
|
|
|
/* Hack: */
|
|
|
|
cmd = F_SETLK;
|
|
|
|
fl->fl_type = F_UNLCK;
|
|
|
|
}
|
2019-11-14 14:52:15 +00:00
|
|
|
if (unlikely(gfs2_withdrawn(sdp))) {
|
2013-03-14 15:49:59 +00:00
|
|
|
if (fl->fl_type == F_UNLCK)
|
2015-10-22 17:38:14 +00:00
|
|
|
locks_lock_file_wait(file, fl);
|
2009-01-12 10:43:39 +00:00
|
|
|
return -EIO;
|
2013-03-14 15:49:59 +00:00
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
if (IS_GETLK(cmd))
|
2009-01-12 10:43:39 +00:00
|
|
|
return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl);
|
2006-01-16 16:50:04 +00:00
|
|
|
else if (fl->fl_type == F_UNLCK)
|
2009-01-12 10:43:39 +00:00
|
|
|
return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl);
|
2006-01-16 16:50:04 +00:00
|
|
|
else
|
2009-01-12 10:43:39 +00:00
|
|
|
return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int do_flock(struct file *file, int cmd, struct file_lock *fl)
|
|
|
|
{
|
2006-02-27 22:23:27 +00:00
|
|
|
struct gfs2_file *fp = file->private_data;
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_holder *fl_gh = &fp->f_fl_gh;
|
2013-01-23 22:07:38 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(file_inode(file));
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_glock *gl;
|
|
|
|
unsigned int state;
|
2015-07-24 14:45:43 +00:00
|
|
|
u16 flags;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error = 0;
|
2014-08-20 16:44:45 +00:00
|
|
|
int sleeptime;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
|
2014-08-20 16:44:45 +00:00
|
|
|
flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY_1CB) | GL_EXACT;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_lock(&fp->f_fl_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2017-07-17 18:39:15 +00:00
|
|
|
if (gfs2_holder_initialized(fl_gh)) {
|
2018-11-29 23:04:08 +00:00
|
|
|
struct file_lock request;
|
2006-01-16 16:50:04 +00:00
|
|
|
if (fl_gh->gh_state == state)
|
|
|
|
goto out;
|
2018-11-29 23:04:08 +00:00
|
|
|
locks_init_lock(&request);
|
|
|
|
request.fl_type = F_UNLCK;
|
|
|
|
request.fl_flags = FL_FLOCK;
|
|
|
|
locks_lock_file_wait(file, &request);
|
2014-06-26 14:46:25 +00:00
|
|
|
gfs2_glock_dq(fl_gh);
|
2007-09-14 04:35:27 +00:00
|
|
|
gfs2_holder_reinit(state, flags, fl_gh);
|
2006-01-16 16:50:04 +00:00
|
|
|
} else {
|
2008-05-21 16:03:22 +00:00
|
|
|
error = gfs2_glock_get(GFS2_SB(&ip->i_inode), ip->i_no_addr,
|
|
|
|
&gfs2_flock_glops, CREATE, &gl);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2007-09-14 04:35:27 +00:00
|
|
|
gfs2_holder_init(gl, state, flags, fl_gh);
|
|
|
|
gfs2_glock_put(gl);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
2014-08-20 16:44:45 +00:00
|
|
|
for (sleeptime = 1; sleeptime <= 4; sleeptime <<= 1) {
|
|
|
|
error = gfs2_glock_nq(fl_gh);
|
|
|
|
if (error != GLR_TRYFAILED)
|
|
|
|
break;
|
|
|
|
fl_gh->gh_flags = LM_FLAG_TRY | GL_EXACT;
|
|
|
|
msleep(sleeptime);
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error) {
|
|
|
|
gfs2_holder_uninit(fl_gh);
|
|
|
|
if (error == GLR_TRYFAILED)
|
|
|
|
error = -EAGAIN;
|
|
|
|
} else {
|
2015-10-22 17:38:14 +00:00
|
|
|
error = locks_lock_file_wait(file, fl);
|
2006-06-14 19:32:57 +00:00
|
|
|
gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:42:17 +00:00
|
|
|
out:
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_unlock(&fp->f_fl_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void do_unflock(struct file *file, struct file_lock *fl)
|
|
|
|
{
|
2006-02-27 22:23:27 +00:00
|
|
|
struct gfs2_file *fp = file->private_data;
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_holder *fl_gh = &fp->f_fl_gh;
|
|
|
|
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_lock(&fp->f_fl_mutex);
|
2015-10-22 17:38:14 +00:00
|
|
|
locks_lock_file_wait(file, fl);
|
2016-06-17 12:31:27 +00:00
|
|
|
if (gfs2_holder_initialized(fl_gh)) {
|
2014-08-20 16:44:45 +00:00
|
|
|
gfs2_glock_dq(fl_gh);
|
2011-03-09 11:14:32 +00:00
|
|
|
gfs2_holder_uninit(fl_gh);
|
|
|
|
}
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_unlock(&fp->f_fl_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_flock - acquire/release a flock lock on a file
|
|
|
|
* @file: the file pointer
|
|
|
|
* @cmd: either modify or retrieve lock state, possibly wait
|
|
|
|
* @fl: type and range of lock
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
|
|
|
|
{
|
|
|
|
if (!(fl->fl_flags & FL_FLOCK))
|
|
|
|
return -ENOLCK;
|
|
|
|
|
|
|
|
if (fl->fl_type == F_UNLCK) {
|
|
|
|
do_unflock(file, fl);
|
|
|
|
return 0;
|
2006-10-02 14:28:05 +00:00
|
|
|
} else {
|
2006-01-16 16:50:04 +00:00
|
|
|
return do_flock(file, cmd, fl);
|
2006-10-02 14:28:05 +00:00
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2009-04-07 17:42:17 +00:00
|
|
|
const struct file_operations gfs2_file_fops = {
|
2006-09-04 19:32:10 +00:00
|
|
|
.llseek = gfs2_llseek,
|
2018-06-19 14:08:02 +00:00
|
|
|
.read_iter = gfs2_file_read_iter,
|
2014-04-03 18:11:01 +00:00
|
|
|
.write_iter = gfs2_file_write_iter,
|
2021-10-12 11:12:24 +00:00
|
|
|
.iopoll = iocb_bio_iopoll,
|
2006-09-04 19:32:10 +00:00
|
|
|
.unlocked_ioctl = gfs2_ioctl,
|
2019-06-03 11:40:01 +00:00
|
|
|
.compat_ioctl = gfs2_compat_ioctl,
|
2006-09-04 19:32:10 +00:00
|
|
|
.mmap = gfs2_mmap,
|
|
|
|
.open = gfs2_open,
|
2012-04-11 16:56:41 +00:00
|
|
|
.release = gfs2_release,
|
2006-09-04 19:32:10 +00:00
|
|
|
.fsync = gfs2_fsync,
|
|
|
|
.lock = gfs2_lock,
|
|
|
|
.flock = gfs2_flock,
|
2016-09-23 03:35:42 +00:00
|
|
|
.splice_read = generic_file_splice_read,
|
2015-02-19 14:02:16 +00:00
|
|
|
.splice_write = gfs2_file_splice_write,
|
2014-08-27 10:49:41 +00:00
|
|
|
.setlease = simple_nosetlease,
|
2011-01-14 12:07:43 +00:00
|
|
|
.fallocate = gfs2_fallocate,
|
2006-01-16 16:50:04 +00:00
|
|
|
};
|
|
|
|
|
2009-04-07 17:42:17 +00:00
|
|
|
const struct file_operations gfs2_dir_fops = {
|
2016-05-12 21:00:20 +00:00
|
|
|
.iterate_shared = gfs2_readdir,
|
2006-09-04 19:32:10 +00:00
|
|
|
.unlocked_ioctl = gfs2_ioctl,
|
2019-06-03 11:40:01 +00:00
|
|
|
.compat_ioctl = gfs2_compat_ioctl,
|
2006-09-04 19:32:10 +00:00
|
|
|
.open = gfs2_open,
|
2012-04-11 16:56:41 +00:00
|
|
|
.release = gfs2_release,
|
2006-09-04 19:32:10 +00:00
|
|
|
.fsync = gfs2_fsync,
|
|
|
|
.lock = gfs2_lock,
|
|
|
|
.flock = gfs2_flock,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 16:52:59 +00:00
|
|
|
.llseek = default_llseek,
|
2006-01-16 16:50:04 +00:00
|
|
|
};
|
|
|
|
|
2009-01-12 10:43:39 +00:00
|
|
|
#endif /* CONFIG_GFS2_FS_LOCKING_DLM */
|
|
|
|
|
2009-04-07 17:42:17 +00:00
|
|
|
const struct file_operations gfs2_file_fops_nolock = {
|
2007-11-29 22:56:51 +00:00
|
|
|
.llseek = gfs2_llseek,
|
2018-06-19 14:08:02 +00:00
|
|
|
.read_iter = gfs2_file_read_iter,
|
2014-04-03 18:11:01 +00:00
|
|
|
.write_iter = gfs2_file_write_iter,
|
2021-10-12 11:12:24 +00:00
|
|
|
.iopoll = iocb_bio_iopoll,
|
2007-11-29 22:56:51 +00:00
|
|
|
.unlocked_ioctl = gfs2_ioctl,
|
2019-06-03 11:40:01 +00:00
|
|
|
.compat_ioctl = gfs2_compat_ioctl,
|
2007-11-29 22:56:51 +00:00
|
|
|
.mmap = gfs2_mmap,
|
|
|
|
.open = gfs2_open,
|
2012-04-11 16:56:41 +00:00
|
|
|
.release = gfs2_release,
|
2007-11-29 22:56:51 +00:00
|
|
|
.fsync = gfs2_fsync,
|
2016-09-23 03:35:42 +00:00
|
|
|
.splice_read = generic_file_splice_read,
|
2015-02-19 14:02:16 +00:00
|
|
|
.splice_write = gfs2_file_splice_write,
|
2009-01-12 10:43:39 +00:00
|
|
|
.setlease = generic_setlease,
|
2011-01-14 12:07:43 +00:00
|
|
|
.fallocate = gfs2_fallocate,
|
2007-11-29 22:56:51 +00:00
|
|
|
};
|
|
|
|
|
2009-04-07 17:42:17 +00:00
|
|
|
const struct file_operations gfs2_dir_fops_nolock = {
|
2016-05-12 21:00:20 +00:00
|
|
|
.iterate_shared = gfs2_readdir,
|
2007-11-29 22:56:51 +00:00
|
|
|
.unlocked_ioctl = gfs2_ioctl,
|
2019-06-03 11:40:01 +00:00
|
|
|
.compat_ioctl = gfs2_compat_ioctl,
|
2007-11-29 22:56:51 +00:00
|
|
|
.open = gfs2_open,
|
2012-04-11 16:56:41 +00:00
|
|
|
.release = gfs2_release,
|
2007-11-29 22:56:51 +00:00
|
|
|
.fsync = gfs2_fsync,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 16:52:59 +00:00
|
|
|
.llseek = default_llseek,
|
2007-11-29 22:56:51 +00:00
|
|
|
};
|
|
|
|
|