[net-next-2.6.git] / fs / gfs2 / ops_file.c

/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU General Public License version 2.
 */

#include <linux/sched.h>
#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>
#include <linux/smp_lock.h>
#include <linux/fs.h>
#include <linux/gfs2_ondisk.h>
#include <linux/ext2_fs.h>
#include <linux/crc32.h>
#include <linux/iflags.h>
#include <linux/lm_interface.h>
#include <asm/uaccess.h>

#include "gfs2.h"
#include "incore.h"
#include "bmap.h"
#include "dir.h"
#include "glock.h"
#include "glops.h"
#include "inode.h"
#include "lm.h"
#include "log.h"
#include "meta_io.h"
#include "ops_file.h"
#include "ops_vm.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
#include "util.h"
#include "eaops.h"

/* For regular, non-NFS */
struct filldir_reg {
	struct gfs2_sbd *fdr_sbd;
	int fdr_prefetch;

	filldir_t fdr_filldir;
	void *fdr_opaque;
};

/*
 * Most fields left uninitialised to catch anybody who tries to
 * use them. f_flags set to prevent file_accessed() from touching
 * any other part of this. Its use is purely as a flag so that we
 * know (in readpage()) whether or not do to locking.
 */
struct file gfs2_internal_file_sentinel = {
	.f_flags = O_NOATIME|O_RDONLY,
};

static int gfs2_read_actor(read_descriptor_t *desc, struct page *page,
			   unsigned long offset, unsigned long size)
{
	char *kaddr;
	unsigned long count = desc->count;

	if (size > count)
		size = count;

	kaddr = kmap(page);
	memcpy(desc->arg.buf, kaddr + offset, size);
	kunmap(page);

	desc->count = count - size;
	desc->written += size;
	desc->arg.buf += size;
	return size;
}

int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,
		       char *buf, loff_t *pos, unsigned size)
{
	struct inode *inode = &ip->i_inode;
	read_descriptor_t desc;
	desc.written = 0;
	desc.arg.buf = buf;
	desc.count = size;
	desc.error = 0;
	do_generic_mapping_read(inode->i_mapping, ra_state,
				&gfs2_internal_file_sentinel, pos, &desc,
				gfs2_read_actor);
	return desc.written ? desc.written : desc.error;
}

/**
 * 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)
{
	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
	struct gfs2_holder i_gh;
	loff_t error;

	if (origin == 2) {
		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
					   &i_gh);
		if (!error) {
			error = remote_llseek(file, offset, origin);
			gfs2_glock_dq_uninit(&i_gh);
		}
	} else
		error = remote_llseek(file, offset, origin);

	return error;
}

/**
 * filldir_func - Report a directory entry to the caller of gfs2_dir_read()
 * @opaque: opaque data used by the function
 * @name: the name of the directory entry
 * @length: the length of the name
 * @offset: the entry's offset in the directory
 * @inum: the inode number the entry points to
 * @type: the type of inode the entry points to
 *
 * Returns: 0 on success, 1 if buffer full
 */

static int filldir_func(void *opaque, const char *name, unsigned int length,
			u64 offset, struct gfs2_inum *inum,
			unsigned int type)
{
	struct filldir_reg *fdr = (struct filldir_reg *)opaque;
	struct gfs2_sbd *sdp = fdr->fdr_sbd;
	int error;

	error = fdr->fdr_filldir(fdr->fdr_opaque, name, length, offset,
				 inum->no_addr, type);
	if (error)
		return 1;

	if (fdr->fdr_prefetch && !(length == 1 && *name == '.')) {
		gfs2_glock_prefetch_num(sdp, inum->no_addr, &gfs2_inode_glops,
				       LM_ST_SHARED, LM_FLAG_TRY | LM_FLAG_ANY);
		gfs2_glock_prefetch_num(sdp, inum->no_addr, &gfs2_iopen_glops,
				       LM_ST_SHARED, LM_FLAG_TRY);
	}

	return 0;
}

/**
 * gfs2_readdir - Read directory entries from a directory
 * @file: The directory to read from
 * @dirent: Buffer for dirents
 * @filldir: Function used to do the copying
 *
 * Returns: errno
 */

static int gfs2_readdir(struct file *file, void *dirent, filldir_t filldir)
{
	struct inode *dir = file->f_mapping->host;
	struct gfs2_inode *dip = GFS2_I(dir);
	struct filldir_reg fdr;
	struct gfs2_holder d_gh;
	u64 offset = file->f_pos;
	int error;

	fdr.fdr_sbd = GFS2_SB(dir);
	fdr.fdr_prefetch = 1;
	fdr.fdr_filldir = filldir;
	fdr.fdr_opaque = dirent;

	gfs2_holder_init(dip->i_gl, LM_ST_SHARED, GL_ATIME, &d_gh);
	error = gfs2_glock_nq_atime(&d_gh);
	if (error) {
		gfs2_holder_uninit(&d_gh);
		return error;
	}

	error = gfs2_dir_read(dir, &offset, &fdr, filldir_func);

	gfs2_glock_dq_uninit(&d_gh);

	file->f_pos = offset;

	return error;
}


