1 files changed, 139 insertions, 0 deletions
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
new file mode 100644
index 000000000000..0b622c0624b7
--- /dev/null
+++ b/fs/ext4/file.c
@@ -0,0 +1,139 @@
+/*
+ *  linux/fs/ext4/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
+ *
+ *  ext4 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/jbd2.h>
+#include <linux/ext4_fs.h>
+#include <linux/ext4_jbd2.h>
+#include "xattr.h"
+#include "acl.h"
+/*
+ * Called when an inode is released. Note that this is different
+ * from ext4_file_open: open gets called at every open, but release
+ * gets called only when /all/ the files are closed.
+ */
+static int ext4_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))
+        {
+                mutex_lock(&EXT4_I(inode)->truncate_mutex);
+                ext4_discard_reservation(inode);
+                mutex_unlock(&EXT4_I(inode)->truncate_mutex);
+        }
+        if (is_dx(inode) && filp->private_data)
+                ext4_htree_free_dir_info(filp->private_data);
+        return 0;
+}
+static ssize_t
+ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
+                unsigned long nr_segs, 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, iov, nr_segs, 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 (!ext4_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 = ext4_force_commit(inode->i_sb);
+        if (err)
+                return err;
+        return ret;
+}
+const struct file_operations ext4_file_operations = {
+        .llseek         = generic_file_llseek,
+        .read           = do_sync_read,
+        .write          = do_sync_write,
+        .aio_read       = generic_file_aio_read,
+        .aio_write      = ext4_file_write,
+        .ioctl          = ext4_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl   = ext4_compat_ioctl,
+#endif
+        .mmap           = generic_file_mmap,
+        .open           = generic_file_open,
+        .release        = ext4_release_file,
+        .fsync          = ext4_sync_file,
+        .sendfile       = generic_file_sendfile,
+        .splice_read    = generic_file_splice_read,
+        .splice_write   = generic_file_splice_write,
+};
+struct inode_operations ext4_file_inode_operations = {
+        .truncate       = ext4_truncate,
+        .setattr        = ext4_setattr,
+#ifdef CONFIG_EXT4DEV_FS_XATTR
+        .setxattr       = generic_setxattr,
+        .getxattr       = generic_getxattr,
+        .listxattr      = ext4_listxattr,
+        .removexattr    = generic_removexattr,
+#endif
+        .permission     = ext4_permission,
+};

diff --git a/fs/ext4/file.c b/fs/ext4/file.c new file mode 100644 index 000000000000..0b622c0624b7 --- /dev/null +++ b/fs/ext4/file.c
@@ -0,0 +1,139 @@
	1	/*
	2	* linux/fs/ext4/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	* ext4 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/jbd2.h>
	24	#include <linux/ext4_fs.h>
	25	#include <linux/ext4_jbd2.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 ext4_file_open: open gets called at every open, but release
	32	* gets called only when /all/ the files are closed.
	33	*/
	34	static int ext4_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	{
	40	mutex_lock(&EXT4_I(inode)->truncate_mutex);
	41	ext4_discard_reservation(inode);
	42	mutex_unlock(&EXT4_I(inode)->truncate_mutex);
	43	}
	44	if (is_dx(inode) && filp->private_data)
	45	ext4_htree_free_dir_info(filp->private_data);
	46
	47	return 0;
	48	}
	49
	50	static ssize_t
	51	ext4_file_write(struct kiocb iocb, const struct iovec iov,
	52	unsigned long nr_segs, loff_t pos)
	53	{
	54	struct file *file = iocb->ki_filp;
	55	struct inode *inode = file->f_dentry->d_inode;
	56	ssize_t ret;
	57	int err;
	58
	59	ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
	60
	61	/*
	62	* Skip flushing if there was an error, or if nothing was written.
	63	*/
	64	if (ret <= 0)
	65	return ret;
	66
	67	/*
	68	* If the inode is IS_SYNC, or is O_SYNC and we are doing data
	69	* journalling then we need to make sure that we force the transaction
	70	* to disk to keep all metadata uptodate synchronously.
	71	*/
	72	if (file->f_flags & O_SYNC) {
	73	/*
	74	* If we are non-data-journaled, then the dirty data has
	75	* already been flushed to backing store by generic_osync_inode,
	76	* and the inode has been flushed too if there have been any
	77	* modifications other than mere timestamp updates.
	78	*
	79	* Open question --- do we care about flushing timestamps too
	80	* if the inode is IS_SYNC?
	81	*/
	82	if (!ext4_should_journal_data(inode))
	83	return ret;
	84
	85	goto force_commit;
	86	}
	87
	88	/*
	89	* So we know that there has been no forced data flush. If the inode
	90	* is marked IS_SYNC, we need to force one ourselves.
	91	*/
	92	if (!IS_SYNC(inode))
	93	return ret;
	94
	95	/*
	96	* Open question #2 --- should we force data to disk here too? If we
	97	* don't, the only impact is that data=writeback filesystems won't
	98	* flush data to disk automatically on IS_SYNC, only metadata (but
	99	* historically, that is what ext2 has done.)
	100	*/
	101
	102	force_commit:
	103	err = ext4_force_commit(inode->i_sb);
	104	if (err)
	105	return err;
	106	return ret;
	107	}
	108
	109	const struct file_operations ext4_file_operations = {
	110	.llseek = generic_file_llseek,
	111	.read = do_sync_read,
	112	.write = do_sync_write,
	113	.aio_read = generic_file_aio_read,
	114	.aio_write = ext4_file_write,
	115	.ioctl = ext4_ioctl,
	116	#ifdef CONFIG_COMPAT
	117	.compat_ioctl = ext4_compat_ioctl,
	118	#endif
	119	.mmap = generic_file_mmap,
	120	.open = generic_file_open,
	121	.release = ext4_release_file,
	122	.fsync = ext4_sync_file,
	123	.sendfile = generic_file_sendfile,
	124	.splice_read = generic_file_splice_read,
	125	.splice_write = generic_file_splice_write,
	126	};
	127
	128	struct inode_operations ext4_file_inode_operations = {
	129	.truncate = ext4_truncate,
	130	.setattr = ext4_setattr,
	131	#ifdef CONFIG_EXT4DEV_FS_XATTR
	132	.setxattr = generic_setxattr,
	133	.getxattr = generic_getxattr,
	134	.listxattr = ext4_listxattr,
	135	.removexattr = generic_removexattr,
	136	#endif
	137	.permission = ext4_permission,
	138	};
	139