[deliverable/linux.git] / fs / xfs / linux-2.6 / xfs_file.c

/*
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.  All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Further, this software is distributed without any warranty that it is
 * free of the rightful claim of any third person regarding infringement
 * or the like.  Any license provided herein, whether implied or
 * otherwise, applies only to this software file.  Patent licenses, if
 * any, provided herein do not apply to combinations of this program with
 * other software, or any other product whatsoever.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write the Free Software Foundation, Inc., 59
 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
 *
 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
 * Mountain View, CA  94043, or:
 *
 * http://www.sgi.com
 *
 * For further information regarding this notice, see:
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */

#include "xfs.h"
#include "xfs_inum.h"
#include "xfs_log.h"
#include "xfs_sb.h"
#include "xfs_dir.h"
#include "xfs_dir2.h"
#include "xfs_trans.h"
#include "xfs_dmapi.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
#include "xfs_alloc_btree.h"
#include "xfs_ialloc_btree.h"
#include "xfs_alloc.h"
#include "xfs_btree.h"
#include "xfs_attr_sf.h"
#include "xfs_dir_sf.h"
#include "xfs_dir2_sf.h"
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_error.h"
#include "xfs_rw.h"
#include "xfs_ioctl32.h"

#include <linux/dcache.h>
#include <linux/smp_lock.h>

static struct vm_operations_struct linvfs_file_vm_ops;
#ifdef CONFIG_XFS_DMAPI
static struct vm_operations_struct linvfs_dmapi_file_vm_ops;
#endif

STATIC inline ssize_t
__linvfs_read(
	struct kiocb		*iocb,
	char			__user *buf,
	int			ioflags,
	size_t			count,
	loff_t			pos)
{
	struct iovec		iov = {buf, count};
	struct file		*file = iocb->ki_filp;
	vnode_t			*vp = LINVFS_GET_VP(file->f_dentry->d_inode);
	ssize_t			rval;

	BUG_ON(iocb->ki_pos != pos);

	if (unlikely(file->f_flags & O_DIRECT))
		ioflags |= IO_ISDIRECT;
	VOP_READ(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL, rval);
	return rval;
}


STATIC ssize_t
linvfs_aio_read(
	struct kiocb		*iocb,
	char			__user *buf,
	size_t			count,
	loff_t			pos)
{
	return __linvfs_read(iocb, buf, IO_ISAIO, count, pos);
}

STATIC ssize_t
linvfs_aio_read_invis(
	struct kiocb		*iocb,
	char			__user *buf,
	size_t			count,
	loff_t			pos)
{
	return __linvfs_read(iocb, buf, IO_ISAIO|IO_INVIS, count, pos);
}


STATIC inline ssize_t
__linvfs_write(
	struct kiocb	*iocb,
	const char	__user *buf,
	int		ioflags,
	size_t		count,
	loff_t		pos)
{
	struct iovec	iov = {(void __user *)buf, count};
	struct file	*file = iocb->ki_filp;
	struct inode	*inode = file->f_mapping->host;
	vnode_t		*vp = LINVFS_GET_VP(inode);
	ssize_t		rval;

	BUG_ON(iocb->ki_pos != pos);
	if (unlikely(file->f_flags & O_DIRECT))
		ioflags |= IO_ISDIRECT;

	VOP_WRITE(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL, rval);
	return rval;
}


STATIC ssize_t
linvfs_aio_write(
	struct kiocb		*iocb,
	const char		__user *buf,
	size_t			count,
	loff_t			pos)
{
	return __linvfs_write(iocb, buf, IO_ISAIO, count, pos);
}

STATIC ssize_t
linvfs_aio_write_invis(
	struct kiocb		*iocb,
	const char		__user *buf,
	size_t			count,
	loff_t			pos)
{
	return __linvfs_write(iocb, buf, IO_ISAIO|IO_INVIS, count, pos);
}


STATIC inline ssize_t
__linvfs_readv(
	struct file		*file,
	const struct iovec 	*iov,
	int			ioflags,
	unsigned long		nr_segs,
	loff_t			*ppos)
{
	struct inode	*inode = file->f_mapping->host;
	vnode_t		*vp = LINVFS_GET_VP(inode);
	struct		kiocb kiocb;
	ssize_t		rval;

	init_sync_kiocb(&kiocb, file);
	kiocb.ki_pos = *ppos;

	if (unlikely(file->f_flags & O_DIRECT))
		ioflags |= IO_ISDIRECT;
	VOP_READ(vp, &kiocb, iov, nr_segs, &kiocb.ki_pos, ioflags, NULL, rval);

	*ppos = kiocb.ki_pos;
	return rval;
}

STATIC ssize_t
linvfs_readv(
	struct file		*file,
	const struct iovec 	*iov,
	unsigned long		nr_segs,
	loff_t			*ppos)
{
	return __linvfs_readv(file, iov, 0, nr_segs, ppos);
}

