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_path.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 .splice_read = generic_file_splice_read, 124 .splice_write = generic_file_splice_write, 125 }; 126 127 const struct inode_operations ext4_file_inode_operations = { 128 .truncate = ext4_truncate, 129 .setattr = ext4_setattr, 130 #ifdef CONFIG_EXT4DEV_FS_XATTR 131 .setxattr = generic_setxattr, 132 .getxattr = generic_getxattr, 133 .listxattr = ext4_listxattr, 134 .removexattr = generic_removexattr, 135 #endif 136 .permission = ext4_permission, 137 .fallocate = ext4_fallocate, 138 }; 139 140