[net-next-2.6.git] / fs / reiserfs / file.c

/*
 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
 */

#include <linux/time.h>
#include <linux/reiserfs_fs.h>
#include <linux/reiserfs_acl.h>
#include <linux/reiserfs_xattr.h>
#include <asm/uaccess.h>
#include <linux/pagemap.h>
#include <linux/swap.h>
#include <linux/writeback.h>
#include <linux/blkdev.h>
#include <linux/buffer_head.h>
#include <linux/quotaops.h>

/*
** We pack the tails of files on file close, not at the time they are written.
** This implies an unnecessary copy of the tail and an unnecessary indirect item
** insertion/balancing, for files that are written in one write.
** It avoids unnecessary tail packings (balances) for files that are written in
** multiple writes and are small enough to have tails.
**
** file_release is called by the VFS layer when the file is closed.  If
** this is the last open file descriptor, and the file
** small enough to have a tail, and the tail is currently in an
** unformatted node, the tail is converted back into a direct item.
**
** We use reiserfs_truncate_file to pack the tail, since it already has
** all the conditions coded.
*/
static int reiserfs_file_release(struct inode *inode, struct file *filp)
{

	struct reiserfs_transaction_handle th;
	int err;
	int jbegin_failure = 0;

	BUG_ON(!S_ISREG(inode->i_mode));

	/* fast out for when nothing needs to be done */
	if ((atomic_read(&inode->i_count) > 1 ||
	     !(REISERFS_I(inode)->i_flags & i_pack_on_close_mask) ||
	     !tail_has_to_be_packed(inode)) &&
	    REISERFS_I(inode)->i_prealloc_count <= 0) {
		return 0;
	}

	mutex_lock(&inode->i_mutex);

	mutex_lock(&(REISERFS_I(inode)->i_mmap));
	if (REISERFS_I(inode)->i_flags & i_ever_mapped)
		REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;

	reiserfs_write_lock(inode->i_sb);
	/* freeing preallocation only involves relogging blocks that
	 * are already in the current transaction.  preallocation gets
	 * freed at the end of each transaction, so it is impossible for
	 * us to log any additional blocks (including quota blocks)
	 */
	err = journal_begin(&th, inode->i_sb, 1);
	if (err) {
		/* uh oh, we can't allow the inode to go away while there
		 * is still preallocation blocks pending.  Try to join the
		 * aborted transaction
		 */
		jbegin_failure = err;
		err = journal_join_abort(&th, inode->i_sb, 1);

		if (err) {
			/* hmpf, our choices here aren't good.  We can pin the inode
			 * which will disallow unmount from every happening, we can
			 * do nothing, which will corrupt random memory on unmount,
			 * or we can forcibly remove the file from the preallocation
			 * list, which will leak blocks on disk.  Lets pin the inode
			 * and let the admin know what is going on.
			 */
			igrab(inode);
			reiserfs_warning(inode->i_sb, "clm-9001",
					 "pinning inode %lu because the "
					 "preallocation can't be freed",
					 inode->i_ino);
			goto out;
		}
	}
	reiserfs_update_inode_transaction(inode);

#ifdef REISERFS_PREALLOCATE
	reiserfs_discard_prealloc(&th, inode);
#endif
	err = journal_end(&th, inode->i_sb, 1);

	/* copy back the error code from journal_begin */
	if (!err)
		err = jbegin_failure;

	if (!err && atomic_read(&inode->i_count) <= 1 &&
	    (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) &&
	    tail_has_to_be_packed(inode)) {
		/* if regular file is released by last holder and it has been
		   appended (we append by unformatted node only) or its direct
		   item(s) had to be converted, then it may have to be
		   indirect2direct converted */
		err = reiserfs_truncate_file(inode, 0);
	}
      out:
	mutex_unlock(&(REISERFS_I(inode)->i_mmap));
	mutex_unlock(&inode->i_mutex);
	reiserfs_write_unlock(inode->i_sb);
	return err;
}

static int reiserfs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct inode *inode;

	inode = file->f_path.dentry->d_inode;
	mutex_lock(&(REISERFS_I(inode)->i_mmap));
	REISERFS_I(inode)->i_flags |= i_ever_mapped;
	mutex_unlock(&(REISERFS_I(inode)->i_mmap));

	return generic_file_mmap(file, vma);
}