STATIC ssize_t
linvfs_readv_invis(
	struct file		*file,
	const struct iovec 	*iov,
	unsigned long		nr_segs,
	loff_t			*ppos)
{
	return __linvfs_readv(file, iov, IO_INVIS, nr_segs, ppos);
}


STATIC inline ssize_t
__linvfs_writev(
	struct file		*file,
	const struct iovec 	*iov,
	int			ioflags,
	unsigned long		nr_segs,
	loff_t			*ppos)
{
	struct inode	*inode = file->f_mapping->host;
	vnode_t		*vp = LINVFS_GET_VP(inode);
	struct		kiocb kiocb;
	ssize_t		rval;

	init_sync_kiocb(&kiocb, file);
	kiocb.ki_pos = *ppos;
	if (unlikely(file->f_flags & O_DIRECT))
		ioflags |= IO_ISDIRECT;

	VOP_WRITE(vp, &kiocb, iov, nr_segs, &kiocb.ki_pos, ioflags, NULL, rval);

	*ppos = kiocb.ki_pos;
	return rval;
}


STATIC ssize_t
linvfs_writev(
	struct file		*file,
	const struct iovec 	*iov,
	unsigned long		nr_segs,
	loff_t			*ppos)
{
	return __linvfs_writev(file, iov, 0, nr_segs, ppos);
}

STATIC ssize_t
linvfs_writev_invis(
	struct file		*file,
	const struct iovec 	*iov,
	unsigned long		nr_segs,
	loff_t			*ppos)
{
	return __linvfs_writev(file, iov, IO_INVIS, nr_segs, ppos);
}

STATIC ssize_t
linvfs_sendfile(
	struct file		*filp,
	loff_t			*ppos,
	size_t			count,
	read_actor_t		actor,
	void			*target)
{
	vnode_t			*vp = LINVFS_GET_VP(filp->f_dentry->d_inode);
	ssize_t			rval;

	VOP_SENDFILE(vp, filp, ppos, 0, count, actor, target, NULL, rval);
	return rval;
}


STATIC int
linvfs_open(
	struct inode	*inode,
	struct file	*filp)
{
	vnode_t		*vp = LINVFS_GET_VP(inode);
	int		error;

	if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
		return -EFBIG;

	ASSERT(vp);
	VOP_OPEN(vp, NULL, error);
	return -error;
}


STATIC int
linvfs_release(
	struct inode	*inode,
	struct file	*filp)
{
	vnode_t		*vp = LINVFS_GET_VP(inode);
	int		error = 0;

	if (vp)
		VOP_RELEASE(vp, error);
	return -error;
}


STATIC int
linvfs_fsync(
	struct file	*filp,
	struct dentry	*dentry,
	int		datasync)
{
	struct inode	*inode = dentry->d_inode;
	vnode_t		*vp = LINVFS_GET_VP(inode);
	int		error;
	int		flags = FSYNC_WAIT;

	if (datasync)
		flags |= FSYNC_DATA;

	ASSERT(vp);
	VOP_FSYNC(vp, flags, NULL, (xfs_off_t)0, (xfs_off_t)-1, error);
	return -error;
}

/*
 * linvfs_readdir maps to VOP_READDIR().
 * We need to build a uio, cred, ...
 */

#define nextdp(dp)      ((struct xfs_dirent *)((char *)(dp) + (dp)->d_reclen))

#ifdef CONFIG_XFS_DMAPI

STATIC struct page *
linvfs_filemap_nopage(
	struct vm_area_struct	*area,
	unsigned long		address,
	int			*type)
{
	struct inode	*inode = area->vm_file->f_dentry->d_inode;
	vnode_t		*vp = LINVFS_GET_VP(inode);
	xfs_mount_t	*mp = XFS_VFSTOM(vp->v_vfsp);
	int		error;

	ASSERT_ALWAYS(vp->v_vfsp->vfs_flag & VFS_DMI);

	error = XFS_SEND_MMAP(mp, area, 0);
	if (error)
		return NULL;

	return filemap_nopage(area, address, type);
}

#endif /* CONFIG_XFS_DMAPI */


