1 files changed, 131 insertions, 0 deletions
diff --git a/fs/ext3/file.c b/fs/ext3/file.c
new file mode 100644
index 000000000000..5ad8cf0292df
--- /dev/null
+++ b/fs/ext3/file.c
@@ -0,0 +1,131 @@
+/*
+ *  linux/fs/ext3/file.c
+ *
+ * Copyright (C) 1992, 1993, 1994, 1995
+ * Remy Card (card@masi.ibp.fr)
+ * Laboratoire MASI - Institut Blaise Pascal
+ * Universite Pierre et Marie Curie (Paris VI)
+ *
+ *  from
+ *
+ *  linux/fs/minix/file.c
+ *
+ *  Copyright (C) 1991, 1992  Linus Torvalds
+ *
+ *  ext3 fs regular file handling primitives
+ *
+ *  64-bit file support on 64-bit platforms by Jakub Jelinek
+ *      (jj@sunsite.ms.mff.cuni.cz)
+ */
+#include <linux/time.h>
+#include <linux/fs.h>
+#include <linux/jbd.h>
+#include <linux/ext3_fs.h>
+#include <linux/ext3_jbd.h>
+#include "xattr.h"
+#include "acl.h"
+/*
+ * Called when an inode is released. Note that this is different
+ * from ext3_file_open: open gets called at every open, but release
+ * gets called only when /all/ the files are closed.
+ */
+static int ext3_release_file (struct inode * inode, struct file * filp)
+{
+        /* if we are the last writer on the inode, drop the block reservation */
+        if ((filp->f_mode & FMODE_WRITE) &&
+                        (atomic_read(&inode->i_writecount) == 1))
+                ext3_discard_reservation(inode);
+        if (is_dx(inode) && filp->private_data)
+                ext3_htree_free_dir_info(filp->private_data);
+        return 0;
+}
+static ssize_t
+ext3_file_write(struct kiocb *iocb, const char __user *buf, size_t count, loff_t pos)
+{
+        struct file *file = iocb->ki_filp;
+        struct inode *inode = file->f_dentry->d_inode;
+        ssize_t ret;
+        int err;
+        ret = generic_file_aio_write(iocb, buf, count, pos);
+        /*
+         * Skip flushing if there was an error, or if nothing was written.
+         */
+        if (ret <= 0)
+                return ret;
+        /*
+         * If the inode is IS_SYNC, or is O_SYNC and we are doing data
+         * journalling then we need to make sure that we force the transaction
+         * to disk to keep all metadata uptodate synchronously.
+         */
+        if (file->f_flags & O_SYNC) {
+                /*
+                 * If we are non-data-journaled, then the dirty data has
+                 * already been flushed to backing store by generic_osync_inode,
+                 * and the inode has been flushed too if there have been any
+                 * modifications other than mere timestamp updates.
+                 *
+                 * Open question --- do we care about flushing timestamps too
+                 * if the inode is IS_SYNC?
+                 */
+                if (!ext3_should_journal_data(inode))
+                        return ret;
+                goto force_commit;
+        }
+        /*
+         * So we know that there has been no forced data flush.  If the inode
+         * is marked IS_SYNC, we need to force one ourselves.
+         */
+        if (!IS_SYNC(inode))
+                return ret;
+        /*
+         * Open question #2 --- should we force data to disk here too?  If we
+         * don't, the only impact is that data=writeback filesystems won't
+         * flush data to disk automatically on IS_SYNC, only metadata (but
+         * historically, that is what ext2 has done.)
+         */
+force_commit:
+        err = ext3_force_commit(inode->i_sb);
+        if (err) 
+                return err;
+        return ret;
+}
+struct file_operations ext3_file_operations = {
+        .llseek         = generic_file_llseek,
+        .read           = do_sync_read,
+        .write          = do_sync_write,
+        .aio_read       = generic_file_aio_read,
+        .aio_write      = ext3_file_write,
+        .readv          = generic_file_readv,
+        .writev         = generic_file_writev,
+        .ioctl          = ext3_ioctl,
+        .mmap           = generic_file_mmap,
+        .open           = generic_file_open,
+        .release        = ext3_release_file,
+        .fsync          = ext3_sync_file,
+        .sendfile       = generic_file_sendfile,
+};
+struct inode_operations ext3_file_inode_operations = {
+        .truncate       = ext3_truncate,
+        .setattr        = ext3_setattr,
+#ifdef CONFIG_EXT3_FS_XATTR
+        .setxattr       = generic_setxattr,
+        .getxattr       = generic_getxattr,
+        .listxattr      = ext3_listxattr,
+        .removexattr    = generic_removexattr,
+#endif
+        .permission     = ext3_permission,
+};

