2006-01-16 17:50:04 +01:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2006-05-18 21:09:15 +02:00
|
|
|
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
|
2006-01-16 17:50:04 +01:00
|
|
|
*
|
|
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
2006-09-01 17:05:15 +02:00
|
|
|
* of the GNU General Public License version 2.
|
2006-01-16 17:50:04 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#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 21:12:01 +02:00
|
|
|
#include <linux/mount.h>
|
2006-02-08 12:50:51 +01:00
|
|
|
#include <linux/fs.h>
|
2006-02-27 23:23:27 +01:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2006-03-28 21:14:04 +02:00
|
|
|
#include <linux/ext2_fs.h>
|
2011-01-14 13:07:43 +01:00
|
|
|
#include <linux/falloc.h>
|
|
|
|
#include <linux/swap.h>
|
2006-03-28 21:14:04 +02:00
|
|
|
#include <linux/crc32.h>
|
2006-11-30 16:14:32 +01:00
|
|
|
#include <linux/writeback.h>
|
2006-01-16 17:50:04 +01:00
|
|
|
#include <asm/uaccess.h>
|
2009-01-12 11:43:39 +01:00
|
|
|
#include <linux/dlm.h>
|
|
|
|
#include <linux/dlm_plock.h>
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-27 23:23:27 +01:00
|
|
|
#include "incore.h"
|
2006-01-16 17:50:04 +01:00
|
|
|
#include "bmap.h"
|
|
|
|
#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 23:23:27 +01:00
|
|
|
#include "util.h"
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_llseek - seek to a location in a file
|
|
|
|
* @file: the file
|
|
|
|
* @offset: the offset
|
|
|
|
* @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
|
|
|
|
*
|
|
|
|
* SEEK_END requires the glock for the file because it references the
|
|
|
|
* file's size.
|
|
|
|
*
|
|
|
|
* Returns: The new offset, or errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
|
|
|
|
{
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
|
2006-01-16 17:50:04 +01:00
|
|
|
struct gfs2_holder i_gh;
|
|
|
|
loff_t error;
|
|
|
|
|
2011-08-23 11:19:25 +02:00
|
|
|
switch (origin) {
|
|
|
|
case SEEK_END: /* These reference inode->i_size */
|
|
|
|
case SEEK_DATA:
|
|
|
|
case SEEK_HOLE:
|
2006-01-16 17:50:04 +01:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
|
|
|
|
&i_gh);
|
|
|
|
if (!error) {
|
2011-09-16 01:06:48 +02:00
|
|
|
error = generic_file_llseek(file, offset, origin);
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
|
|
|
}
|
2011-08-23 11:19:25 +02:00
|
|
|
break;
|
|
|
|
case SEEK_CUR:
|
|
|
|
case SEEK_SET:
|
2011-09-16 01:06:48 +02:00
|
|
|
error = generic_file_llseek(file, offset, origin);
|
2011-08-23 11:19:25 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error = -EINVAL;
|
|
|
|
}
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-09-19 22:41:11 +02:00
|
|
|
* gfs2_readdir - Read directory entries from a directory
|
2006-01-16 17:50:04 +01:00
|
|
|
* @file: The directory to read from
|
|
|
|
* @dirent: Buffer for dirents
|
|
|
|
* @filldir: Function used to do the copying
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2006-09-19 22:41:11 +02:00
|
|
|
static int gfs2_readdir(struct file *file, void *dirent, filldir_t filldir)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
2006-03-28 21:14:04 +02:00
|
|
|
struct inode *dir = file->f_mapping->host;
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_inode *dip = GFS2_I(dir);
|
2006-01-16 17:50:04 +01:00
|
|
|
struct gfs2_holder d_gh;
|
2006-09-04 18:49:07 +02:00
|
|
|
u64 offset = file->f_pos;
|
2006-01-16 17:50:04 +01:00
|
|
|
int error;
|
|
|
|
|
2008-09-18 14:53:59 +02:00
|
|
|
gfs2_holder_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
|
|
|
|
error = gfs2_glock_nq(&d_gh);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error) {
|
|
|
|
gfs2_holder_uninit(&d_gh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-01-17 16:09:20 +01:00
|
|
|
error = gfs2_dir_read(dir, &offset, dirent, filldir);
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
gfs2_glock_dq_uninit(&d_gh);
|
|
|
|
|
|
|
|
file->f_pos = offset;
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-10-02 17:24:43 +02:00
|
|
|
/**
|
|
|
|
* fsflags_cvt
|
|
|
|
* @table: A table of 32 u32 flags
|
|
|
|
* @val: a 32 bit value to convert
|
|
|
|
*
|
|
|
|
* This function can be used to convert between fsflags values and
|
|
|
|
* GFS2's own flags values.
|
|
|
|
*
|
|
|
|
* Returns: the converted flags
|
|
|
|
*/
|
|
|
|
static u32 fsflags_cvt(const u32 *table, u32 val)
|
|
|
|
{
|
|
|
|
u32 res = 0;
|
|
|
|
while(val) {
|
|
|
|
if (val & 1)
|
|
|
|
res |= *table;
|
|
|
|
table++;
|
|
|
|
val >>= 1;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-10-02 17:24:43 +02:00
|
|
|
static const u32 fsflags_to_gfs2[32] = {
|
|
|
|
[3] = GFS2_DIF_SYNC,
|
|
|
|
[4] = GFS2_DIF_IMMUTABLE,
|
|
|
|
[5] = GFS2_DIF_APPENDONLY,
|
|
|
|
[7] = GFS2_DIF_NOATIME,
|
|
|
|
[12] = GFS2_DIF_EXHASH,
|
2007-07-18 12:40:06 +02:00
|
|
|
[14] = GFS2_DIF_INHERIT_JDATA,
|
2006-03-28 21:14:04 +02:00
|
|
|
};
|
|
|
|
|
2006-10-02 17:24:43 +02:00
|
|
|
static const u32 gfs2_to_fsflags[32] = {
|
|
|
|
[gfs2fl_Sync] = FS_SYNC_FL,
|
|
|
|
[gfs2fl_Immutable] = FS_IMMUTABLE_FL,
|
|
|
|
[gfs2fl_AppendOnly] = FS_APPEND_FL,
|
|
|
|
[gfs2fl_NoAtime] = FS_NOATIME_FL,
|
|
|
|
[gfs2fl_ExHash] = FS_INDEX_FL,
|
|
|
|
[gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL,
|
2006-03-31 22:01:28 +02:00
|
|
|
};
|
2006-03-28 21:14:04 +02:00
|
|
|
|
2006-04-07 17:17:32 +02:00
|
|
|
static int gfs2_get_flags(struct file *filp, u32 __user *ptr)
|
2006-03-28 21:14:04 +02:00
|
|
|
{
|
2006-12-08 11:37:03 +01:00
|
|
|
struct inode *inode = filp->f_path.dentry->d_inode;
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2006-03-28 21:14:04 +02:00
|
|
|
struct gfs2_holder gh;
|
|
|
|
int error;
|
2006-10-02 17:24:43 +02:00
|
|
|
u32 fsflags;
|
2006-03-28 21:14:04 +02:00
|
|
|
|
2008-09-18 14:53:59 +02:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
|
|
|
|
error = gfs2_glock_nq(&gh);
|
2006-03-28 21:14:04 +02:00
|
|
|
if (error)
|
|
|
|
return error;
|
2006-09-25 15:26:04 +02:00
|
|
|
|
2008-11-04 11:05:22 +01:00
|
|
|
fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_diskflags);
|
|
|
|
if (!S_ISDIR(inode->i_mode) && ip->i_diskflags & GFS2_DIF_JDATA)
|
2008-07-10 17:09:29 +02:00
|
|
|
fsflags |= FS_JOURNAL_DATA_FL;
|
2006-10-02 17:24:43 +02:00
|
|
|
if (put_user(fsflags, ptr))
|
2006-03-28 21:14:04 +02:00
|
|
|
error = -EFAULT;
|
|
|
|
|
2007-10-15 16:40:33 +02:00
|
|
|
gfs2_glock_dq(&gh);
|
2006-03-28 21:14:04 +02:00
|
|
|
gfs2_holder_uninit(&gh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-11-08 18:51:06 +01: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 15:06:55 +02:00
|
|
|
flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_NOSEC);
|
|
|
|
if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode))
|
|
|
|
inode->i_flags |= S_NOSEC;
|
2008-11-04 11:05:22 +01:00
|
|
|
if (ip->i_diskflags & GFS2_DIF_IMMUTABLE)
|
2006-11-08 18:51:06 +01:00
|
|
|
flags |= S_IMMUTABLE;
|
2008-11-04 11:05:22 +01:00
|
|
|
if (ip->i_diskflags & GFS2_DIF_APPENDONLY)
|
2006-11-08 18:51:06 +01:00
|
|
|
flags |= S_APPEND;
|
2008-11-04 11:05:22 +01:00
|
|
|
if (ip->i_diskflags & GFS2_DIF_NOATIME)
|
2006-11-08 18:51:06 +01:00
|
|
|
flags |= S_NOATIME;
|
2008-11-04 11:05:22 +01:00
|
|
|
if (ip->i_diskflags & GFS2_DIF_SYNC)
|
2006-11-08 18:51:06 +01:00
|
|
|
flags |= S_SYNC;
|
|
|
|
inode->i_flags = flags;
|
|
|
|
}
|
|
|
|
|
2006-03-28 21:14:04 +02: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| \
|
|
|
|
GFS2_DIF_SYSTEM| \
|
|
|
|
GFS2_DIF_INHERIT_JDATA)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_set_flags - set flags on an inode
|
|
|
|
* @inode: The inode
|
|
|
|
* @flags: The flags to set
|
|
|
|
* @mask: Indicates which flags are valid
|
|
|
|
*
|
|
|
|
*/
|
2006-04-07 17:17:32 +02:00
|
|
|
static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
|
2006-03-28 21:14:04 +02:00
|
|
|
{
|
2006-12-08 11:37:03 +01:00
|
|
|
struct inode *inode = filp->f_path.dentry->d_inode;
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
2006-03-28 21:14:04 +02:00
|
|
|
struct buffer_head *bh;
|
|
|
|
struct gfs2_holder gh;
|
|
|
|
int error;
|
2006-04-04 20:29:30 +02:00
|
|
|
u32 new_flags, flags;
|
2006-03-28 21:14:04 +02:00
|
|
|
|
2008-07-02 21:12:01 +02:00
|
|
|
error = mnt_want_write(filp->f_path.mnt);
|
2006-07-21 08:03:21 +02:00
|
|
|
if (error)
|
2006-03-28 21:14:04 +02:00
|
|
|
return error;
|
|
|
|
|
2008-07-02 21:12:01 +02:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
|
|
|
|
if (error)
|
|
|
|
goto out_drop_write;
|
|
|
|
|
2010-05-24 15:36:48 +02:00
|
|
|
error = -EACCES;
|
2011-03-24 00:43:26 +01:00
|
|
|
if (!inode_owner_or_capable(inode))
|
2010-05-24 15:36:48 +02:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
error = 0;
|
2008-11-04 11:05:22 +01:00
|
|
|
flags = ip->i_diskflags;
|
2006-04-04 20:29:30 +02:00
|
|
|
new_flags = (flags & ~mask) | (reqflags & mask);
|
2006-03-28 21:14:04 +02:00
|
|
|
if ((new_flags ^ flags) == 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
error = -EINVAL;
|
|
|
|
if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
error = -EPERM;
|
|
|
|
if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE))
|
|
|
|
goto out;
|
|
|
|
if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY))
|
|
|
|
goto out;
|
2006-09-25 15:26:04 +02:00
|
|
|
if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
|
2006-05-12 23:07:56 +02:00
|
|
|
!capable(CAP_LINUX_IMMUTABLE))
|
2006-03-28 21:14:04 +02:00
|
|
|
goto out;
|
2006-05-12 23:07:56 +02:00
|
|
|
if (!IS_IMMUTABLE(inode)) {
|
2011-06-21 01:28:19 +02:00
|
|
|
error = gfs2_permission(inode, MAY_WRITE);
|
2006-05-12 23:07:56 +02:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
}
|
2007-10-17 09:47:38 +02:00
|
|
|
if ((flags ^ new_flags) & GFS2_DIF_JDATA) {
|
|
|
|
if (flags & GFS2_DIF_JDATA)
|
|
|
|
gfs2_log_flush(sdp, ip->i_gl);
|
|
|
|
error = filemap_fdatawrite(inode->i_mapping);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
error = filemap_fdatawait(inode->i_mapping);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
}
|
2006-04-04 20:29:30 +02:00
|
|
|
error = gfs2_trans_begin(sdp, RES_DINODE, 0);
|
2006-03-28 21:14:04 +02:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2006-04-04 20:29:30 +02:00
|
|
|
error = gfs2_meta_inode_buffer(ip, &bh);
|
|
|
|
if (error)
|
|
|
|
goto out_trans_end;
|
2006-03-28 21:14:04 +02:00
|
|
|
gfs2_trans_add_bh(ip->i_gl, bh, 1);
|
2008-11-04 11:05:22 +01:00
|
|
|
ip->i_diskflags = new_flags;
|
2006-10-31 21:07:05 +01:00
|
|
|
gfs2_dinode_out(ip, bh->b_data);
|
2006-03-28 21:14:04 +02:00
|
|
|
brelse(bh);
|
2006-11-08 18:51:06 +01:00
|
|
|
gfs2_set_inode_flags(inode);
|
2007-10-17 09:47:38 +02:00
|
|
|
gfs2_set_aops(inode);
|
2006-04-04 20:29:30 +02:00
|
|
|
out_trans_end:
|
|
|
|
gfs2_trans_end(sdp);
|
2006-03-28 21:14:04 +02:00
|
|
|
out:
|
|
|
|
gfs2_glock_dq_uninit(&gh);
|
2008-07-02 21:12:01 +02:00
|
|
|
out_drop_write:
|
|
|
|
mnt_drop_write(filp->f_path.mnt);
|
2006-03-28 21:14:04 +02:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-04-07 17:17:32 +02:00
|
|
|
static int gfs2_set_flags(struct file *filp, u32 __user *ptr)
|
2006-03-28 21:14:04 +02:00
|
|
|
{
|
2007-07-18 12:40:06 +02:00
|
|
|
struct inode *inode = filp->f_path.dentry->d_inode;
|
2006-10-02 17:24:43 +02:00
|
|
|
u32 fsflags, gfsflags;
|
2010-05-24 15:36:48 +02:00
|
|
|
|
2006-10-02 17:24:43 +02:00
|
|
|
if (get_user(fsflags, ptr))
|
2006-03-28 21:14:04 +02:00
|
|
|
return -EFAULT;
|
2010-05-24 15:36:48 +02:00
|
|
|
|
2006-10-02 17:24:43 +02:00
|
|
|
gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);
|
2007-07-18 12:40:06 +02:00
|
|
|
if (!S_ISDIR(inode->i_mode)) {
|
|
|
|
if (gfsflags & GFS2_DIF_INHERIT_JDATA)
|
|
|
|
gfsflags ^= (GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA);
|
|
|
|
return do_gfs2_set_flags(filp, gfsflags, ~0);
|
|
|
|
}
|
|
|
|
return do_gfs2_set_flags(filp, gfsflags, ~GFS2_DIF_JDATA);
|
2006-03-28 21:14:04 +02:00
|
|
|
}
|
|
|
|
|
2006-04-07 17:17:32 +02:00
|
|
|
static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
2006-03-28 21:14:04 +02:00
|
|
|
{
|
|
|
|
switch(cmd) {
|
2006-10-02 17:24:43 +02:00
|
|
|
case FS_IOC_GETFLAGS:
|
2006-04-07 17:17:32 +02:00
|
|
|
return gfs2_get_flags(filp, (u32 __user *)arg);
|
2006-10-02 17:24:43 +02:00
|
|
|
case FS_IOC_SETFLAGS:
|
2006-04-07 17:17:32 +02:00
|
|
|
return gfs2_set_flags(filp, (u32 __user *)arg);
|
2006-03-28 21:14:04 +02:00
|
|
|
}
|
|
|
|
return -ENOTTY;
|
|
|
|
}
|
|
|
|
|
2007-10-15 16:40:33 +02:00
|
|
|
/**
|
|
|
|
* gfs2_allocate_page_backing - Use bmap to allocate blocks
|
|
|
|
* @page: The (locked) page to allocate backing for
|
|
|
|
*
|
|
|
|
* 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, thats ok too.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_allocate_page_backing(struct page *page)
|
|
|
|
{
|
|
|
|
struct inode *inode = page->mapping->host;
|
|
|
|
struct buffer_head bh;
|
|
|
|
unsigned long size = PAGE_CACHE_SIZE;
|
|
|
|
u64 lblock = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
|
|
|
|
|
|
|
|
do {
|
|
|
|
bh.b_state = 0;
|
|
|
|
bh.b_size = size;
|
2007-12-10 21:13:27 +01:00
|
|
|
gfs2_block_map(inode, lblock, &bh, 1);
|
2007-10-15 16:40:33 +02:00
|
|
|
if (!buffer_mapped(&bh))
|
|
|
|
return -EIO;
|
|
|
|
size -= bh.b_size;
|
|
|
|
lblock += (bh.b_size >> inode->i_blkbits);
|
|
|
|
} while(size > 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_page_mkwrite - Make a shared, mmap()ed, page writable
|
|
|
|
* @vma: The virtual memory area
|
|
|
|
* @page: The page which is about to become writable
|
|
|
|
*
|
|
|
|
* When the page becomes writable, we need to ensure that we have
|
|
|
|
* blocks allocated on disk to back that page.
|
|
|
|
*/
|
|
|
|
|
2009-04-01 00:23:21 +02:00
|
|
|
static int gfs2_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
|
2007-10-15 16:40:33 +02:00
|
|
|
{
|
2009-04-01 00:23:21 +02:00
|
|
|
struct page *page = vmf->page;
|
2007-10-15 16:40:33 +02:00
|
|
|
struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
|
|
|
unsigned long last_index;
|
2009-01-06 17:47:50 +01:00
|
|
|
u64 pos = page->index << PAGE_CACHE_SHIFT;
|
2007-10-15 16:40:33 +02:00
|
|
|
unsigned int data_blocks, ind_blocks, rblocks;
|
|
|
|
struct gfs2_holder gh;
|
|
|
|
struct gfs2_alloc *al;
|
2011-09-07 16:12:51 +02:00
|
|
|
loff_t size;
|
2007-10-15 16:40:33 +02:00
|
|
|
int ret;
|
|
|
|
|
2011-09-07 16:12:51 +02:00
|
|
|
/* Wait if fs is frozen. This is racy so we check again later on
|
|
|
|
* and retry if the fs has been frozen after the page lock has
|
|
|
|
* been acquired
|
|
|
|
*/
|
|
|
|
vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
|
|
|
|
|
2008-09-18 14:53:59 +02:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
|
|
|
|
ret = gfs2_glock_nq(&gh);
|
2007-10-15 16:40:33 +02:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2009-03-19 14:15:44 +01:00
|
|
|
set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
|
|
|
|
set_bit(GIF_SW_PAGED, &ip->i_flags);
|
|
|
|
|
2011-09-07 16:12:51 +02:00
|
|
|
if (!gfs2_write_alloc_required(ip, pos, PAGE_CACHE_SIZE)) {
|
|
|
|
lock_page(page);
|
|
|
|
if (!PageUptodate(page) || page->mapping != inode->i_mapping) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
unlock_page(page);
|
|
|
|
}
|
2007-10-15 16:40:33 +02:00
|
|
|
goto out_unlock;
|
2011-09-07 16:12:51 +02:00
|
|
|
}
|
|
|
|
|
2008-01-10 16:18:55 +01:00
|
|
|
ret = -ENOMEM;
|
2007-10-15 16:40:33 +02:00
|
|
|
al = gfs2_alloc_get(ip);
|
2008-01-10 16:18:55 +01:00
|
|
|
if (al == NULL)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2008-03-10 16:34:50 +01:00
|
|
|
ret = gfs2_quota_lock_check(ip);
|
2007-10-15 16:40:33 +02:00
|
|
|
if (ret)
|
|
|
|
goto out_alloc_put;
|
2008-12-10 11:28:10 +01:00
|
|
|
gfs2_write_calc_reserv(ip, PAGE_CACHE_SIZE, &data_blocks, &ind_blocks);
|
2007-10-15 16:40:33 +02:00
|
|
|
al->al_requested = data_blocks + ind_blocks;
|
|
|
|
ret = gfs2_inplace_reserve(ip);
|
|
|
|
if (ret)
|
|
|
|
goto out_quota_unlock;
|
|
|
|
|
|
|
|
rblocks = RES_DINODE + ind_blocks;
|
|
|
|
if (gfs2_is_jdata(ip))
|
|
|
|
rblocks += data_blocks ? data_blocks : 1;
|
2010-09-27 23:00:04 +02:00
|
|
|
if (ind_blocks || data_blocks) {
|
2007-10-15 16:40:33 +02:00
|
|
|
rblocks += RES_STATFS + RES_QUOTA;
|
2011-09-01 14:31:59 +02:00
|
|
|
rblocks += gfs2_rg_blocks(ip);
|
2010-09-27 23:00:04 +02:00
|
|
|
}
|
2007-10-15 16:40:33 +02:00
|
|
|
ret = gfs2_trans_begin(sdp, rblocks, 0);
|
|
|
|
if (ret)
|
|
|
|
goto out_trans_fail;
|
|
|
|
|
|
|
|
lock_page(page);
|
|
|
|
ret = -EINVAL;
|
2011-09-07 16:12:51 +02:00
|
|
|
size = i_size_read(inode);
|
|
|
|
last_index = (size - 1) >> PAGE_CACHE_SHIFT;
|
|
|
|
/* Check page index against inode size */
|
|
|
|
if (size == 0 || (page->index > last_index))
|
|
|
|
goto out_trans_end;
|
|
|
|
|
|
|
|
ret = -EAGAIN;
|
|
|
|
/* If truncated, we must retry the operation, we may have raced
|
|
|
|
* with the glock demotion code.
|
|
|
|
*/
|
|
|
|
if (!PageUptodate(page) || page->mapping != inode->i_mapping)
|
|
|
|
goto out_trans_end;
|
|
|
|
|
|
|
|
/* Unstuff, if required, and allocate backing blocks for page */
|
2008-01-17 16:12:03 +01:00
|
|
|
ret = 0;
|
2011-09-07 16:12:51 +02:00
|
|
|
if (gfs2_is_stuffed(ip))
|
2007-10-15 16:40:33 +02:00
|
|
|
ret = gfs2_unstuff_dinode(ip, page);
|
2011-09-07 16:12:51 +02:00
|
|
|
if (ret == 0)
|
|
|
|
ret = gfs2_allocate_page_backing(page);
|
2007-10-15 16:40:33 +02:00
|
|
|
|
2011-09-07 16:12:51 +02:00
|
|
|
out_trans_end:
|
|
|
|
if (ret)
|
|
|
|
unlock_page(page);
|
2007-10-15 16:40:33 +02:00
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
out_trans_fail:
|
|
|
|
gfs2_inplace_release(ip);
|
|
|
|
out_quota_unlock:
|
|
|
|
gfs2_quota_unlock(ip);
|
|
|
|
out_alloc_put:
|
|
|
|
gfs2_alloc_put(ip);
|
|
|
|
out_unlock:
|
|
|
|
gfs2_glock_dq(&gh);
|
|
|
|
out:
|
|
|
|
gfs2_holder_uninit(&gh);
|
2011-09-07 16:12:51 +02:00
|
|
|
if (ret == 0) {
|
|
|
|
set_page_dirty(page);
|
|
|
|
/* This check must be post dropping of transaction lock */
|
|
|
|
if (inode->i_sb->s_frozen == SB_UNFROZEN) {
|
|
|
|
wait_on_page_writeback(page);
|
|
|
|
} else {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
unlock_page(page);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return block_page_mkwrite_return(ret);
|
2007-10-15 16:40:33 +02:00
|
|
|
}
|
|
|
|
|
2009-09-27 20:29:37 +02:00
|
|
|
static const struct vm_operations_struct gfs2_vm_ops = {
|
2007-10-15 16:40:33 +02:00
|
|
|
.fault = filemap_fault,
|
|
|
|
.page_mkwrite = gfs2_page_mkwrite,
|
|
|
|
};
|
|
|
|
|
2006-01-16 17:50:04 +01:00
|
|
|
/**
|
|
|
|
* gfs2_mmap -
|
|
|
|
* @file: The file to map
|
|
|
|
* @vma: The VMA which described the mapping
|
|
|
|
*
|
2009-04-29 14:59:35 +02: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 17:50:04 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
|
|
|
|
{
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2011-02-02 15:48:10 +01:00
|
|
|
if (!(file->f_flags & O_NOATIME) &&
|
|
|
|
!IS_NOATIME(&ip->i_inode)) {
|
2009-04-29 14:59:35 +02:00
|
|
|
struct gfs2_holder i_gh;
|
|
|
|
int error;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2011-02-02 15:48:10 +01:00
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
|
2009-04-29 14:59:35 +02:00
|
|
|
error = gfs2_glock_nq(&i_gh);
|
2011-02-02 15:48:10 +01:00
|
|
|
if (error == 0) {
|
|
|
|
file_accessed(file);
|
|
|
|
gfs2_glock_dq(&i_gh);
|
|
|
|
}
|
|
|
|
gfs2_holder_uninit(&i_gh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2009-04-29 14:59:35 +02:00
|
|
|
}
|
2007-10-15 16:40:33 +02:00
|
|
|
vma->vm_ops = &gfs2_vm_ops;
|
2009-04-29 14:59:35 +02:00
|
|
|
vma->vm_flags |= VM_CAN_NONLINEAR;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2009-04-29 14:59:35 +02:00
|
|
|
return 0;
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_open - open a file
|
|
|
|
* @inode: the inode to open
|
|
|
|
* @file: the struct file for this opening
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2006-06-14 21:32:57 +02:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2006-01-16 17:50:04 +01:00
|
|
|
struct gfs2_holder i_gh;
|
|
|
|
struct gfs2_file *fp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
|
|
|
|
if (!fp)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-02-21 13:51:39 +01:00
|
|
|
mutex_init(&fp->f_fl_mutex);
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-06-14 21:32:57 +02:00
|
|
|
gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
|
2006-02-27 23:23:27 +01:00
|
|
|
file->private_data = fp;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-11-01 18:22:46 +01:00
|
|
|
if (S_ISREG(ip->i_inode.i_mode)) {
|
2006-01-16 17:50:04 +01:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
|
|
|
|
&i_gh);
|
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
if (!(file->f_flags & O_LARGEFILE) &&
|
2010-08-11 10:53:11 +02:00
|
|
|
i_size_read(inode) > MAX_NON_LFS) {
|
2007-10-17 08:30:22 +02:00
|
|
|
error = -EOVERFLOW;
|
2006-01-16 17:50:04 +01:00
|
|
|
goto fail_gunlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2006-07-31 21:42:17 +02:00
|
|
|
fail_gunlock:
|
2006-01-16 17:50:04 +01:00
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
2006-07-31 21:42:17 +02:00
|
|
|
fail:
|
2006-02-27 23:23:27 +01:00
|
|
|
file->private_data = NULL;
|
2006-01-16 17:50:04 +01:00
|
|
|
kfree(fp);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_close - called to close a struct file
|
|
|
|
* @inode: the inode the struct file belongs to
|
|
|
|
* @file: the struct file being closed
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_close(struct inode *inode, struct file *file)
|
|
|
|
{
|
2006-02-27 23:23:27 +01:00
|
|
|
struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
|
2006-01-16 17:50:04 +01:00
|
|
|
struct gfs2_file *fp;
|
|
|
|
|
2006-02-27 23:23:27 +01:00
|
|
|
fp = file->private_data;
|
|
|
|
file->private_data = NULL;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
if (gfs2_assert_warn(sdp, fp))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
kfree(fp);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_fsync - sync the dirty data for a file (across the cluster)
|
2011-07-17 02:44:56 +02: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 10:54:02 +02:00
|
|
|
* @datasync: set if we can ignore timestamp changes
|
2006-01-16 17:50:04 +01:00
|
|
|
*
|
2011-07-27 11:58:48 +02: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 15:13:14 +01:00
|
|
|
*
|
2006-01-16 17:50:04 +01:00
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
2011-07-17 02:44:56 +02:00
|
|
|
static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
|
|
|
|
int datasync)
|
2006-01-16 17:50:04 +01:00
|
|
|
{
|
2011-07-27 11:58:48 +02:00
|
|
|
struct address_space *mapping = file->f_mapping;
|
|
|
|
struct inode *inode = mapping->host;
|
2006-11-30 16:14:32 +01:00
|
|
|
int sync_state = inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC);
|
2011-04-14 10:54:02 +02:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2011-07-27 11:58:48 +02:00
|
|
|
int ret, ret1 = 0;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2011-07-27 11:58:48 +02:00
|
|
|
if (mapping->nrpages) {
|
|
|
|
ret1 = filemap_fdatawrite_range(mapping, start, end);
|
|
|
|
if (ret1 == -EIO)
|
|
|
|
return ret1;
|
|
|
|
}
|
2011-07-17 02:44:56 +02:00
|
|
|
|
2011-04-14 10:54:02 +02:00
|
|
|
if (datasync)
|
|
|
|
sync_state &= ~I_DIRTY_SYNC;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2011-04-14 10:54:02 +02:00
|
|
|
if (sync_state) {
|
|
|
|
ret = sync_inode_metadata(inode, 1);
|
2011-09-07 11:33:25 +02:00
|
|
|
if (ret)
|
2011-04-14 10:54:02 +02:00
|
|
|
return ret;
|
2011-08-05 11:12:47 +02:00
|
|
|
if (gfs2_is_jdata(ip))
|
|
|
|
filemap_write_and_wait(mapping);
|
2011-09-07 11:33:25 +02:00
|
|
|
gfs2_ail_flush(ip->i_gl, 1);
|
2006-11-30 16:14:32 +01:00
|
|
|
}
|
|
|
|
|
2011-07-27 11:58:48 +02:00
|
|
|
if (mapping->nrpages)
|
|
|
|
ret = filemap_fdatawait_range(mapping, start, end);
|
|
|
|
|
|
|
|
return ret ? ret : ret1;
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
2009-12-08 11:25:33 +01:00
|
|
|
/**
|
|
|
|
* gfs2_file_aio_write - Perform a write to a file
|
|
|
|
* @iocb: The io context
|
|
|
|
* @iov: The data to write
|
|
|
|
* @nr_segs: Number of @iov segments
|
|
|
|
* @pos: The file position
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static ssize_t gfs2_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
|
|
|
|
unsigned long nr_segs, loff_t pos)
|
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
|
|
|
|
|
|
|
if (file->f_flags & O_APPEND) {
|
|
|
|
struct dentry *dentry = file->f_dentry;
|
|
|
|
struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
|
|
|
|
struct gfs2_holder gh;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
gfs2_glock_dq_uninit(&gh);
|
|
|
|
}
|
|
|
|
|
|
|
|
return generic_file_aio_write(iocb, iov, nr_segs, pos);
|
|
|
|
}
|
|
|
|
|
2011-01-14 13:07:43 +01:00
|
|
|
static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,
|
|
|
|
int mode)
|
|
|
|
{
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
struct buffer_head *dibh;
|
|
|
|
int error;
|
2011-09-13 01:15:24 +02:00
|
|
|
unsigned int nr_blks;
|
|
|
|
sector_t lblock = offset >> inode->i_blkbits;
|
2011-01-14 13:07:43 +01:00
|
|
|
|
|
|
|
error = gfs2_meta_inode_buffer(ip, &dibh);
|
|
|
|
if (unlikely(error))
|
2011-09-13 01:15:24 +02:00
|
|
|
return error;
|
2011-01-14 13:07:43 +01:00
|
|
|
|
|
|
|
gfs2_trans_add_bh(ip->i_gl, dibh, 1);
|
|
|
|
|
|
|
|
if (gfs2_is_stuffed(ip)) {
|
|
|
|
error = gfs2_unstuff_dinode(ip, NULL);
|
|
|
|
if (unlikely(error))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-09-13 01:15:24 +02:00
|
|
|
while (len) {
|
|
|
|
struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
|
|
|
|
bh_map.b_size = len;
|
|
|
|
set_buffer_zeronew(&bh_map);
|
2011-01-14 13:07:43 +01:00
|
|
|
|
2011-09-13 01:15:24 +02:00
|
|
|
error = gfs2_block_map(inode, lblock, &bh_map, 1);
|
|
|
|
if (unlikely(error))
|
|
|
|
goto out;
|
|
|
|
len -= bh_map.b_size;
|
|
|
|
nr_blks = bh_map.b_size >> inode->i_blkbits;
|
|
|
|
lblock += nr_blks;
|
|
|
|
if (!buffer_new(&bh_map))
|
|
|
|
continue;
|
|
|
|
if (unlikely(!buffer_zeronew(&bh_map))) {
|
|
|
|
error = -EIO;
|
2011-01-14 13:07:43 +01:00
|
|
|
goto out;
|
2011-09-13 01:15:24 +02:00
|
|
|
}
|
2011-01-14 13:07:43 +01:00
|
|
|
}
|
2011-09-13 01:15:24 +02:00
|
|
|
if (offset + len > inode->i_size && !(mode & FALLOC_FL_KEEP_SIZE))
|
|
|
|
i_size_write(inode, offset + len);
|
2011-01-14 13:07:43 +01:00
|
|
|
|
|
|
|
mark_inode_dirty(inode);
|
|
|
|
|
|
|
|
out:
|
2011-09-13 01:15:24 +02:00
|
|
|
brelse(dibh);
|
2011-01-14 13:07:43 +01:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void calc_max_reserv(struct gfs2_inode *ip, loff_t max, loff_t *len,
|
|
|
|
unsigned int *data_blocks, unsigned int *ind_blocks)
|
|
|
|
{
|
|
|
|
const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2011-09-01 14:31:59 +02:00
|
|
|
unsigned int max_blocks = ip->i_rgd->rd_free_clone;
|
2011-01-14 13:07:43 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
/* This calculation isn't the exact reverse of gfs2_write_calc_reserve,
|
|
|
|
so it might end up with fewer data blocks */
|
|
|
|
if (max_data <= *data_blocks)
|
|
|
|
return;
|
|
|
|
*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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static long gfs2_fallocate(struct file *file, int mode, loff_t offset,
|
|
|
|
loff_t len)
|
|
|
|
{
|
|
|
|
struct inode *inode = file->f_path.dentry->d_inode;
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(inode);
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
|
|
|
unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
|
|
|
|
loff_t bytes, max_bytes;
|
|
|
|
struct gfs2_alloc *al;
|
|
|
|
int error;
|
2011-04-26 08:13:24 +02:00
|
|
|
loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1);
|
2011-01-14 13:07:43 +01:00
|
|
|
loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift;
|
2011-09-13 01:15:24 +02:00
|
|
|
loff_t max_chunk_size = UINT_MAX & bsize_mask;
|
2011-01-14 13:07:43 +01:00
|
|
|
next = (next + 1) << sdp->sd_sb.sb_bsize_shift;
|
|
|
|
|
|
|
|
/* We only support the FALLOC_FL_KEEP_SIZE mode */
|
|
|
|
if (mode & ~FALLOC_FL_KEEP_SIZE)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2011-04-26 08:13:24 +02:00
|
|
|
offset &= bsize_mask;
|
2011-01-14 13:07:43 +01:00
|
|
|
|
|
|
|
len = next - offset;
|
|
|
|
bytes = sdp->sd_max_rg_data * sdp->sd_sb.sb_bsize / 2;
|
|
|
|
if (!bytes)
|
|
|
|
bytes = UINT_MAX;
|
2011-04-26 08:13:24 +02:00
|
|
|
bytes &= bsize_mask;
|
|
|
|
if (bytes == 0)
|
|
|
|
bytes = sdp->sd_sb.sb_bsize;
|
2011-01-14 13:07:43 +01:00
|
|
|
|
|
|
|
gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
|
|
|
|
error = gfs2_glock_nq(&ip->i_gh);
|
|
|
|
if (unlikely(error))
|
|
|
|
goto out_uninit;
|
|
|
|
|
|
|
|
if (!gfs2_write_alloc_required(ip, offset, len))
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
while (len > 0) {
|
|
|
|
if (len < bytes)
|
|
|
|
bytes = len;
|
|
|
|
al = gfs2_alloc_get(ip);
|
|
|
|
if (!al) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_quota_lock_check(ip);
|
|
|
|
if (error)
|
|
|
|
goto out_alloc_put;
|
|
|
|
|
|
|
|
retry:
|
|
|
|
gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks);
|
|
|
|
|
|
|
|
al->al_requested = data_blocks + ind_blocks;
|
|
|
|
error = gfs2_inplace_reserve(ip);
|
|
|
|
if (error) {
|
|
|
|
if (error == -ENOSPC && bytes > sdp->sd_sb.sb_bsize) {
|
|
|
|
bytes >>= 1;
|
2011-04-26 08:13:24 +02:00
|
|
|
bytes &= bsize_mask;
|
|
|
|
if (bytes == 0)
|
|
|
|
bytes = sdp->sd_sb.sb_bsize;
|
2011-01-14 13:07:43 +01:00
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
goto out_qunlock;
|
|
|
|
}
|
|
|
|
max_bytes = bytes;
|
2011-09-13 01:15:24 +02:00
|
|
|
calc_max_reserv(ip, (len > max_chunk_size)? max_chunk_size: len,
|
|
|
|
&max_bytes, &data_blocks, &ind_blocks);
|
2011-01-14 13:07:43 +01:00
|
|
|
al->al_requested = data_blocks + ind_blocks;
|
|
|
|
|
|
|
|
rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA +
|
2011-09-01 14:31:59 +02:00
|
|
|
RES_RG_HDR + gfs2_rg_blocks(ip);
|
2011-01-14 13:07:43 +01:00
|
|
|
if (gfs2_is_jdata(ip))
|
|
|
|
rblocks += data_blocks ? data_blocks : 1;
|
|
|
|
|
|
|
|
error = gfs2_trans_begin(sdp, rblocks,
|
|
|
|
PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
|
|
|
|
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);
|
|
|
|
gfs2_alloc_put(ip);
|
|
|
|
}
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
out_trans_fail:
|
|
|
|
gfs2_inplace_release(ip);
|
|
|
|
out_qunlock:
|
|
|
|
gfs2_quota_unlock(ip);
|
|
|
|
out_alloc_put:
|
|
|
|
gfs2_alloc_put(ip);
|
|
|
|
out_unlock:
|
|
|
|
gfs2_glock_dq(&ip->i_gh);
|
|
|
|
out_uninit:
|
|
|
|
gfs2_holder_uninit(&ip->i_gh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2009-01-12 11:43:39 +01:00
|
|
|
#ifdef CONFIG_GFS2_FS_LOCKING_DLM
|
|
|
|
|
2007-01-16 00:33:36 +01:00
|
|
|
/**
|
|
|
|
* gfs2_setlease - acquire/release a file lease
|
|
|
|
* @file: the file pointer
|
|
|
|
* @arg: lease type
|
|
|
|
* @fl: file lock
|
|
|
|
*
|
2009-01-12 11:43:39 +01:00
|
|
|
* We don't currently have a way to enforce a lease across the whole
|
|
|
|
* cluster; until we do, disable leases (by just returning -EINVAL),
|
|
|
|
* unless the administrator has requested purely local locking.
|
|
|
|
*
|
2010-09-18 15:09:31 +02:00
|
|
|
* Locking: called under lock_flocks
|
|
|
|
*
|
2007-01-16 00:33:36 +01:00
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_setlease(struct file *file, long arg, struct file_lock **fl)
|
|
|
|
{
|
2009-01-12 11:43:39 +01:00
|
|
|
return -EINVAL;
|
2008-01-30 16:34:04 +01:00
|
|
|
}
|
|
|
|
|
2006-01-16 17:50:04 +01: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 21:32:57 +02:00
|
|
|
struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
|
2009-01-12 11:43:39 +01:00
|
|
|
struct lm_lockstruct *ls = &sdp->sd_lockstruct;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
if (!(fl->fl_flags & FL_POSIX))
|
|
|
|
return -ENOLCK;
|
2010-03-11 18:24:45 +01:00
|
|
|
if (__mandatory_lock(&ip->i_inode) && fl->fl_type != F_UNLCK)
|
2006-01-16 17:50:04 +01:00
|
|
|
return -ENOLCK;
|
|
|
|
|
2006-11-14 22:37:25 +01:00
|
|
|
if (cmd == F_CANCELLK) {
|
|
|
|
/* Hack: */
|
|
|
|
cmd = F_SETLK;
|
|
|
|
fl->fl_type = F_UNLCK;
|
|
|
|
}
|
2009-01-12 11:43:39 +01:00
|
|
|
if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
|
|
|
|
return -EIO;
|
2006-01-16 17:50:04 +01:00
|
|
|
if (IS_GETLK(cmd))
|
2009-01-12 11:43:39 +01:00
|
|
|
return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl);
|
2006-01-16 17:50:04 +01:00
|
|
|
else if (fl->fl_type == F_UNLCK)
|
2009-01-12 11:43:39 +01:00
|
|
|
return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl);
|
2006-01-16 17:50:04 +01:00
|
|
|
else
|
2009-01-12 11:43:39 +01:00
|
|
|
return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl);
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int do_flock(struct file *file, int cmd, struct file_lock *fl)
|
|
|
|
{
|
2006-02-27 23:23:27 +01:00
|
|
|
struct gfs2_file *fp = file->private_data;
|
2006-01-16 17:50:04 +01:00
|
|
|
struct gfs2_holder *fl_gh = &fp->f_fl_gh;
|
2006-12-08 11:37:03 +01:00
|
|
|
struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);
|
2006-01-16 17:50:04 +01:00
|
|
|
struct gfs2_glock *gl;
|
|
|
|
unsigned int state;
|
|
|
|
int flags;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
|
2008-05-21 18:03:22 +02:00
|
|
|
flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
2006-02-21 13:51:39 +01:00
|
|
|
mutex_lock(&fp->f_fl_mutex);
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
gl = fl_gh->gh_gl;
|
|
|
|
if (gl) {
|
|
|
|
if (fl_gh->gh_state == state)
|
|
|
|
goto out;
|
|
|
|
flock_lock_file_wait(file,
|
2006-09-25 15:26:04 +02:00
|
|
|
&(struct file_lock){.fl_type = F_UNLCK});
|
2007-09-14 06:35:27 +02:00
|
|
|
gfs2_glock_dq_wait(fl_gh);
|
|
|
|
gfs2_holder_reinit(state, flags, fl_gh);
|
2006-01-16 17:50:04 +01:00
|
|
|
} else {
|
2008-05-21 18:03:22 +02:00
|
|
|
error = gfs2_glock_get(GFS2_SB(&ip->i_inode), ip->i_no_addr,
|
|
|
|
&gfs2_flock_glops, CREATE, &gl);
|
2006-01-16 17:50:04 +01:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2007-09-14 06:35:27 +02:00
|
|
|
gfs2_holder_init(gl, state, flags, fl_gh);
|
|
|
|
gfs2_glock_put(gl);
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
error = gfs2_glock_nq(fl_gh);
|
|
|
|
if (error) {
|
|
|
|
gfs2_holder_uninit(fl_gh);
|
|
|
|
if (error == GLR_TRYFAILED)
|
|
|
|
error = -EAGAIN;
|
|
|
|
} else {
|
|
|
|
error = flock_lock_file_wait(file, fl);
|
2006-06-14 21:32:57 +02:00
|
|
|
gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
2006-07-31 21:42:17 +02:00
|
|
|
out:
|
2006-02-21 13:51:39 +01:00
|
|
|
mutex_unlock(&fp->f_fl_mutex);
|
2006-01-16 17:50:04 +01:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void do_unflock(struct file *file, struct file_lock *fl)
|
|
|
|
{
|
2006-02-27 23:23:27 +01:00
|
|
|
struct gfs2_file *fp = file->private_data;
|
2006-01-16 17:50:04 +01:00
|
|
|
struct gfs2_holder *fl_gh = &fp->f_fl_gh;
|
|
|
|
|
2006-02-21 13:51:39 +01:00
|
|
|
mutex_lock(&fp->f_fl_mutex);
|
2006-01-16 17:50:04 +01:00
|
|
|
flock_lock_file_wait(file, fl);
|
2011-03-09 12:14:32 +01:00
|
|
|
if (fl_gh->gh_gl) {
|
|
|
|
gfs2_glock_dq_wait(fl_gh);
|
|
|
|
gfs2_holder_uninit(fl_gh);
|
|
|
|
}
|
2006-02-21 13:51:39 +01:00
|
|
|
mutex_unlock(&fp->f_fl_mutex);
|
2006-01-16 17:50:04 +01: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;
|
2009-06-01 19:30:03 +02:00
|
|
|
if (fl->fl_type & LOCK_MAND)
|
|
|
|
return -EOPNOTSUPP;
|
2006-01-16 17:50:04 +01:00
|
|
|
|
|
|
|
if (fl->fl_type == F_UNLCK) {
|
|
|
|
do_unflock(file, fl);
|
|
|
|
return 0;
|
2006-10-02 16:28:05 +02:00
|
|
|
} else {
|
2006-01-16 17:50:04 +01:00
|
|
|
return do_flock(file, cmd, fl);
|
2006-10-02 16:28:05 +02:00
|
|
|
}
|
2006-01-16 17:50:04 +01:00
|
|
|
}
|
|
|
|
|
2009-04-07 19:42:17 +02:00
|
|
|
const struct file_operations gfs2_file_fops = {
|
2006-09-04 21:32:10 +02:00
|
|
|
.llseek = gfs2_llseek,
|
2006-10-02 16:28:05 +02:00
|
|
|
.read = do_sync_read,
|
2006-09-04 21:32:10 +02:00
|
|
|
.aio_read = generic_file_aio_read,
|
2006-10-02 16:28:05 +02:00
|
|
|
.write = do_sync_write,
|
2009-12-08 11:25:33 +01:00
|
|
|
.aio_write = gfs2_file_aio_write,
|
2006-09-04 21:32:10 +02:00
|
|
|
.unlocked_ioctl = gfs2_ioctl,
|
|
|
|
.mmap = gfs2_mmap,
|
|
|
|
.open = gfs2_open,
|
|
|
|
.release = gfs2_close,
|
|
|
|
.fsync = gfs2_fsync,
|
|
|
|
.lock = gfs2_lock,
|
|
|
|
.flock = gfs2_flock,
|
|
|
|
.splice_read = generic_file_splice_read,
|
|
|
|
.splice_write = generic_file_splice_write,
|
2007-01-16 00:33:36 +01:00
|
|
|
.setlease = gfs2_setlease,
|
2011-01-14 13:07:43 +01:00
|
|
|
.fallocate = gfs2_fallocate,
|
2006-01-16 17:50:04 +01:00
|
|
|
};
|
|
|
|
|
2009-04-07 19:42:17 +02:00
|
|
|
const struct file_operations gfs2_dir_fops = {
|
2006-09-04 21:32:10 +02:00
|
|
|
.readdir = gfs2_readdir,
|
|
|
|
.unlocked_ioctl = gfs2_ioctl,
|
|
|
|
.open = gfs2_open,
|
|
|
|
.release = gfs2_close,
|
|
|
|
.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 18:52:59 +02:00
|
|
|
.llseek = default_llseek,
|
2006-01-16 17:50:04 +01:00
|
|
|
};
|
|
|
|
|
2009-01-12 11:43:39 +01:00
|
|
|
#endif /* CONFIG_GFS2_FS_LOCKING_DLM */
|
|
|
|
|
2009-04-07 19:42:17 +02:00
|
|
|
const struct file_operations gfs2_file_fops_nolock = {
|
2007-11-29 23:56:51 +01:00
|
|
|
.llseek = gfs2_llseek,
|
|
|
|
.read = do_sync_read,
|
|
|
|
.aio_read = generic_file_aio_read,
|
|
|
|
.write = do_sync_write,
|
2009-12-08 11:25:33 +01:00
|
|
|
.aio_write = gfs2_file_aio_write,
|
2007-11-29 23:56:51 +01:00
|
|
|
.unlocked_ioctl = gfs2_ioctl,
|
|
|
|
.mmap = gfs2_mmap,
|
|
|
|
.open = gfs2_open,
|
|
|
|
.release = gfs2_close,
|
|
|
|
.fsync = gfs2_fsync,
|
|
|
|
.splice_read = generic_file_splice_read,
|
|
|
|
.splice_write = generic_file_splice_write,
|
2009-01-12 11:43:39 +01:00
|
|
|
.setlease = generic_setlease,
|
2011-01-14 13:07:43 +01:00
|
|
|
.fallocate = gfs2_fallocate,
|
2007-11-29 23:56:51 +01:00
|
|
|
};
|
|
|
|
|
2009-04-07 19:42:17 +02:00
|
|
|
const struct file_operations gfs2_dir_fops_nolock = {
|
2007-11-29 23:56:51 +01:00
|
|
|
.readdir = gfs2_readdir,
|
|
|
|
.unlocked_ioctl = gfs2_ioctl,
|
|
|
|
.open = gfs2_open,
|
|
|
|
.release = gfs2_close,
|
|
|
|
.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 18:52:59 +02:00
|
|
|
.llseek = default_llseek,
|
2007-11-29 23:56:51 +01:00
|
|
|
};
|
|
|
|
|