STATIC int
linvfs_readdir(
	struct file	*filp,
	void		*dirent,
	filldir_t	filldir)
{
	int		error = 0;
	vnode_t		*vp;
	uio_t		uio;
	iovec_t		iov;
	int		eof = 0;
	caddr_t		read_buf;
	int		namelen, size = 0;
	size_t		rlen = PAGE_CACHE_SIZE;
	xfs_off_t	start_offset, curr_offset;
	xfs_dirent_t	*dbp = NULL;

	vp = LINVFS_GET_VP(filp->f_dentry->d_inode);
	ASSERT(vp);

	/* Try fairly hard to get memory */
	do {
		if ((read_buf = (caddr_t)kmalloc(rlen, GFP_KERNEL)))
			break;
		rlen >>= 1;
	} while (rlen >= 1024);

	if (read_buf == NULL)
		return -ENOMEM;

	uio.uio_iov = &iov;
	uio.uio_segflg = UIO_SYSSPACE;
	curr_offset = filp->f_pos;
	if (filp->f_pos != 0x7fffffff)
		uio.uio_offset = filp->f_pos;
	else
		uio.uio_offset = 0xffffffff;

	while (!eof) {
		uio.uio_resid = iov.iov_len = rlen;
		iov.iov_base = read_buf;
		uio.uio_iovcnt = 1;

		start_offset = uio.uio_offset;

		VOP_READDIR(vp, &uio, NULL, &eof, error);
		if ((uio.uio_offset == start_offset) || error) {
			size = 0;
			break;
		}

		size = rlen - uio.uio_resid;
		dbp = (xfs_dirent_t *)read_buf;
		while (size > 0) {
			namelen = strlen(dbp->d_name);

			if (filldir(dirent, dbp->d_name, namelen,
					(loff_t) curr_offset & 0x7fffffff,
					(ino_t) dbp->d_ino,
					DT_UNKNOWN)) {
				goto done;
			}
			size -= dbp->d_reclen;
			curr_offset = (loff_t)dbp->d_off /* & 0x7fffffff */;
			dbp = nextdp(dbp);
		}
	}
done:
	if (!error) {
		if (size == 0)
			filp->f_pos = uio.uio_offset & 0x7fffffff;
		else if (dbp)
			filp->f_pos = curr_offset;
	}

	kfree(read_buf);
	return -error;
}


STATIC int
linvfs_file_mmap(
	struct file	*filp,
	struct vm_area_struct *vma)
{
	struct inode	*ip = filp->f_dentry->d_inode;
	vnode_t		*vp = LINVFS_GET_VP(ip);
	vattr_t		va = { .va_mask = XFS_AT_UPDATIME };
	int		error;

	vma->vm_ops = &linvfs_file_vm_ops;

#ifdef CONFIG_XFS_DMAPI
	if (vp->v_vfsp->vfs_flag & VFS_DMI) {
		vma->vm_ops = &linvfs_dmapi_file_vm_ops;
	}
#endif /* CONFIG_XFS_DMAPI */

	VOP_SETATTR(vp, &va, XFS_AT_UPDATIME, NULL, error);
	if (!error)
		vn_revalidate(vp);	/* update Linux inode flags */
	return 0;
}


STATIC long
linvfs_ioctl(
	struct file	*filp,
	unsigned int	cmd,
	unsigned long	arg)
{
	int		error;
	struct inode *inode = filp->f_dentry->d_inode;
	vnode_t		*vp = LINVFS_GET_VP(inode);

	VOP_IOCTL(vp, inode, filp, 0, cmd, (void __user *)arg, error);
	VMODIFY(vp);

	/* NOTE:  some of the ioctl's return positive #'s as a
	 *	  byte count indicating success, such as
	 *	  readlink_by_handle.  So we don't "sign flip"
	 *	  like most other routines.  This means true
	 *	  errors need to be returned as a negative value.
	 */
	return error;
}

STATIC long
linvfs_ioctl_invis(
	struct file	*filp,
	unsigned int	cmd,
	unsigned long	arg)
{
	int		error;
	struct inode *inode = filp->f_dentry->d_inode;
	vnode_t		*vp = LINVFS_GET_VP(inode);

	ASSERT(vp);
	VOP_IOCTL(vp, inode, filp, IO_INVIS, cmd, (void __user *)arg, error);
	VMODIFY(vp);

	/* NOTE:  some of the ioctl's return positive #'s as a
	 *	  byte count indicating success, such as
	 *	  readlink_by_handle.  So we don't "sign flip"
	 *	  like most other routines.  This means true
	 *	  errors need to be returned as a negative value.
	 */
	return error;
}

#ifdef CONFIG_XFS_DMAPI
#ifdef HAVE_VMOP_MPROTECT
STATIC int
linvfs_mprotect(
	struct vm_area_struct *vma,
	unsigned int	newflags)
{
	vnode_t		*vp = LINVFS_GET_VP(vma->vm_file->f_dentry->d_inode);
	int		error = 0;

	if (vp->v_vfsp->vfs_flag & VFS_DMI) {
		if ((vma->vm_flags & VM_MAYSHARE) &&
		    (newflags & VM_WRITE) && !(vma->vm_flags & VM_WRITE)) {
			xfs_mount_t	*mp = XFS_VFSTOM(vp->v_vfsp);

			error = XFS_SEND_MMAP(mp, vma, VM_WRITE);
		    }
	}
	return error;
}
#endif /* HAVE_VMOP_MPROTECT */
#endif /* CONFIG_XFS_DMAPI */

#ifdef HAVE_FOP_OPEN_EXEC
/* If the user is attempting to execute a file that is offline then
 * we have to trigger a DMAPI READ event before the file is marked as busy
 * otherwise the invisible I/O will not be able to write to the file to bring
 * it back online.
 */