static const u32 iflags_to_gfs2[32] = {
	[iflag_Sync] = GFS2_DIF_SYNC,
	[iflag_Immutable] = GFS2_DIF_IMMUTABLE,
	[iflag_Append] = GFS2_DIF_APPENDONLY,
	[iflag_NoAtime] = GFS2_DIF_NOATIME,
	[iflag_Index] = GFS2_DIF_EXHASH,
	[iflag_JournalData] = GFS2_DIF_JDATA,
	[iflag_DirectIO] = GFS2_DIF_DIRECTIO,
};

static const u32 gfs2_to_iflags[32] = {
	[gfs2fl_Sync] = IFLAG_SYNC,
	[gfs2fl_Immutable] = IFLAG_IMMUTABLE,
	[gfs2fl_AppendOnly] = IFLAG_APPEND,
	[gfs2fl_NoAtime] = IFLAG_NOATIME,
	[gfs2fl_ExHash] = IFLAG_INDEX,
	[gfs2fl_Jdata] = IFLAG_JOURNAL_DATA,
	[gfs2fl_Directio] = IFLAG_DIRECTIO,
	[gfs2fl_InheritDirectio] = IFLAG_DIRECTIO,
	[gfs2fl_InheritJdata] = IFLAG_JOURNAL_DATA,
};

static int gfs2_get_flags(struct file *filp, u32 __user *ptr)
{
	struct inode *inode = filp->f_dentry->d_inode;
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_holder gh;
	int error;
	u32 iflags;

	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
	error = gfs2_glock_nq_m_atime(1, &gh);
	if (error)
		return error;

	iflags = iflags_cvt(gfs2_to_iflags, ip->i_di.di_flags);
	if (put_user(iflags, ptr))
		error = -EFAULT;

	gfs2_glock_dq_m(1, &gh);
	gfs2_holder_uninit(&gh);
	return error;
}

/* Flags that can be set by user space */
#define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA|			\
			     GFS2_DIF_DIRECTIO|			\
			     GFS2_DIF_IMMUTABLE|		\
			     GFS2_DIF_APPENDONLY|		\
			     GFS2_DIF_NOATIME|			\
			     GFS2_DIF_SYNC|			\
			     GFS2_DIF_SYSTEM|			\
			     GFS2_DIF_INHERIT_DIRECTIO|		\
			     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
 *
 */
static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
{
	struct inode *inode = filp->f_dentry->d_inode;
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	struct buffer_head *bh;
	struct gfs2_holder gh;
	int error;
	u32 new_flags, flags;

	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
	if (error)
		return error;

	flags = ip->i_di.di_flags;
	new_flags = (flags & ~mask) | (reqflags & mask);
	if ((new_flags ^ flags) == 0)
		goto out;

	if (S_ISDIR(inode->i_mode)) {
		if ((new_flags ^ flags) & GFS2_DIF_JDATA)
			new_flags ^= (GFS2_DIF_JDATA|GFS2_DIF_INHERIT_JDATA);
		if ((new_flags ^ flags) & GFS2_DIF_DIRECTIO)
			new_flags ^= (GFS2_DIF_DIRECTIO|GFS2_DIF_INHERIT_DIRECTIO);
	}

	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;
	if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
	    !capable(CAP_LINUX_IMMUTABLE))
		goto out;
	if (!IS_IMMUTABLE(inode)) {
		error = permission(inode, MAY_WRITE, NULL);
		if (error)
			goto out;
	}

	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
	if (error)
		goto out;
	error = gfs2_meta_inode_buffer(ip, &bh);
	if (error)
		goto out_trans_end;
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
	ip->i_di.di_flags = new_flags;
	gfs2_dinode_out(&ip->i_di, bh->b_data);
	brelse(bh);
out_trans_end:
	gfs2_trans_end(sdp);
out:
	gfs2_glock_dq_uninit(&gh);
	return error;
}

static int gfs2_set_flags(struct file *filp, u32 __user *ptr)
{
	u32 iflags, gfsflags;
	if (get_user(iflags, ptr))
		return -EFAULT;
	gfsflags = iflags_cvt(iflags_to_gfs2, iflags);
	return do_gfs2_set_flags(filp, gfsflags, ~0);
}

static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	switch(cmd) {
	case IFLAGS_GET_IOC:
		return gfs2_get_flags(filp, (u32 __user *)arg);
	case IFLAGS_SET_IOC:
		return gfs2_set_flags(filp, (u32 __user *)arg);
	}
	return -ENOTTY;
}


/**
 * gfs2_mmap -
 * @file: The file to map
 * @vma: The VMA which described the mapping
 *
 * Returns: 0 or error code
 */

static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
	struct gfs2_holder i_gh;
	int error;

	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
	error = gfs2_glock_nq_atime(&i_gh);
	if (error) {
		gfs2_holder_uninit(&i_gh);
		return error;
	}

	/* This is VM_MAYWRITE instead of VM_WRITE because a call
	   to mprotect() can turn on VM_WRITE later. */

	if ((vma->vm_flags & (VM_MAYSHARE | VM_MAYWRITE)) ==
	    (VM_MAYSHARE | VM_MAYWRITE))
		vma->vm_ops = &gfs2_vm_ops_sharewrite;
	else
		vma->vm_ops = &gfs2_vm_ops_private;

	gfs2_glock_dq_uninit(&i_gh);

	return error;
}

