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 down_write(&EXT4_I(inode)->i_data_sem); 41 ext4_discard_reservation(inode); 42 up_write(&EXT4_I(inode)->i_data_sem); 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 /* 60 * If we have encountered a bitmap-format file, the size limit 61 * is smaller than s_maxbytes, which is for extent-mapped files. 62 */ 63 64 if (!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)) { 65 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 66 size_t length = iov_length(iov, nr_segs); 67 68 if (pos > sbi->s_bitmap_maxbytes) 69 return -EFBIG; 70 71 if (pos + length > sbi->s_bitmap_maxbytes) { 72 nr_segs = iov_shorten((struct iovec *)iov, nr_segs, 73 sbi->s_bitmap_maxbytes - pos); 74 } 75 } 76 77 ret = generic_file_aio_write(iocb, iov, nr_segs, pos); 78 /* 79 * Skip flushing if there was an error, or if nothing was written. 80 */ 81 if (ret <= 0) 82 return ret; 83 84 /* 85 * If the inode is IS_SYNC, or is O_SYNC and we are doing data 86 * journalling then we need to make sure that we force the transaction 87 * to disk to keep all metadata uptodate synchronously. 88 */ 89 if (file->f_flags & O_SYNC) { 90 /* 91 * If we are non-data-journaled, then the dirty data has 92 * already been flushed to backing store by generic_osync_inode, 93 * and the inode has been flushed too if there have been any 94 * modifications other than mere timestamp updates. 95 * 96 * Open question --- do we care about flushing timestamps too 97 * if the inode is IS_SYNC? 98 */ 99 if (!ext4_should_journal_data(inode)) 100 return ret; 101 102 goto force_commit; 103 } 104 105 /* 106 * So we know that there has been no forced data flush. If the inode 107 * is marked IS_SYNC, we need to force one ourselves. 108 */ 109 if (!IS_SYNC(inode)) 110 return ret; 111 112 /* 113 * Open question #2 --- should we force data to disk here too? If we 114 * don't, the only impact is that data=writeback filesystems won't 115 * flush data to disk automatically on IS_SYNC, only metadata (but 116 * historically, that is what ext2 has done.) 117 */ 118 119 force_commit: 120 err = ext4_force_commit(inode->i_sb); 121 if (err) 122 return err; 123 return ret; 124 } 125 126 const struct file_operations ext4_file_operations = { 127 .llseek = generic_file_llseek, 128 .read = do_sync_read, 129 .write = do_sync_write, 130 .aio_read = generic_file_aio_read, 131 .aio_write = ext4_file_write, 132 .ioctl = ext4_ioctl, 133 #ifdef CONFIG_COMPAT 134 .compat_ioctl = ext4_compat_ioctl, 135 #endif 136 .mmap = generic_file_mmap, 137 .open = generic_file_open, 138 .release = ext4_release_file, 139 .fsync = ext4_sync_file, 140 .splice_read = generic_file_splice_read, 141 .splice_write = generic_file_splice_write, 142 }; 143 144 const struct inode_operations ext4_file_inode_operations = { 145 .truncate = ext4_truncate, 146 .setattr = ext4_setattr, 147 #ifdef CONFIG_EXT4DEV_FS_XATTR 148 .setxattr = generic_setxattr, 149 .getxattr = generic_getxattr, 150 .listxattr = ext4_listxattr, 151 .removexattr = generic_removexattr, 152 #endif 153 .permission = ext4_permission, 154 .fallocate = ext4_fallocate, 155 }; 156 157