STATIC int
linvfs_open_exec(
	struct inode	*inode)
{
	vnode_t		*vp = LINVFS_GET_VP(inode);
	xfs_mount_t	*mp = XFS_VFSTOM(vp->v_vfsp);
	int		error = 0;
	bhv_desc_t	*bdp;
	xfs_inode_t	*ip;

	if (vp->v_vfsp->vfs_flag & VFS_DMI) {
		bdp = vn_bhv_lookup(VN_BHV_HEAD(vp), &xfs_vnodeops);
		if (!bdp) {
			error = -EINVAL;
			goto open_exec_out;
		}
		ip = XFS_BHVTOI(bdp);
		if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_READ)) {
			error = -XFS_SEND_DATA(mp, DM_EVENT_READ, vp,
					       0, 0, 0, NULL);
		}
	}
open_exec_out:
	return error;
}
#endif /* HAVE_FOP_OPEN_EXEC */

struct file_operations linvfs_file_operations = {
	.llseek		= generic_file_llseek,
	.read		= do_sync_read,
	.write		= do_sync_write,
	.readv		= linvfs_readv,
	.writev		= linvfs_writev,
	.aio_read	= linvfs_aio_read,
	.aio_write	= linvfs_aio_write,
	.sendfile	= linvfs_sendfile,
	.unlocked_ioctl	= linvfs_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= linvfs_compat_ioctl,
#endif
	.mmap		= linvfs_file_mmap,
	.open		= linvfs_open,
	.release	= linvfs_release,
	.fsync		= linvfs_fsync,
#ifdef HAVE_FOP_OPEN_EXEC
	.open_exec	= linvfs_open_exec,
#endif
};

struct file_operations linvfs_invis_file_operations = {
	.llseek		= generic_file_llseek,
	.read		= do_sync_read,
	.write		= do_sync_write,
	.readv		= linvfs_readv_invis,
	.writev		= linvfs_writev_invis,
	.aio_read	= linvfs_aio_read_invis,
	.aio_write	= linvfs_aio_write_invis,
	.sendfile	= linvfs_sendfile,
	.unlocked_ioctl	= linvfs_ioctl_invis,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= linvfs_compat_invis_ioctl,
#endif
	.mmap		= linvfs_file_mmap,
	.open		= linvfs_open,
	.release	= linvfs_release,
	.fsync		= linvfs_fsync,
};


struct file_operations linvfs_dir_operations = {
	.read		= generic_read_dir,
	.readdir	= linvfs_readdir,
	.unlocked_ioctl	= linvfs_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= linvfs_compat_ioctl,
#endif
	.fsync		= linvfs_fsync,
};

static struct vm_operations_struct linvfs_file_vm_ops = {
	.nopage		= filemap_nopage,
	.populate	= filemap_populate,
};

#ifdef CONFIG_XFS_DMAPI
static struct vm_operations_struct linvfs_dmapi_file_vm_ops = {
	.nopage		= linvfs_filemap_nopage,
	.populate	= filemap_populate,
#ifdef HAVE_VMOP_MPROTECT
	.mprotect	= linvfs_mprotect,
#endif
};
#endif /* CONFIG_XFS_DMAPI */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (c) 2000-2005 Silicon Graphics, Inc. All Rights Reserved.
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of version 2 of the GNU General Public License as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it would be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	11	*
	12	* Further, this software is distributed without any warranty that it is
	13	* free of the rightful claim of any third person regarding infringement
	14	* or the like. Any license provided herein, whether implied or
	15	* otherwise, applies only to this software file. Patent licenses, if
	16	* any, provided herein do not apply to combinations of this program with
	17	* other software, or any other product whatsoever.
	18	*
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write the Free Software Foundation, Inc., 59
	21	* Temple Place - Suite 330, Boston MA 02111-1307, USA.
	22	*
	23	* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
	24	* Mountain View, CA 94043, or:
	25	*
	26	* http://www.sgi.com
	27	*
	28	* For further information regarding this notice, see:
	29	*
	30	* http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
	31	*/
	32
	33	#include "xfs.h"
	34	#include "xfs_inum.h"
	35	#include "xfs_log.h"
	36	#include "xfs_sb.h"
	37	#include "xfs_dir.h"
	38	#include "xfs_dir2.h"
	39	#include "xfs_trans.h"
	40	#include "xfs_dmapi.h"
	41	#include "xfs_mount.h"
	42	#include "xfs_bmap_btree.h"
	43	#include "xfs_alloc_btree.h"
	44	#include "xfs_ialloc_btree.h"
	45	#include "xfs_alloc.h"
	46	#include "xfs_btree.h"
	47	#include "xfs_attr_sf.h"
	48	#include "xfs_dir_sf.h"
	49	#include "xfs_dir2_sf.h"
	50	#include "xfs_dinode.h"
	51	#include "xfs_inode.h"
	52	#include "xfs_error.h"
	53	#include "xfs_rw.h"
	54	#include "xfs_ioctl32.h"
	55
	56	#include <linux/dcache.h>
	57	#include <linux/smp_lock.h>
	58
	59	static struct vm_operations_struct linvfs_file_vm_ops;