/**
 * 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)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_holder i_gh;
	struct gfs2_file *fp;
	int error;

	fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
	if (!fp)
		return -ENOMEM;

	mutex_init(&fp->f_fl_mutex);

	gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
	file->private_data = fp;

	if (S_ISREG(ip->i_di.di_mode)) {
		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) &&
		    ip->i_di.di_size > MAX_NON_LFS) {
			error = -EFBIG;
			goto fail_gunlock;
		}

		/* Listen to the Direct I/O flag */

		if (ip->i_di.di_flags & GFS2_DIF_DIRECTIO)
			file->f_flags |= O_DIRECT;

		gfs2_glock_dq_uninit(&i_gh);
	}

	return 0;

fail_gunlock:
	gfs2_glock_dq_uninit(&i_gh);
fail:
	file->private_data = NULL;
	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)
{
	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
	struct gfs2_file *fp;

	fp = file->private_data;
	file->private_data = NULL;

	if (gfs2_assert_warn(sdp, fp))
		return -EIO;

	kfree(fp);

	return 0;
}

/**
 * gfs2_fsync - sync the dirty data for a file (across the cluster)
 * @file: the file that points to the dentry (we ignore this)
 * @dentry: the dentry that points to the inode to sync
 *
 * Returns: errno
 */

static int gfs2_fsync(struct file *file, struct dentry *dentry, int datasync)
{
	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);

	gfs2_log_flush(ip->i_gl->gl_sbd, ip->i_gl);

	return 0;
}

/**
 * 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)
{
	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
	struct lm_lockname name =
		{ .ln_number = ip->i_num.no_addr,
		  .ln_type = LM_TYPE_PLOCK };

	if (!(fl->fl_flags & FL_POSIX))
		return -ENOLCK;
	if ((ip->i_di.di_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
		return -ENOLCK;

	if (sdp->sd_args.ar_localflocks) {
		if (IS_GETLK(cmd)) {
			struct file_lock tmp;
			int ret;
			ret = posix_test_lock(file, fl, &tmp);
			fl->fl_type = F_UNLCK;
			if (ret)
				memcpy(fl, &tmp, sizeof(struct file_lock));
			return 0;
		} else {
			return posix_lock_file_wait(file, fl);
		}
	}

	if (IS_GETLK(cmd))
		return gfs2_lm_plock_get(sdp, &name, file, fl);
	else if (fl->fl_type == F_UNLCK)
		return gfs2_lm_punlock(sdp, &name, file, fl);
	else
		return gfs2_lm_plock(sdp, &name, file, cmd, fl);
}

static int do_flock(struct file *file, int cmd, struct file_lock *fl)
{
	struct gfs2_file *fp = file->private_data;
	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
	struct gfs2_inode *ip = GFS2_I(file->f_dentry->d_inode);
	struct gfs2_glock *gl;
	unsigned int state;
	int flags;
	int error = 0;

	state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
	flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE;

	mutex_lock(&fp->f_fl_mutex);

	gl = fl_gh->gh_gl;
	if (gl) {
		if (fl_gh->gh_state == state)
			goto out;
		gfs2_glock_hold(gl);
		flock_lock_file_wait(file,
				     &(struct file_lock){.fl_type = F_UNLCK});
		gfs2_glock_dq_uninit(fl_gh);
	} else {
		error = gfs2_glock_get(GFS2_SB(&ip->i_inode),
				      ip->i_num.no_addr, &gfs2_flock_glops,
				      CREATE, &gl);
		if (error)
			goto out;
	}

	gfs2_holder_init(gl, state, flags, fl_gh);
	gfs2_glock_put(gl);

	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);
		gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
	}

out:
	mutex_unlock(&fp->f_fl_mutex);
	return error;
}

static void do_unflock(struct file *file, struct file_lock *fl)
{
	struct gfs2_file *fp = file->private_data;
	struct gfs2_holder *fl_gh = &fp->f_fl_gh;

	mutex_lock(&fp->f_fl_mutex);
	flock_lock_file_wait(file, fl);
	if (fl_gh->gh_gl)
		gfs2_glock_dq_uninit(fl_gh);
	mutex_unlock(&fp->f_fl_mutex);
}

/**
 * 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)
{
	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);

	if (!(fl->fl_flags & FL_FLOCK))
		return -ENOLCK;
	if ((ip->i_di.di_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
		return -ENOLCK;

	if (sdp->sd_args.ar_localflocks)
		return flock_lock_file_wait(file, fl);

	if (fl->fl_type == F_UNLCK) {
		do_unflock(file, fl);
		return 0;
	} else
		return do_flock(file, cmd, fl);
}

const struct file_operations gfs2_file_fops = {
	.llseek		= gfs2_llseek,
	.read = do_sync_read,
	.aio_read	= generic_file_aio_read,
	.write = do_sync_write,
	.aio_write	= generic_file_aio_write,
	.unlocked_ioctl	= gfs2_ioctl,
	.mmap		= gfs2_mmap,
	.open		= gfs2_open,
	.release	= gfs2_close,
	.fsync		= gfs2_fsync,
	.lock		= gfs2_lock,
	.sendfile	= generic_file_sendfile,
	.flock		= gfs2_flock,
	.splice_read	= generic_file_splice_read,
	.splice_write	= generic_file_splice_write,
};

const struct file_operations gfs2_dir_fops = {
	.readdir	= gfs2_readdir,
	.unlocked_ioctl	= gfs2_ioctl,
	.open		= gfs2_open,
	.release	= gfs2_close,
	.fsync		= gfs2_fsync,
	.lock		= gfs2_lock,
	.flock		= gfs2_flock,
};
Commit	Line	Data
b3b94faa DT	1	/*
b3b94faa DT	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3a8a9a10	3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
b3b94faa DT	4	*
	5	* This copyrighted material is made available to anyone wishing to use,
	6	* modify, copy, or redistribute it subject to the terms and conditions
e9fc2aa0	7	* of the GNU General Public License version 2.
b3b94faa DT	8	*/
	9
	10	#include <linux/sched.h>
	11	#include <linux/slab.h>
	12	#include <linux/spinlock.h>
	13	#include <linux/completion.h>
	14	#include <linux/buffer_head.h>
	15	#include <linux/pagemap.h>
	16	#include <linux/uio.h>
	17	#include <linux/blkdev.h>
	18	#include <linux/mm.h>
	19	#include <linux/smp_lock.h>
