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 "ext4.h" 25 #include "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_preallocations(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 static struct vm_operations_struct ext4_file_vm_ops = { 127 .fault = filemap_fault, 128 .page_mkwrite = ext4_page_mkwrite, 129 }; 130 131 static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma) 132 { 133 struct address_space *mapping = file->f_mapping; 134 135 if (!mapping->a_ops->readpage) 136 return -ENOEXEC; 137 file_accessed(file); 138 vma->vm_ops = &ext4_file_vm_ops; 139 vma->vm_flags |= VM_CAN_NONLINEAR; 140 return 0; 141 } 142 143 extern int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 144 __u64 start, __u64 len); 145 146 const struct file_operations ext4_file_operations = { 147 .llseek = generic_file_llseek, 148 .read = do_sync_read, 149 .write = do_sync_write, 150 .aio_read = generic_file_aio_read, 151 .aio_write = ext4_file_write, 152 .unlocked_ioctl = ext4_ioctl, 153 #ifdef CONFIG_COMPAT 154 .compat_ioctl = ext4_compat_ioctl, 155 #endif 156 .mmap = ext4_file_mmap, 157 .open = generic_file_open, 158 .release = ext4_release_file, 159 .fsync = ext4_sync_file, 160 .splice_read = generic_file_splice_read, 161 .splice_write = generic_file_splice_write, 162 }; 163 164 const struct inode_operations ext4_file_inode_operations = { 165 .truncate = ext4_truncate, 166 .setattr = ext4_setattr, 167 .getattr = ext4_getattr, 168 #ifdef CONFIG_EXT4_FS_XATTR 169 .setxattr = generic_setxattr, 170 .getxattr = generic_getxattr, 171 .listxattr = ext4_listxattr, 172 .removexattr = generic_removexattr, 173 #endif 174 .permission = ext4_permission, 175 .fallocate = ext4_fallocate, 176 .fiemap = ext4_fiemap, 177 }; 178 179