6fac0cb4 DR	60	#ifdef CONFIG_XFS_DMAPI
	61	static struct vm_operations_struct linvfs_dmapi_file_vm_ops;
	62	#endif
1da177e4 LT	63
	64	STATIC inline ssize_t
	65	__linvfs_read(
	66	struct kiocb *iocb,
	67	char __user *buf,
	68	int ioflags,
	69	size_t count,
	70	loff_t pos)
	71	{
	72	struct iovec iov = {buf, count};
	73	struct file *file = iocb->ki_filp;
	74	vnode_t *vp = LINVFS_GET_VP(file->f_dentry->d_inode);
	75	ssize_t rval;
	76
	77	BUG_ON(iocb->ki_pos != pos);
	78
	79	if (unlikely(file->f_flags & O_DIRECT))
	80	ioflags \|= IO_ISDIRECT;
	81	VOP_READ(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL, rval);
	82	return rval;
	83	}
	84
	85
	86	STATIC ssize_t
	87	linvfs_aio_read(
	88	struct kiocb *iocb,
	89	char __user *buf,
	90	size_t count,
	91	loff_t pos)
	92	{
	93	return __linvfs_read(iocb, buf, IO_ISAIO, count, pos);
	94	}
	95
	96	STATIC ssize_t
	97	linvfs_aio_read_invis(
	98	struct kiocb *iocb,
	99	char __user *buf,
	100	size_t count,
	101	loff_t pos)
	102	{
	103	return __linvfs_read(iocb, buf, IO_ISAIO\|IO_INVIS, count, pos);
	104	}
	105
	106
	107	STATIC inline ssize_t
	108	__linvfs_write(
	109	struct kiocb *iocb,
	110	const char __user *buf,
	111	int ioflags,
	112	size_t count,
	113	loff_t pos)
	114	{
	115	struct iovec iov = {(void __user *)buf, count};
	116	struct file *file = iocb->ki_filp;
	117	struct inode *inode = file->f_mapping->host;
	118	vnode_t *vp = LINVFS_GET_VP(inode);
	119	ssize_t rval;
	120
	121	BUG_ON(iocb->ki_pos != pos);
	122	if (unlikely(file->f_flags & O_DIRECT))
	123	ioflags \|= IO_ISDIRECT;
	124
	125	VOP_WRITE(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL, rval);
	126	return rval;
127	}
128
129
130	STATIC ssize_t
131	linvfs_aio_write(
132	struct kiocb *iocb,
133	const char __user *buf,
134	size_t count,
135	loff_t pos)
136	{
137	return __linvfs_write(iocb, buf, IO_ISAIO, count, pos);
138	}
139
140	STATIC ssize_t
141	linvfs_aio_write_invis(
142	struct kiocb *iocb,
143	const char __user *buf,
144	size_t count,
145	loff_t pos)
146	{
147	return __linvfs_write(iocb, buf, IO_ISAIO\|IO_INVIS, count, pos);
148	}
149
150
151	STATIC inline ssize_t
152	__linvfs_readv(
153	struct file *file,
154	const struct iovec *iov,
155	int ioflags,
156	unsigned long nr_segs,
157	loff_t *ppos)
158	{
159	struct inode *inode = file->f_mapping->host;
160	vnode_t *vp = LINVFS_GET_VP(inode);
161	struct kiocb kiocb;
162	ssize_t rval;
163
164	init_sync_kiocb(&kiocb, file);
165	kiocb.ki_pos = *ppos;
166
167	if (unlikely(file->f_flags & O_DIRECT))
168	ioflags \|= IO_ISDIRECT;
169	VOP_READ(vp, &kiocb, iov, nr_segs, &kiocb.ki_pos, ioflags, NULL, rval);
170
171	*ppos = kiocb.ki_pos;
172	return rval;
173	}
174
175	STATIC ssize_t
176	linvfs_readv(
177	struct file *file,
178	const struct iovec *iov,
179	unsigned long nr_segs,
180	loff_t *ppos)
181	{
182	return __linvfs_readv(file, iov, 0, nr_segs, ppos);
183	}
184
185	STATIC ssize_t
186	linvfs_readv_invis(
187	struct file *file,
188	const struct iovec *iov,
189	unsigned long nr_segs,
190	loff_t *ppos)
191	{
192	return __linvfs_readv(file, iov, IO_INVIS, nr_segs, ppos);
193	}
194
195
196	STATIC inline ssize_t
197	__linvfs_writev(
198	struct file *file,
199	const struct iovec *iov,
200	int ioflags,
201	unsigned long nr_segs,
202	loff_t *ppos)
203	{
204	struct inode *inode = file->f_mapping->host;
205	vnode_t *vp = LINVFS_GET_VP(inode);
206	struct kiocb kiocb;
207	ssize_t rval;
208
209	init_sync_kiocb(&kiocb, file);
210	kiocb.ki_pos = *ppos;
211	if (unlikely(file->f_flags & O_DIRECT))
212	ioflags \|= IO_ISDIRECT;
213
214	VOP_WRITE(vp, &kiocb, iov, nr_segs, &kiocb.ki_pos, ioflags, NULL, rval);
215
216	*ppos = kiocb.ki_pos;
217	return rval;
218	}
219
220
221	STATIC ssize_t
222	linvfs_writev(
223	struct file *file,
224	const struct iovec *iov,
225	unsigned long nr_segs,
226	loff_t *ppos)
227	{
228	return __linvfs_writev(file, iov, 0, nr_segs, ppos);
229	}
230
231	STATIC ssize_t
232	linvfs_writev_invis(
233	struct file *file,
234	const struct iovec *iov,
235	unsigned long nr_segs,
236	loff_t *ppos)
237	{
238	return __linvfs_writev(file, iov, IO_INVIS, nr_segs, ppos);
239	}
240
241	STATIC ssize_t
242	linvfs_sendfile(
243	struct file *filp,
244	loff_t *ppos,
245	size_t count,
246	read_actor_t actor,
247	void *target)
248	{
249	vnode_t *vp = LINVFS_GET_VP(filp->f_dentry->d_inode);
250	ssize_t rval;
251
252	VOP_SENDFILE(vp, filp, ppos, 0, count, actor, target, NULL, rval);
253	return rval;
254	}
255
256
257	STATIC int
258	linvfs_open(
259	struct inode *inode,
260	struct file *filp)
261	{
262	vnode_t *vp = LINVFS_GET_VP(inode);
263	int error;
264
265	if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
266	return -EFBIG;
267
268	ASSERT(vp);
269	VOP_OPEN(vp, NULL, error);
270	return -error;
271	}
272
273
274	STATIC int
275	linvfs_release(
276	struct inode *inode,
277	struct file *filp)
278	{
279	vnode_t *vp = LINVFS_GET_VP(inode);
280	int error = 0;
281
282	if (vp)
283	VOP_RELEASE(vp, error);
284	return -error;
285	}
286
287
288	STATIC int
289	linvfs_fsync(
290	struct file *filp,
291	struct dentry *dentry,
292	int datasync)
293	{
294	struct inode *inode = dentry->d_inode;
295	vnode_t *vp = LINVFS_GET_VP(inode);
296	int error;
297	int flags = FSYNC_WAIT;
298
299	if (datasync)
300	flags \|= FSYNC_DATA;
301
302	ASSERT(vp);
303	VOP_FSYNC(vp, flags, NULL, (xfs_off_t)0, (xfs_off_t)-1, error);
304	return -error;
305	}
306
307	/*
308	* linvfs_readdir maps to VOP_READDIR().
309	* We need to build a uio, cred, ...
310	*/
311
312	#define nextdp(dp) ((struct xfs_dirent )((char )(dp) + (dp)->d_reclen))
313
bb3f724e DR	314	#ifdef CONFIG_XFS_DMAPI
	315
	316	STATIC struct page *
	317	linvfs_filemap_nopage(
	318	struct vm_area_struct *area,
	319	unsigned long address,
	320	int *type)
	321	{
	322	struct inode *inode = area->vm_file->f_dentry->d_inode;
	323	vnode_t *vp = LINVFS_GET_VP(inode);
	324	xfs_mount_t *mp = XFS_VFSTOM(vp->v_vfsp);
	325	int error;
	326
	327	ASSERT_ALWAYS(vp->v_vfsp->vfs_flag & VFS_DMI);
	328
	329	error = XFS_SEND_MMAP(mp, area, 0);
	330	if (error)
	331	return NULL;
	332
	333	return filemap_nopage(area, address, type);
	334	}
	335
	336	#endif /* CONFIG_XFS_DMAPI */
	337
	338