diff --git a/fs/ext3/file.c b/fs/ext3/file.c new file mode 100644 index 000000000000..5ad8cf0292df --- /dev/null +++ b/fs/ext3/file.c
@@ -0,0 +1,131 @@
	1	/*
	2	* linux/fs/ext3/file.c
	3	*
	4	* Copyright (C) 1992, 1993, 1994, 1995
	5	* Remy Card (card@masi.ibp.fr)
	6	* Laboratoire MASI - Institut Blaise Pascal
	7	* Universite Pierre et Marie Curie (Paris VI)
	8	*
	9	* from
	10	*
	11	* linux/fs/minix/file.c
	12	*
	13	* Copyright (C) 1991, 1992 Linus Torvalds
	14	*
	15	* ext3 fs regular file handling primitives
	16	*
	17	* 64-bit file support on 64-bit platforms by Jakub Jelinek
	18	* (jj@sunsite.ms.mff.cuni.cz)
	19	*/
	20
	21	#include <linux/time.h>
	22	#include <linux/fs.h>
	23	#include <linux/jbd.h>
	24	#include <linux/ext3_fs.h>
	25	#include <linux/ext3_jbd.h>
	26	#include "xattr.h"
	27	#include "acl.h"
	28
	29	/*
	30	* Called when an inode is released. Note that this is different
	31	* from ext3_file_open: open gets called at every open, but release
	32	* gets called only when /all/ the files are closed.
	33	*/
	34	static int ext3_release_file (struct inode * inode, struct file * filp)
	35	{
	36	/* if we are the last writer on the inode, drop the block reservation */
	37	if ((filp->f_mode & FMODE_WRITE) &&
	38	(atomic_read(&inode->i_writecount) == 1))
	39	ext3_discard_reservation(inode);
	40	if (is_dx(inode) && filp->private_data)
	41	ext3_htree_free_dir_info(filp->private_data);
	42
	43	return 0;
	44	}
	45
	46	static ssize_t
	47	ext3_file_write(struct kiocb iocb, const char __user buf, size_t count, loff_t pos)
	48	{
	49	struct file *file = iocb->ki_filp;
	50	struct inode *inode = file->f_dentry->d_inode;
	51	ssize_t ret;
	52	int err;
	53
	54	ret = generic_file_aio_write(iocb, buf, count, pos);
	55
	56	/*
	57	* Skip flushing if there was an error, or if nothing was written.
	58	*/
	59	if (ret <= 0)
	60	return ret;
	61
	62	/*
	63	* If the inode is IS_SYNC, or is O_SYNC and we are doing data
	64	* journalling then we need to make sure that we force the transaction
	65	* to disk to keep all metadata uptodate synchronously.
	66	*/
	67	if (file->f_flags & O_SYNC) {
	68	/*
	69	* If we are non-data-journaled, then the dirty data has
	70	* already been flushed to backing store by generic_osync_inode,
	71	* and the inode has been flushed too if there have been any
	72	* modifications other than mere timestamp updates.
	73	*
	74	* Open question --- do we care about flushing timestamps too
	75	* if the inode is IS_SYNC?
	76	*/
	77	if (!ext3_should_journal_data(inode))
	78	return ret;
	79
	80	goto force_commit;
	81	}
	82
	83	/*
	84	* So we know that there has been no forced data flush. If the inode
	85	* is marked IS_SYNC, we need to force one ourselves.
	86	*/
	87	if (!IS_SYNC(inode))
	88	return ret;
	89
	90	/*
	91	* Open question #2 --- should we force data to disk here too? If we
	92	* don't, the only impact is that data=writeback filesystems won't
	93	* flush data to disk automatically on IS_SYNC, only metadata (but
	94	* historically, that is what ext2 has done.)
	95	*/
	96
	97	force_commit:
	98	err = ext3_force_commit(inode->i_sb);
	99	if (err)
	100	return err;
	101	return ret;
	102	}
	103
	104	struct file_operations ext3_file_operations = {
	105	.llseek = generic_file_llseek,
	106	.read = do_sync_read,
	107	.write = do_sync_write,
	108	.aio_read = generic_file_aio_read,
	109	.aio_write = ext3_file_write,
	110	.readv = generic_file_readv,
	111	.writev = generic_file_writev,
	112	.ioctl = ext3_ioctl,
	113	.mmap = generic_file_mmap,
	114	.open = generic_file_open,
	115	.release = ext3_release_file,
	116	.fsync = ext3_sync_file,
	117	.sendfile = generic_file_sendfile,
	118	};
	119
	120	struct inode_operations ext3_file_inode_operations = {
	121	.truncate = ext3_truncate,
	122	.setattr = ext3_setattr,
	123	#ifdef CONFIG_EXT3_FS_XATTR
	124	.setxattr = generic_setxattr,
	125	.getxattr = generic_getxattr,
	126	.listxattr = ext3_listxattr,
	127	.removexattr = generic_removexattr,
	128	#endif
	129	.permission = ext3_permission,
	130	};
	131