static void reiserfs_vfs_truncate_file(struct inode *inode)
{
	reiserfs_truncate_file(inode, 1);
}

/* Sync a reiserfs file. */

/*
 * FIXME: sync_mapping_buffers() never has anything to sync.  Can
 * be removed...
 */

static int reiserfs_sync_file(struct file *p_s_filp,
			      struct dentry *p_s_dentry, int datasync)
{
	struct inode *inode = p_s_dentry->d_inode;
	int n_err;
	int barrier_done;

	BUG_ON(!S_ISREG(inode->i_mode));
	n_err = sync_mapping_buffers(inode->i_mapping);
	reiserfs_write_lock(inode->i_sb);
	barrier_done = reiserfs_commit_for_inode(inode);
	reiserfs_write_unlock(inode->i_sb);
	if (barrier_done != 1 && reiserfs_barrier_flush(inode->i_sb))
		blkdev_issue_flush(inode->i_sb->s_bdev, NULL);
	if (barrier_done < 0)
		return barrier_done;
	return (n_err < 0) ? -EIO : 0;
}

/* taken fs/buffer.c:__block_commit_write */
int reiserfs_commit_page(struct inode *inode, struct page *page,
			 unsigned from, unsigned to)
{
	unsigned block_start, block_end;
	int partial = 0;
	unsigned blocksize;
	struct buffer_head *bh, *head;
	unsigned long i_size_index = inode->i_size >> PAGE_CACHE_SHIFT;
	int new;
	int logit = reiserfs_file_data_log(inode);
	struct super_block *s = inode->i_sb;
	int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;
	struct reiserfs_transaction_handle th;
	int ret = 0;

	th.t_trans_id = 0;
	blocksize = 1 << inode->i_blkbits;

	if (logit) {
		reiserfs_write_lock(s);
		ret = journal_begin(&th, s, bh_per_page + 1);
		if (ret)
			goto drop_write_lock;
		reiserfs_update_inode_transaction(inode);
	}
	for (bh = head = page_buffers(page), block_start = 0;
	     bh != head || !block_start;
	     block_start = block_end, bh = bh->b_this_page) {

		new = buffer_new(bh);
		clear_buffer_new(bh);
		block_end = block_start + blocksize;
		if (block_end <= from || block_start >= to) {
			if (!buffer_uptodate(bh))
				partial = 1;
		} else {
			set_buffer_uptodate(bh);
			if (logit) {
				reiserfs_prepare_for_journal(s, bh, 1);
				journal_mark_dirty(&th, s, bh);
			} else if (!buffer_dirty(bh)) {
				mark_buffer_dirty(bh);
				/* do data=ordered on any page past the end
				 * of file and any buffer marked BH_New.
				 */
				if (reiserfs_data_ordered(inode->i_sb) &&
				    (new || page->index >= i_size_index)) {
					reiserfs_add_ordered_list(inode, bh);
				}
			}
		}
	}
	if (logit) {
		ret = journal_end(&th, s, bh_per_page + 1);
	      drop_write_lock:
		reiserfs_write_unlock(s);
	}
	/*
	 * If this is a partial write which happened to make all buffers
	 * uptodate then we can optimize away a bogus readpage() for
	 * the next read(). Here we 'discover' whether the page went
	 * uptodate as a result of this (potentially partial) write.
	 */
	if (!partial)
		SetPageUptodate(page);
	return ret;
}