1da177e4 LT	339	STATIC int
	340	linvfs_readdir(
	341	struct file *filp,
	342	void *dirent,
	343	filldir_t filldir)
	344	{
	345	int error = 0;
	346	vnode_t *vp;
	347	uio_t uio;
	348	iovec_t iov;
	349	int eof = 0;
	350	caddr_t read_buf;
	351	int namelen, size = 0;
	352	size_t rlen = PAGE_CACHE_SIZE;
	353	xfs_off_t start_offset, curr_offset;
	354	xfs_dirent_t *dbp = NULL;
	355
	356	vp = LINVFS_GET_VP(filp->f_dentry->d_inode);
	357	ASSERT(vp);
	358
	359	/* Try fairly hard to get memory */
	360	do {
	361	if ((read_buf = (caddr_t)kmalloc(rlen, GFP_KERNEL)))
	362	break;
	363	rlen >>= 1;
	364	} while (rlen >= 1024);
	365
	366	if (read_buf == NULL)
	367	return -ENOMEM;
	368
	369	uio.uio_iov = &iov;
	370	uio.uio_segflg = UIO_SYSSPACE;
	371	curr_offset = filp->f_pos;
	372	if (filp->f_pos != 0x7fffffff)
	373	uio.uio_offset = filp->f_pos;
	374	else
	375	uio.uio_offset = 0xffffffff;
	376
	377	while (!eof) {
	378	uio.uio_resid = iov.iov_len = rlen;
	379	iov.iov_base = read_buf;
	380	uio.uio_iovcnt = 1;
	381
	382	start_offset = uio.uio_offset;
	383
	384	VOP_READDIR(vp, &uio, NULL, &eof, error);
	385	if ((uio.uio_offset == start_offset) \|\| error) {
	386	size = 0;
	387	break;
	388	}
	389
	390	size = rlen - uio.uio_resid;
	391	dbp = (xfs_dirent_t *)read_buf;
	392	while (size > 0) {
	393	namelen = strlen(dbp->d_name);
	394
	395	if (filldir(dirent, dbp->d_name, namelen,
	396	(loff_t) curr_offset & 0x7fffffff,
	397	(ino_t) dbp->d_ino,
	398	DT_UNKNOWN)) {
	399	goto done;
	400	}
	401	size -= dbp->d_reclen;
	402	curr_offset = (loff_t)dbp->d_off /* & 0x7fffffff */;
403	dbp = nextdp(dbp);
404	}
405	}
406	done:
407	if (!error) {
408	if (size == 0)
409	filp->f_pos = uio.uio_offset & 0x7fffffff;
410	else if (dbp)
411	filp->f_pos = curr_offset;
412	}
413
414	kfree(read_buf);
415	return -error;
416	}
417
418
419	STATIC int
420	linvfs_file_mmap(
421	struct file *filp,
422	struct vm_area_struct *vma)
423	{
424	struct inode *ip = filp->f_dentry->d_inode;
425	vnode_t *vp = LINVFS_GET_VP(ip);
426	vattr_t va = { .va_mask = XFS_AT_UPDATIME };
427	int error;
428
6fac0cb4 DR	429	vma->vm_ops = &linvfs_file_vm_ops;
6fac0cb4 DR	430
6fac0cb4	431	#ifdef CONFIG_XFS_DMAPI
bb3f724e	432	if (vp->v_vfsp->vfs_flag & VFS_DMI) {
6fac0cb4	433	vma->vm_ops = &linvfs_dmapi_file_vm_ops;
1da177e4	434	}
bb3f724e	435	#endif /* CONFIG_XFS_DMAPI */
1da177e4	436
1da177e4 LT	437	VOP_SETATTR(vp, &va, XFS_AT_UPDATIME, NULL, error);
	438	if (!error)
	439	vn_revalidate(vp); /* update Linux inode flags */
	440	return 0;
	441	}
	442
	443
	444	STATIC long
	445	linvfs_ioctl(
	446	struct file *filp,
	447	unsigned int cmd,
	448	unsigned long arg)
	449	{
	450	int error;
	451	struct inode *inode = filp->f_dentry->d_inode;
	452	vnode_t *vp = LINVFS_GET_VP(inode);
	453
	454	VOP_IOCTL(vp, inode, filp, 0, cmd, (void __user *)arg, error);
	455	VMODIFY(vp);
	456
	457	/* NOTE: some of the ioctl's return positive #'s as a
	458	* byte count indicating success, such as
	459	* readlink_by_handle. So we don't "sign flip"
	460	* like most other routines. This means true
	461	* errors need to be returned as a negative value.
	462	*/
	463	return error;
	464	}
	465
	466	STATIC long
	467	linvfs_ioctl_invis(
	468	struct file *filp,
	469	unsigned int cmd,
	470	unsigned long arg)
	471	{
	472	int error;
	473	struct inode *inode = filp->f_dentry->d_inode;
	474	vnode_t *vp = LINVFS_GET_VP(inode);
	475
	476	ASSERT(vp);
	477	VOP_IOCTL(vp, inode, filp, IO_INVIS, cmd, (void __user *)arg, error);
	478	VMODIFY(vp);
	479
	480	/* NOTE: some of the ioctl's return positive #'s as a
	481	* byte count indicating success, such as
	482	* readlink_by_handle. So we don't "sign flip"
	483	* like most other routines. This means true
	484	* errors need to be returned as a negative value.
	485	*/
	486	return error;
	487	}
	488