18ec7d5c	20	#include <linux/fs.h>
5c676f6d	21	#include <linux/gfs2_ondisk.h>
71b86f56 SW	22	#include <linux/ext2_fs.h>
71b86f56 SW	23	#include <linux/crc32.h>
7ea9ea83	24	#include <linux/iflags.h>
7d308590	25	#include <linux/lm_interface.h>
b3b94faa DT	26	#include <asm/uaccess.h>
	27
	28	#include "gfs2.h"
5c676f6d	29	#include "incore.h"
b3b94faa DT	30	#include "bmap.h"
	31	#include "dir.h"
	32	#include "glock.h"
	33	#include "glops.h"
	34	#include "inode.h"
b3b94faa DT	35	#include "lm.h"
	36	#include "log.h"
	37	#include "meta_io.h"
	38	#include "ops_file.h"
	39	#include "ops_vm.h"
	40	#include "quota.h"
	41	#include "rgrp.h"
	42	#include "trans.h"
5c676f6d	43	#include "util.h"
71b86f56	44	#include "eaops.h"
b3b94faa	45
b3b94faa DT	46	/* For regular, non-NFS */
	47	struct filldir_reg {
	48	struct gfs2_sbd *fdr_sbd;
	49	int fdr_prefetch;
	50
	51	filldir_t fdr_filldir;
	52	void *fdr_opaque;
	53	};
	54
61a30dcb SW	55	/*
	56	* Most fields left uninitialised to catch anybody who tries to
	57	* use them. f_flags set to prevent file_accessed() from touching
	58	* any other part of this. Its use is purely as a flag so that we
	59	* know (in readpage()) whether or not do to locking.
	60	*/
dd538c83	61	struct file gfs2_internal_file_sentinel = {
61a30dcb SW	62	.f_flags = O_NOATIME\|O_RDONLY,
	63	};
	64
18ec7d5c SW	65	static int gfs2_read_actor(read_descriptor_t desc, struct page page,
	66	unsigned long offset, unsigned long size)
	67	{
	68	char *kaddr;
	69	unsigned long count = desc->count;
	70
	71	if (size > count)
	72	size = count;
	73
	74	kaddr = kmap(page);
	75	memcpy(desc->arg.buf, kaddr + offset, size);
26c1a574	76	kunmap(page);
18ec7d5c	77
26c1a574 SW	78	desc->count = count - size;
	79	desc->written += size;
	80	desc->arg.buf += size;
	81	return size;
18ec7d5c SW	82	}
	83
	84	int gfs2_internal_read(struct gfs2_inode ip, struct file_ra_state ra_state,
	85	char buf, loff_t pos, unsigned size)
	86	{
feaa7bba	87	struct inode *inode = &ip->i_inode;
18ec7d5c SW	88	read_descriptor_t desc;
	89	desc.written = 0;
	90	desc.arg.buf = buf;
	91	desc.count = size;
	92	desc.error = 0;
61a30dcb	93	do_generic_mapping_read(inode->i_mapping, ra_state,
dd538c83	94	&gfs2_internal_file_sentinel, pos, &desc,
61a30dcb	95	gfs2_read_actor);
18ec7d5c SW	96	return desc.written ? desc.written : desc.error;
18ec7d5c SW	97	}
b3b94faa DT	98
	99	/**
	100	* gfs2_llseek - seek to a location in a file
	101	* @file: the file
	102	* @offset: the offset
	103	* @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
	104	*
	105	* SEEK_END requires the glock for the file because it references the
	106	* file's size.
	107	*
	108	* Returns: The new offset, or errno
	109	*/
	110
	111	static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
	112	{
feaa7bba	113	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
b3b94faa DT	114	struct gfs2_holder i_gh;
	115	loff_t error;
	116
b3b94faa DT	117	if (origin == 2) {
	118	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
	119	&i_gh);
	120	if (!error) {
	121	error = remote_llseek(file, offset, origin);
	122	gfs2_glock_dq_uninit(&i_gh);
	123	}
	124	} else
	125	error = remote_llseek(file, offset, origin);
	126
	127	return error;
	128	}
	129
b3b94faa	130	/**
f0e522a9	131	* filldir_func - Report a directory entry to the caller of gfs2_dir_read()
b3b94faa DT	132	* @opaque: opaque data used by the function
	133	* @name: the name of the directory entry
	134	* @length: the length of the name
	135	* @offset: the entry's offset in the directory
	136	* @inum: the inode number the entry points to
	137	* @type: the type of inode the entry points to
	138	*
	139	* Returns: 0 on success, 1 if buffer full
	140	*/
	141