/* Write @count bytes at position @ppos in a file indicated by @file
   from the buffer @buf.

   generic_file_write() is only appropriate for filesystems that are not seeking to optimize performance and want
   something simple that works.  It is not for serious use by general purpose filesystems, excepting the one that it was
   written for (ext2/3).  This is for several reasons:

   * It has no understanding of any filesystem specific optimizations.

   * It enters the filesystem repeatedly for each page that is written.

   * It depends on reiserfs_get_block() function which if implemented by reiserfs performs costly search_by_key
   * operation for each page it is supplied with. By contrast reiserfs_file_write() feeds as much as possible at a time
   * to reiserfs which allows for fewer tree traversals.

   * Each indirect pointer insertion takes a lot of cpu, because it involves memory moves inside of blocks.

   * Asking the block allocation code for blocks one at a time is slightly less efficient.

   All of these reasons for not using only generic file write were understood back when reiserfs was first miscoded to
   use it, but we were in a hurry to make code freeze, and so it couldn't be revised then.  This new code should make
   things right finally.

   Future Features: providing search_by_key with hints.

*/
static ssize_t reiserfs_file_write(struct file *file,	/* the file we are going to write into */
				   const char __user * buf,	/*  pointer to user supplied data
								   (in userspace) */
				   size_t count,	/* amount of bytes to write */
				   loff_t * ppos	/* pointer to position in file that we start writing at. Should be updated to
							 * new current position before returning. */
				   )
{
	struct inode *inode = file->f_path.dentry->d_inode;	// Inode of the file that we are writing to.
	/* To simplify coding at this time, we store
	   locked pages in array for now */
	struct reiserfs_transaction_handle th;
	th.t_trans_id = 0;

	/* If a filesystem is converted from 3.5 to 3.6, we'll have v3.5 items
	* lying around (most of the disk, in fact). Despite the filesystem
	* now being a v3.6 format, the old items still can't support large
	* file sizes. Catch this case here, as the rest of the VFS layer is
	* oblivious to the different limitations between old and new items.
	* reiserfs_setattr catches this for truncates. This chunk is lifted
	* from generic_write_checks. */
	if (get_inode_item_key_version (inode) == KEY_FORMAT_3_5 &&
	    *ppos + count > MAX_NON_LFS) {
		if (*ppos >= MAX_NON_LFS) {
			return -EFBIG;
		}
		if (count > MAX_NON_LFS - (unsigned long)*ppos)
			count = MAX_NON_LFS - (unsigned long)*ppos;
	}

	return do_sync_write(file, buf, count, ppos);
}

const struct file_operations reiserfs_file_operations = {
	.read = do_sync_read,
	.write = reiserfs_file_write,
	.ioctl = reiserfs_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = reiserfs_compat_ioctl,
#endif
	.mmap = reiserfs_file_mmap,
	.open = generic_file_open,
	.release = reiserfs_file_release,
	.fsync = reiserfs_sync_file,
	.aio_read = generic_file_aio_read,
	.aio_write = generic_file_aio_write,
	.splice_read = generic_file_splice_read,
	.splice_write = generic_file_splice_write,
	.llseek = generic_file_llseek,
};