bb3f724e	489	#ifdef CONFIG_XFS_DMAPI
1da177e4 LT	490	#ifdef HAVE_VMOP_MPROTECT
	491	STATIC int
	492	linvfs_mprotect(
	493	struct vm_area_struct *vma,
	494	unsigned int newflags)
	495	{
	496	vnode_t *vp = LINVFS_GET_VP(vma->vm_file->f_dentry->d_inode);
	497	int error = 0;
	498
	499	if (vp->v_vfsp->vfs_flag & VFS_DMI) {
	500	if ((vma->vm_flags & VM_MAYSHARE) &&
	501	(newflags & VM_WRITE) && !(vma->vm_flags & VM_WRITE)) {
	502	xfs_mount_t *mp = XFS_VFSTOM(vp->v_vfsp);
	503
	504	error = XFS_SEND_MMAP(mp, vma, VM_WRITE);
	505	}
	506	}
	507	return error;
	508	}
	509	#endif /* HAVE_VMOP_MPROTECT */
bb3f724e	510	#endif /* CONFIG_XFS_DMAPI */
1da177e4 LT	511
	512	#ifdef HAVE_FOP_OPEN_EXEC
	513	/* If the user is attempting to execute a file that is offline then
	514	* we have to trigger a DMAPI READ event before the file is marked as busy
	515	* otherwise the invisible I/O will not be able to write to the file to bring
	516	* it back online.
	517	*/
	518	STATIC int
	519	linvfs_open_exec(
	520	struct inode *inode)
	521	{
	522	vnode_t *vp = LINVFS_GET_VP(inode);
	523	xfs_mount_t *mp = XFS_VFSTOM(vp->v_vfsp);
	524	int error = 0;
	525	bhv_desc_t *bdp;
	526	xfs_inode_t *ip;
	527
	528	if (vp->v_vfsp->vfs_flag & VFS_DMI) {
	529	bdp = vn_bhv_lookup(VN_BHV_HEAD(vp), &xfs_vnodeops);
	530	if (!bdp) {
	531	error = -EINVAL;
	532	goto open_exec_out;
	533	}
	534	ip = XFS_BHVTOI(bdp);
	535	if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_READ)) {
	536	error = -XFS_SEND_DATA(mp, DM_EVENT_READ, vp,
	537	0, 0, 0, NULL);
	538	}
	539	}
	540	open_exec_out:
	541	return error;
	542	}
	543	#endif /* HAVE_FOP_OPEN_EXEC */
	544
	545	struct file_operations linvfs_file_operations = {
	546	.llseek = generic_file_llseek,
	547	.read = do_sync_read,
bb3f724e	548	.write = do_sync_write,
1da177e4 LT	549	.readv = linvfs_readv,
	550	.writev = linvfs_writev,
	551	.aio_read = linvfs_aio_read,
	552	.aio_write = linvfs_aio_write,
	553	.sendfile = linvfs_sendfile,
	554	.unlocked_ioctl = linvfs_ioctl,
	555	#ifdef CONFIG_COMPAT
d3870398	556	.compat_ioctl = linvfs_compat_ioctl,
1da177e4 LT	557	#endif
	558	.mmap = linvfs_file_mmap,
	559	.open = linvfs_open,
	560	.release = linvfs_release,
	561	.fsync = linvfs_fsync,
	562	#ifdef HAVE_FOP_OPEN_EXEC
	563	.open_exec = linvfs_open_exec,
	564	#endif
	565	};
	566
	567	struct file_operations linvfs_invis_file_operations = {
	568	.llseek = generic_file_llseek,
	569	.read = do_sync_read,
bb3f724e	570	.write = do_sync_write,
1da177e4 LT	571	.readv = linvfs_readv_invis,
	572	.writev = linvfs_writev_invis,
	573	.aio_read = linvfs_aio_read_invis,
	574	.aio_write = linvfs_aio_write_invis,
	575	.sendfile = linvfs_sendfile,
	576	.unlocked_ioctl = linvfs_ioctl_invis,
	577	#ifdef CONFIG_COMPAT
d3870398	578	.compat_ioctl = linvfs_compat_invis_ioctl,
1da177e4 LT	579	#endif
	580	.mmap = linvfs_file_mmap,
	581	.open = linvfs_open,
	582	.release = linvfs_release,
	583	.fsync = linvfs_fsync,
	584	};
	585
	586
	587	struct file_operations linvfs_dir_operations = {
	588	.read = generic_read_dir,
	589	.readdir = linvfs_readdir,
	590	.unlocked_ioctl = linvfs_ioctl,
d3870398 NS	591	#ifdef CONFIG_COMPAT
	592	.compat_ioctl = linvfs_compat_ioctl,
	593	#endif
1da177e4 LT	594	.fsync = linvfs_fsync,
	595	};
	596
	597	static struct vm_operations_struct linvfs_file_vm_ops = {
	598	.nopage = filemap_nopage,
	599	.populate = filemap_populate,
6fac0cb4 DR	600	};
	601
	602	#ifdef CONFIG_XFS_DMAPI
	603	static struct vm_operations_struct linvfs_dmapi_file_vm_ops = {
bb3f724e	604	.nopage = linvfs_filemap_nopage,
6fac0cb4	605	.populate = filemap_populate,
1da177e4 LT	606	#ifdef HAVE_VMOP_MPROTECT
	607	.mprotect = linvfs_mprotect,
	608	#endif
	609	};
6fac0cb4	610	#endif /* CONFIG_XFS_DMAPI */