f0e522a9 SW	142	static int filldir_func(void opaque, const char name, unsigned int length,
	143	u64 offset, struct gfs2_inum *inum,
	144	unsigned int type)
b3b94faa DT	145	{
	146	struct filldir_reg fdr = (struct filldir_reg )opaque;
	147	struct gfs2_sbd *sdp = fdr->fdr_sbd;
	148	int error;
	149
	150	error = fdr->fdr_filldir(fdr->fdr_opaque, name, length, offset,
4340fe62	151	inum->no_addr, type);
b3b94faa DT	152	if (error)
	153	return 1;
	154
	155	if (fdr->fdr_prefetch && !(length == 1 && *name == '.')) {
f0e522a9	156	gfs2_glock_prefetch_num(sdp, inum->no_addr, &gfs2_inode_glops,
b3b94faa	157	LM_ST_SHARED, LM_FLAG_TRY \| LM_FLAG_ANY);
f0e522a9	158	gfs2_glock_prefetch_num(sdp, inum->no_addr, &gfs2_iopen_glops,
b3b94faa DT	159	LM_ST_SHARED, LM_FLAG_TRY);
	160	}
	161
	162	return 0;
	163	}
	164
	165	/**
f0e522a9	166	* gfs2_readdir - Read directory entries from a directory
b3b94faa DT	167	* @file: The directory to read from
	168	* @dirent: Buffer for dirents
	169	* @filldir: Function used to do the copying
	170	*
	171	* Returns: errno
	172	*/
	173
f0e522a9	174	static int gfs2_readdir(struct file file, void dirent, filldir_t filldir)
b3b94faa	175	{
71b86f56	176	struct inode *dir = file->f_mapping->host;
feaa7bba	177	struct gfs2_inode *dip = GFS2_I(dir);
b3b94faa DT	178	struct filldir_reg fdr;
b3b94faa DT	179	struct gfs2_holder d_gh;
cd915493	180	u64 offset = file->f_pos;
b3b94faa DT	181	int error;
b3b94faa DT	182
feaa7bba	183	fdr.fdr_sbd = GFS2_SB(dir);
b3b94faa DT	184	fdr.fdr_prefetch = 1;
	185	fdr.fdr_filldir = filldir;
	186	fdr.fdr_opaque = dirent;
	187
	188	gfs2_holder_init(dip->i_gl, LM_ST_SHARED, GL_ATIME, &d_gh);
	189	error = gfs2_glock_nq_atime(&d_gh);
	190	if (error) {
	191	gfs2_holder_uninit(&d_gh);
	192	return error;
	193	}
	194
f0e522a9	195	error = gfs2_dir_read(dir, &offset, &fdr, filldir_func);
b3b94faa DT	196
	197	gfs2_glock_dq_uninit(&d_gh);
	198
b3b94faa DT	199	file->f_pos = offset;
b3b94faa DT	200
b3b94faa DT	201	return error;
	202	}
	203
b3b94faa	204
7ea9ea83 SW	205	static const u32 iflags_to_gfs2[32] = {
	206	[iflag_Sync] = GFS2_DIF_SYNC,
	207	[iflag_Immutable] = GFS2_DIF_IMMUTABLE,
	208	[iflag_Append] = GFS2_DIF_APPENDONLY,
	209	[iflag_NoAtime] = GFS2_DIF_NOATIME,
	210	[iflag_Index] = GFS2_DIF_EXHASH,
	211	[iflag_JournalData] = GFS2_DIF_JDATA,
	212	[iflag_DirectIO] = GFS2_DIF_DIRECTIO,
71b86f56 SW	213	};
71b86f56 SW	214
7ea9ea83 SW	215	static const u32 gfs2_to_iflags[32] = {
	216	[gfs2fl_Sync] = IFLAG_SYNC,
	217	[gfs2fl_Immutable] = IFLAG_IMMUTABLE,
	218	[gfs2fl_AppendOnly] = IFLAG_APPEND,
	219	[gfs2fl_NoAtime] = IFLAG_NOATIME,
	220	[gfs2fl_ExHash] = IFLAG_INDEX,
	221	[gfs2fl_Jdata] = IFLAG_JOURNAL_DATA,
	222	[gfs2fl_Directio] = IFLAG_DIRECTIO,
4bcf7091 SW	223	[gfs2fl_InheritDirectio] = IFLAG_DIRECTIO,
4bcf7091 SW	224	[gfs2fl_InheritJdata] = IFLAG_JOURNAL_DATA,
7ea9ea83	225	};
71b86f56	226
b09e593d	227	static int gfs2_get_flags(struct file filp, u32 __user ptr)
71b86f56	228	{
b09e593d	229	struct inode *inode = filp->f_dentry->d_inode;
feaa7bba	230	struct gfs2_inode *ip = GFS2_I(inode);
71b86f56 SW	231	struct gfs2_holder gh;
71b86f56 SW	232	int error;
7ea9ea83	233	u32 iflags;
71b86f56 SW	234
	235	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
	236	error = gfs2_glock_nq_m_atime(1, &gh);
	237	if (error)
	238	return error;
907b9bce	239
7ea9ea83 SW	240	iflags = iflags_cvt(gfs2_to_iflags, ip->i_di.di_flags);
7ea9ea83 SW	241	if (put_user(iflags, ptr))
71b86f56 SW	242	error = -EFAULT;
	243
	244	gfs2_glock_dq_m(1, &gh);
	245	gfs2_holder_uninit(&gh);
	246	return error;
	247	}
	248
	249	/* Flags that can be set by user space */
	250	#define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA\| \
	251	GFS2_DIF_DIRECTIO\| \
	252	GFS2_DIF_IMMUTABLE\| \
	253	GFS2_DIF_APPENDONLY\| \
	254	GFS2_DIF_NOATIME\| \
	255	GFS2_DIF_SYNC\| \
	256	GFS2_DIF_SYSTEM\| \
	257	GFS2_DIF_INHERIT_DIRECTIO\| \
	258	GFS2_DIF_INHERIT_JDATA)
	259
	260	/**
	261	* gfs2_set_flags - set flags on an inode
	262	* @inode: The inode
	263	* @flags: The flags to set
	264	* @mask: Indicates which flags are valid
	265	*
	266	*/