const struct inode_operations reiserfs_file_inode_operations = {
	.truncate = reiserfs_vfs_truncate_file,
	.setattr = reiserfs_setattr,
	.setxattr = reiserfs_setxattr,
	.getxattr = reiserfs_getxattr,
	.listxattr = reiserfs_listxattr,
	.removexattr = reiserfs_removexattr,
	.permission = reiserfs_permission,
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
	3	*/
	4
1da177e4 LT	5	#include <linux/time.h>
	6	#include <linux/reiserfs_fs.h>
	7	#include <linux/reiserfs_acl.h>
	8	#include <linux/reiserfs_xattr.h>
1da177e4 LT	9	#include <asm/uaccess.h>
	10	#include <linux/pagemap.h>
	11	#include <linux/swap.h>
	12	#include <linux/writeback.h>
	13	#include <linux/blkdev.h>
	14	#include <linux/buffer_head.h>
	15	#include <linux/quotaops.h>
	16
	17	/*
	18	** We pack the tails of files on file close, not at the time they are written.
	19	** This implies an unnecessary copy of the tail and an unnecessary indirect item
	20	** insertion/balancing, for files that are written in one write.
	21	** It avoids unnecessary tail packings (balances) for files that are written in
	22	** multiple writes and are small enough to have tails.
0222e657	23	**
1da177e4 LT	24	** file_release is called by the VFS layer when the file is closed. If
	25	** this is the last open file descriptor, and the file
	26	** small enough to have a tail, and the tail is currently in an
	27	** unformatted node, the tail is converted back into a direct item.
0222e657	28	**
1da177e4	29	** We use reiserfs_truncate_file to pack the tail, since it already has
0222e657	30	** all the conditions coded.
1da177e4	31	*/
bd4c625c	32	static int reiserfs_file_release(struct inode inode, struct file filp)
1da177e4 LT	33	{
1da177e4 LT	34
bd4c625c LT	35	struct reiserfs_transaction_handle th;
	36	int err;
	37	int jbegin_failure = 0;
1da177e4	38
14a61442	39	BUG_ON(!S_ISREG(inode->i_mode));
1da177e4	40
bd4c625c LT	41	/* fast out for when nothing needs to be done */
	42	if ((atomic_read(&inode->i_count) > 1 \|\|
	43	!(REISERFS_I(inode)->i_flags & i_pack_on_close_mask) \|\|
	44	!tail_has_to_be_packed(inode)) &&
	45	REISERFS_I(inode)->i_prealloc_count <= 0) {
	46	return 0;
	47	}
1da177e4	48
1b1dcc1b	49	mutex_lock(&inode->i_mutex);
de14569f VS	50
	51	mutex_lock(&(REISERFS_I(inode)->i_mmap));
	52	if (REISERFS_I(inode)->i_flags & i_ever_mapped)
	53	REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
	54
b5f3953c	55	reiserfs_write_lock(inode->i_sb);
bd4c625c LT	56	/* freeing preallocation only involves relogging blocks that
	57	* are already in the current transaction. preallocation gets
	58	* freed at the end of each transaction, so it is impossible for
	59	* us to log any additional blocks (including quota blocks)
	60	*/
	61	err = journal_begin(&th, inode->i_sb, 1);
1da177e4	62	if (err) {
bd4c625c LT	63	/* uh oh, we can't allow the inode to go away while there
	64	* is still preallocation blocks pending. Try to join the
	65	* aborted transaction
	66	*/
	67	jbegin_failure = err;
	68	err = journal_join_abort(&th, inode->i_sb, 1);
	69
	70	if (err) {
	71	/* hmpf, our choices here aren't good. We can pin the inode
	72	* which will disallow unmount from every happening, we can
	73	* do nothing, which will corrupt random memory on unmount,
	74	* or we can forcibly remove the file from the preallocation
	75	* list, which will leak blocks on disk. Lets pin the inode
	76	* and let the admin know what is going on.
	77	*/
	78	igrab(inode);
45b03d5e	79	reiserfs_warning(inode->i_sb, "clm-9001",
bd4c625c	80	"pinning inode %lu because the "
533221fb AD	81	"preallocation can't be freed",
533221fb AD	82	inode->i_ino);
bd4c625c LT	83	goto out;
bd4c625c LT	84	}
1da177e4	85	}
bd4c625c	86	reiserfs_update_inode_transaction(inode);
1da177e4 LT	87
1da177e4 LT	88	#ifdef REISERFS_PREALLOCATE
bd4c625c	89	reiserfs_discard_prealloc(&th, inode);
1da177e4	90	#endif
bd4c625c LT	91	err = journal_end(&th, inode->i_sb, 1);
	92
	93	/* copy back the error code from journal_begin */
	94	if (!err)
	95	err = jbegin_failure;
	96
	97	if (!err && atomic_read(&inode->i_count) <= 1 &&
	98	(REISERFS_I(inode)->i_flags & i_pack_on_close_mask) &&
	99	tail_has_to_be_packed(inode)) {
	100	/* if regular file is released by last holder and it has been
	101	appended (we append by unformatted node only) or its direct
	102	item(s) had to be converted, then it may have to be
	103	indirect2direct converted */
	104	err = reiserfs_truncate_file(inode, 0);
	105	}
	106	out:
de14569f	107	mutex_unlock(&(REISERFS_I(inode)->i_mmap));
1b1dcc1b	108	mutex_unlock(&inode->i_mutex);
bd4c625c LT	109	reiserfs_write_unlock(inode->i_sb);
bd4c625c LT	110	return err;
1da177e4 LT	111	}
1da177e4 LT	112
de14569f VS	113	static int reiserfs_file_mmap(struct file file, struct vm_area_struct vma)
	114	{
	115	struct inode *inode;
	116
	117	inode = file->f_path.dentry->d_inode;
	118	mutex_lock(&(REISERFS_I(inode)->i_mmap));
	119	REISERFS_I(inode)->i_flags \|= i_ever_mapped;
	120	mutex_unlock(&(REISERFS_I(inode)->i_mmap));
	121
	122	return generic_file_mmap(file, vma);
	123	}
	124
bd4c625c LT	125	static void reiserfs_vfs_truncate_file(struct inode *inode)
	126	{
	127	reiserfs_truncate_file(inode, 1);
1da177e4 LT	128	}
	129
	130	/* Sync a reiserfs file. */
	131
	132	/*
	133	* FIXME: sync_mapping_buffers() never has anything to sync. Can
	134	* be removed...
	135	*/
	136
bd4c625c LT	137	static int reiserfs_sync_file(struct file *p_s_filp,
	138	struct dentry *p_s_dentry, int datasync)
	139	{
995c762e	140	struct inode *inode = p_s_dentry->d_inode;
bd4c625c LT	141	int n_err;
	142	int barrier_done;
	143
995c762e JM	144	BUG_ON(!S_ISREG(inode->i_mode));
	145	n_err = sync_mapping_buffers(inode->i_mapping);
	146	reiserfs_write_lock(inode->i_sb);
	147	barrier_done = reiserfs_commit_for_inode(inode);
	148	reiserfs_write_unlock(inode->i_sb);
	149	if (barrier_done != 1 && reiserfs_barrier_flush(inode->i_sb))
	150	blkdev_issue_flush(inode->i_sb->s_bdev, NULL);
bd4c625c LT	151	if (barrier_done < 0)
	152	return barrier_done;
	153	return (n_err < 0) ? -EIO : 0;
1da177e4 LT	154	}
1da177e4 LT	155
1da177e4 LT	156	/* taken fs/buffer.c:__block_commit_write */
1da177e4 LT	157	int reiserfs_commit_page(struct inode inode, struct page page,
bd4c625c	158	unsigned from, unsigned to)
1da177e4	159	{
bd4c625c LT	160	unsigned block_start, block_end;
	161	int partial = 0;
	162	unsigned blocksize;
	163	struct buffer_head bh, head;
	164	unsigned long i_size_index = inode->i_size >> PAGE_CACHE_SHIFT;
	165	int new;
	166	int logit = reiserfs_file_data_log(inode);
	167	struct super_block *s = inode->i_sb;
	168	int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;
	169	struct reiserfs_transaction_handle th;
	170	int ret = 0;
	171
	172	th.t_trans_id = 0;
	173	blocksize = 1 << inode->i_blkbits;
	174
	175	if (logit) {
	176	reiserfs_write_lock(s);
	177	ret = journal_begin(&th, s, bh_per_page + 1);
	178	if (ret)
	179	goto drop_write_lock;
	180	reiserfs_update_inode_transaction(inode);
	181	}
	182	for (bh = head = page_buffers(page), block_start = 0;
	183	bh != head \|\| !block_start;
	184	block_start = block_end, bh = bh->b_this_page) {
	185
	186	new = buffer_new(bh);
	187	clear_buffer_new(bh);
	188	block_end = block_start + blocksize;
	189	if (block_end <= from \|\| block_start >= to) {
	190	if (!buffer_uptodate(bh))
	191	partial = 1;
	192	} else {
	193	set_buffer_uptodate(bh);
	194	if (logit) {
	195	reiserfs_prepare_for_journal(s, bh, 1);
	196	journal_mark_dirty(&th, s, bh);
	197	} else if (!buffer_dirty(bh)) {
	198	mark_buffer_dirty(bh);
	199	/* do data=ordered on any page past the end
	200	* of file and any buffer marked BH_New.
	201	*/
	202	if (reiserfs_data_ordered(inode->i_sb) &&
	203	(new \|\| page->index >= i_size_index)) {
	204	reiserfs_add_ordered_list(inode, bh);
	205	}
	206	}
	207	}
1da177e4	208	}
bd4c625c LT	209	if (logit) {
	210	ret = journal_end(&th, s, bh_per_page + 1);
	211	drop_write_lock:
	212	reiserfs_write_unlock(s);
	213	}
	214	/*
	215	* If this is a partial write which happened to make all buffers
	216	* uptodate then we can optimize away a bogus readpage() for
	217	* the next read(). Here we 'discover' whether the page went
	218	* uptodate as a result of this (potentially partial) write.
	219	*/
	220	if (!partial)
	221	SetPageUptodate(page);
	222	return ret;
1da177e4 LT	223	}
1da177e4 LT	224
1da177e4	225	/* Write @count bytes at position @ppos in a file indicated by @file
0222e657	226	from the buffer @buf.
1da177e4 LT	227
	228	generic_file_write() is only appropriate for filesystems that are not seeking to optimize performance and want
	229	something simple that works. It is not for serious use by general purpose filesystems, excepting the one that it was
	230	written for (ext2/3). This is for several reasons:
	231
	232	* It has no understanding of any filesystem specific optimizations.
	233
	234	* It enters the filesystem repeatedly for each page that is written.
	235
	236	* It depends on reiserfs_get_block() function which if implemented by reiserfs performs costly search_by_key
	237	* operation for each page it is supplied with. By contrast reiserfs_file_write() feeds as much as possible at a time
	238	* to reiserfs which allows for fewer tree traversals.
	239
	240	* Each indirect pointer insertion takes a lot of cpu, because it involves memory moves inside of blocks.
	241
	242	* Asking the block allocation code for blocks one at a time is slightly less efficient.
	243
	244	All of these reasons for not using only generic file write were understood back when reiserfs was first miscoded to
	245	use it, but we were in a hurry to make code freeze, and so it couldn't be revised then. This new code should make
	246	things right finally.
	247
	248	Future Features: providing search_by_key with hints.
	249
	250	*/
bd4c625c LT	251	static ssize_t reiserfs_file_write(struct file file, / the file we are going to write into */
	252	const char __user * buf, /* pointer to user supplied data
	253	(in userspace) */
	254	size_t count, /* amount of bytes to write */
	255	loff_t * ppos /* pointer to position in file that we start writing at. Should be updated to
	256	* new current position before returning. */
	257	)
1da177e4	258	{
1fc5adbd	259	struct inode *inode = file->f_path.dentry->d_inode; // Inode of the file that we are writing to.
bd4c625c LT	260	/* To simplify coding at this time, we store
bd4c625c LT	261	locked pages in array for now */
bd4c625c LT	262	struct reiserfs_transaction_handle th;
	263	th.t_trans_id = 0;
	264
fa385bef JM	265	/* If a filesystem is converted from 3.5 to 3.6, we'll have v3.5 items
	266	* lying around (most of the disk, in fact). Despite the filesystem
	267	* now being a v3.6 format, the old items still can't support large
	268	* file sizes. Catch this case here, as the rest of the VFS layer is
	269	* oblivious to the different limitations between old and new items.
	270	* reiserfs_setattr catches this for truncates. This chunk is lifted
	271	* from generic_write_checks. */
	272	if (get_inode_item_key_version (inode) == KEY_FORMAT_3_5 &&
	273	*ppos + count > MAX_NON_LFS) {
	274	if (*ppos >= MAX_NON_LFS) {
fa385bef JM	275	return -EFBIG;
	276	}
	277	if (count > MAX_NON_LFS - (unsigned long)*ppos)
	278	count = MAX_NON_LFS - (unsigned long)*ppos;
	279	}
	280
797b4cff	281	return do_sync_write(file, buf, count, ppos);
1da177e4 LT	282	}
1da177e4 LT	283
4b6f5d20	284	const struct file_operations reiserfs_file_operations = {
027445c3	285	.read = do_sync_read,
bd4c625c LT	286	.write = reiserfs_file_write,
bd4c625c LT	287	.ioctl = reiserfs_ioctl,
52b499c4 DH	288	#ifdef CONFIG_COMPAT
	289	.compat_ioctl = reiserfs_compat_ioctl,
	290	#endif
de14569f	291	.mmap = reiserfs_file_mmap,
5a2618e6	292	.open = generic_file_open,
bd4c625c LT	293	.release = reiserfs_file_release,
bd4c625c LT	294	.fsync = reiserfs_sync_file,
bd4c625c	295	.aio_read = generic_file_aio_read,
9637f28f	296	.aio_write = generic_file_aio_write,
5274f052 JA	297	.splice_read = generic_file_splice_read,
5274f052 JA	298	.splice_write = generic_file_splice_write,
91efc167	299	.llseek = generic_file_llseek,
1da177e4 LT	300	};
1da177e4 LT	301
c5ef1c42	302	const struct inode_operations reiserfs_file_inode_operations = {
bd4c625c LT	303	.truncate = reiserfs_vfs_truncate_file,
	304	.setattr = reiserfs_setattr,
	305	.setxattr = reiserfs_setxattr,
	306	.getxattr = reiserfs_getxattr,
	307	.listxattr = reiserfs_listxattr,
	308	.removexattr = reiserfs_removexattr,
	309	.permission = reiserfs_permission,
1da177e4	310	};