b09e593d	267	static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
71b86f56	268	{
b09e593d	269	struct inode *inode = filp->f_dentry->d_inode;
feaa7bba SW	270	struct gfs2_inode *ip = GFS2_I(inode);
feaa7bba SW	271	struct gfs2_sbd *sdp = GFS2_SB(inode);
71b86f56 SW	272	struct buffer_head *bh;
	273	struct gfs2_holder gh;
	274	int error;
55eccc6d	275	u32 new_flags, flags;
71b86f56	276
71b86f56	277	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
52f341cf	278	if (error)
71b86f56 SW	279	return error;
71b86f56 SW	280
55eccc6d SW	281	flags = ip->i_di.di_flags;
55eccc6d SW	282	new_flags = (flags & ~mask) \| (reqflags & mask);
71b86f56 SW	283	if ((new_flags ^ flags) == 0)
	284	goto out;
	285
4bcf7091 SW	286	if (S_ISDIR(inode->i_mode)) {
	287	if ((new_flags ^ flags) & GFS2_DIF_JDATA)
	288	new_flags ^= (GFS2_DIF_JDATA\|GFS2_DIF_INHERIT_JDATA);
	289	if ((new_flags ^ flags) & GFS2_DIF_DIRECTIO)
	290	new_flags ^= (GFS2_DIF_DIRECTIO\|GFS2_DIF_INHERIT_DIRECTIO);
	291	}
	292
71b86f56 SW	293	error = -EINVAL;
	294	if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET)
	295	goto out;
	296
71b86f56 SW	297	error = -EPERM;
	298	if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE))
	299	goto out;
	300	if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY))
	301	goto out;
907b9bce	302	if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
b9cb9813	303	!capable(CAP_LINUX_IMMUTABLE))
71b86f56	304	goto out;
b9cb9813	305	if (!IS_IMMUTABLE(inode)) {
faf450ef	306	error = permission(inode, MAY_WRITE, NULL);
b9cb9813 SW	307	if (error)
	308	goto out;
	309	}
71b86f56	310
55eccc6d	311	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
71b86f56 SW	312	if (error)
71b86f56 SW	313	goto out;
55eccc6d SW	314	error = gfs2_meta_inode_buffer(ip, &bh);
	315	if (error)
	316	goto out_trans_end;
71b86f56 SW	317	gfs2_trans_add_bh(ip->i_gl, bh, 1);
	318	ip->i_di.di_flags = new_flags;
	319	gfs2_dinode_out(&ip->i_di, bh->b_data);
	320	brelse(bh);
55eccc6d SW	321	out_trans_end:
55eccc6d SW	322	gfs2_trans_end(sdp);
71b86f56 SW	323	out:
	324	gfs2_glock_dq_uninit(&gh);
	325	return error;
	326	}
	327
b09e593d	328	static int gfs2_set_flags(struct file filp, u32 __user ptr)
71b86f56	329	{
7ea9ea83 SW	330	u32 iflags, gfsflags;
7ea9ea83 SW	331	if (get_user(iflags, ptr))
71b86f56	332	return -EFAULT;
7ea9ea83	333	gfsflags = iflags_cvt(iflags_to_gfs2, iflags);
b09e593d	334	return do_gfs2_set_flags(filp, gfsflags, ~0);
71b86f56 SW	335	}
71b86f56 SW	336
b09e593d	337	static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
71b86f56 SW	338	{
71b86f56 SW	339	switch(cmd) {
7ea9ea83	340	case IFLAGS_GET_IOC:
b09e593d	341	return gfs2_get_flags(filp, (u32 __user *)arg);
7ea9ea83	342	case IFLAGS_SET_IOC:
b09e593d	343	return gfs2_set_flags(filp, (u32 __user *)arg);
71b86f56 SW	344	}
	345	return -ENOTTY;
	346	}
	347
	348
b3b94faa DT	349	/**
	350	* gfs2_mmap -
	351	* @file: The file to map
	352	* @vma: The VMA which described the mapping
	353	*
	354	* Returns: 0 or error code
	355	*/
	356
	357	static int gfs2_mmap(struct file file, struct vm_area_struct vma)
	358	{
feaa7bba	359	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
b3b94faa DT	360	struct gfs2_holder i_gh;
	361	int error;
	362
b3b94faa DT	363	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
	364	error = gfs2_glock_nq_atime(&i_gh);
	365	if (error) {
	366	gfs2_holder_uninit(&i_gh);
	367	return error;
	368	}
	369
18ec7d5c SW	370	/* This is VM_MAYWRITE instead of VM_WRITE because a call
	371	to mprotect() can turn on VM_WRITE later. */
	372
	373	if ((vma->vm_flags & (VM_MAYSHARE \| VM_MAYWRITE)) ==
	374	(VM_MAYSHARE \| VM_MAYWRITE))
	375	vma->vm_ops = &gfs2_vm_ops_sharewrite;
	376	else
	377	vma->vm_ops = &gfs2_vm_ops_private;
b3b94faa DT	378
	379	gfs2_glock_dq_uninit(&i_gh);
	380
	381	return error;
	382	}
	383
	384	/**
	385	* gfs2_open - open a file
	386	* @inode: the inode to open
	387	* @file: the struct file for this opening
	388	*
	389	* Returns: errno
	390	*/
	391
	392	static int gfs2_open(struct inode inode, struct file file)
	393	{
feaa7bba	394	struct gfs2_inode *ip = GFS2_I(inode);
b3b94faa DT	395	struct gfs2_holder i_gh;
	396	struct gfs2_file *fp;
	397	int error;
	398
b3b94faa DT	399	fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
	400	if (!fp)
	401	return -ENOMEM;
	402
f55ab26a	403	mutex_init(&fp->f_fl_mutex);
b3b94faa	404
feaa7bba	405	gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
5c676f6d	406	file->private_data = fp;
b3b94faa DT	407
	408	if (S_ISREG(ip->i_di.di_mode)) {
	409	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
	410	&i_gh);
	411	if (error)
	412	goto fail;
	413
	414	if (!(file->f_flags & O_LARGEFILE) &&
	415	ip->i_di.di_size > MAX_NON_LFS) {
	416	error = -EFBIG;
	417	goto fail_gunlock;
	418	}
	419
	420	/* Listen to the Direct I/O flag */
	421
	422	if (ip->i_di.di_flags & GFS2_DIF_DIRECTIO)
	423	file->f_flags \|= O_DIRECT;
	424
b3b94faa DT	425	gfs2_glock_dq_uninit(&i_gh);
	426	}
	427
	428	return 0;
	429
420b9e5e	430	fail_gunlock:
b3b94faa	431	gfs2_glock_dq_uninit(&i_gh);
420b9e5e	432	fail:
5c676f6d	433	file->private_data = NULL;
b3b94faa	434	kfree(fp);
b3b94faa DT	435	return error;
	436	}
	437
	438	/**
	439	* gfs2_close - called to close a struct file
	440	* @inode: the inode the struct file belongs to
	441	* @file: the struct file being closed
	442	*
	443	* Returns: errno
	444	*/
	445
	446	static int gfs2_close(struct inode inode, struct file file)
	447	{
5c676f6d	448	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
b3b94faa DT	449	struct gfs2_file *fp;
b3b94faa DT	450
5c676f6d SW	451	fp = file->private_data;
5c676f6d SW	452	file->private_data = NULL;
b3b94faa DT	453
	454	if (gfs2_assert_warn(sdp, fp))
	455	return -EIO;
	456
	457	kfree(fp);
	458
	459	return 0;
	460	}
	461
	462	/**
	463	* gfs2_fsync - sync the dirty data for a file (across the cluster)
	464	* @file: the file that points to the dentry (we ignore this)
	465	* @dentry: the dentry that points to the inode to sync
	466	*
	467	* Returns: errno
	468	*/
	469
	470	static int gfs2_fsync(struct file file, struct dentry dentry, int datasync)
	471	{
feaa7bba	472	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
b3b94faa	473
b09e593d	474	gfs2_log_flush(ip->i_gl->gl_sbd, ip->i_gl);
b3b94faa DT	475
	476	return 0;
	477	}
	478
	479	/**
	480	* gfs2_lock - acquire/release a posix lock on a file
	481	* @file: the file pointer
	482	* @cmd: either modify or retrieve lock state, possibly wait
	483	* @fl: type and range of lock
	484	*
	485	* Returns: errno
	486	*/
	487
	488	static int gfs2_lock(struct file file, int cmd, struct file_lock fl)
	489	{
feaa7bba SW	490	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
feaa7bba SW	491	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
b3b94faa DT	492	struct lm_lockname name =
	493	{ .ln_number = ip->i_num.no_addr,
	494	.ln_type = LM_TYPE_PLOCK };
	495
b3b94faa DT	496	if (!(fl->fl_flags & FL_POSIX))
	497	return -ENOLCK;
	498	if ((ip->i_di.di_mode & (S_ISGID \| S_IXGRP)) == S_ISGID)
	499	return -ENOLCK;
	500
	501	if (sdp->sd_args.ar_localflocks) {
	502	if (IS_GETLK(cmd)) {
8628de05 SW	503	struct file_lock tmp;
	504	int ret;
	505	ret = posix_test_lock(file, fl, &tmp);
b3b94faa	506	fl->fl_type = F_UNLCK;
8628de05 SW	507	if (ret)
8628de05 SW	508	memcpy(fl, &tmp, sizeof(struct file_lock));
b3b94faa DT	509	return 0;
b3b94faa DT	510	} else {
8628de05	511	return posix_lock_file_wait(file, fl);
b3b94faa DT	512	}
	513	}
	514
	515	if (IS_GETLK(cmd))
	516	return gfs2_lm_plock_get(sdp, &name, file, fl);
	517	else if (fl->fl_type == F_UNLCK)
	518	return gfs2_lm_punlock(sdp, &name, file, fl);
	519	else
	520	return gfs2_lm_plock(sdp, &name, file, cmd, fl);
	521	}
	522
b3b94faa DT	523	static int do_flock(struct file file, int cmd, struct file_lock fl)
b3b94faa DT	524	{
5c676f6d	525	struct gfs2_file *fp = file->private_data;
b3b94faa	526	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
feaa7bba	527	struct gfs2_inode *ip = GFS2_I(file->f_dentry->d_inode);
b3b94faa DT	528	struct gfs2_glock *gl;
	529	unsigned int state;
	530	int flags;
	531	int error = 0;
	532
	533	state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
26c1a574	534	flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) \| GL_EXACT \| GL_NOCACHE;
b3b94faa	535
f55ab26a	536	mutex_lock(&fp->f_fl_mutex);
b3b94faa DT	537
	538	gl = fl_gh->gh_gl;
	539	if (gl) {
	540	if (fl_gh->gh_state == state)
	541	goto out;
	542	gfs2_glock_hold(gl);
	543	flock_lock_file_wait(file,
907b9bce	544	&(struct file_lock){.fl_type = F_UNLCK});
b3b94faa DT	545	gfs2_glock_dq_uninit(fl_gh);
b3b94faa DT	546	} else {
feaa7bba	547	error = gfs2_glock_get(GFS2_SB(&ip->i_inode),
b3b94faa DT	548	ip->i_num.no_addr, &gfs2_flock_glops,
	549	CREATE, &gl);
	550	if (error)
	551	goto out;
	552	}
	553
	554	gfs2_holder_init(gl, state, flags, fl_gh);
	555	gfs2_glock_put(gl);
	556
	557	error = gfs2_glock_nq(fl_gh);
	558	if (error) {
	559	gfs2_holder_uninit(fl_gh);
	560	if (error == GLR_TRYFAILED)
	561	error = -EAGAIN;
	562	} else {
	563	error = flock_lock_file_wait(file, fl);
feaa7bba	564	gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
b3b94faa DT	565	}
b3b94faa DT	566
420b9e5e	567	out:
f55ab26a	568	mutex_unlock(&fp->f_fl_mutex);
b3b94faa DT	569	return error;
	570	}
	571
	572	static void do_unflock(struct file file, struct file_lock fl)
	573	{
5c676f6d	574	struct gfs2_file *fp = file->private_data;
b3b94faa DT	575	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
b3b94faa DT	576
f55ab26a	577	mutex_lock(&fp->f_fl_mutex);
b3b94faa DT	578	flock_lock_file_wait(file, fl);
	579	if (fl_gh->gh_gl)
	580	gfs2_glock_dq_uninit(fl_gh);
f55ab26a	581	mutex_unlock(&fp->f_fl_mutex);
b3b94faa DT	582	}
	583
	584	/**
	585	* gfs2_flock - acquire/release a flock lock on a file
	586	* @file: the file pointer
	587	* @cmd: either modify or retrieve lock state, possibly wait
	588	* @fl: type and range of lock
	589	*
	590	* Returns: errno
	591	*/
	592
	593	static int gfs2_flock(struct file file, int cmd, struct file_lock fl)
	594	{
feaa7bba SW	595	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
feaa7bba SW	596	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
b3b94faa	597
b3b94faa DT	598	if (!(fl->fl_flags & FL_FLOCK))
	599	return -ENOLCK;
	600	if ((ip->i_di.di_mode & (S_ISGID \| S_IXGRP)) == S_ISGID)
	601	return -ENOLCK;
	602
	603	if (sdp->sd_args.ar_localflocks)
	604	return flock_lock_file_wait(file, fl);
	605
	606	if (fl->fl_type == F_UNLCK) {
	607	do_unflock(file, fl);
	608	return 0;
	609	} else
	610	return do_flock(file, cmd, fl);
	611	}
	612
b0dd9308	613	const struct file_operations gfs2_file_fops = {
26c1a574	614	.llseek = gfs2_llseek,
930cc237	615	.read = do_sync_read,
26c1a574	616	.aio_read = generic_file_aio_read,
930cc237	617	.write = do_sync_write,
26c1a574 SW	618	.aio_write = generic_file_aio_write,
	619	.unlocked_ioctl = gfs2_ioctl,
	620	.mmap = gfs2_mmap,
	621	.open = gfs2_open,
	622	.release = gfs2_close,
	623	.fsync = gfs2_fsync,
	624	.lock = gfs2_lock,
	625	.sendfile = generic_file_sendfile,
	626	.flock = gfs2_flock,
	627	.splice_read = generic_file_splice_read,
	628	.splice_write = generic_file_splice_write,
b3b94faa DT	629	};
b3b94faa DT	630
b0dd9308	631	const struct file_operations gfs2_dir_fops = {
26c1a574 SW	632	.readdir = gfs2_readdir,
	633	.unlocked_ioctl = gfs2_ioctl,
	634	.open = gfs2_open,
	635	.release = gfs2_close,
	636	.fsync = gfs2_fsync,
	637	.lock = gfs2_lock,
	638	.flock = gfs2_flock,
b3b94faa DT	639	};
b3b94faa DT	640