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 */ 34static 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 { 40 mutex_lock(&EXT3_I(inode)->truncate_mutex); 41 ext3_discard_reservation(inode); 42 mutex_unlock(&EXT3_I(inode)->truncate_mutex); 43 } 44 if (is_dx(inode) && filp->private_data) 45 ext3_htree_free_dir_info(filp->private_data); 46 47 return 0; 48} 49 50static ssize_t 51ext3_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 (!ext3_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 102force_commit: 103 err = ext3_force_commit(inode->i_sb); 104 if (err) 105 return err; 106 return ret; 107} 108 109const struct file_operations ext3_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 = ext3_file_write, 115 .ioctl = ext3_ioctl, 116#ifdef CONFIG_COMPAT 117 .compat_ioctl = ext3_compat_ioctl, 118#endif 119 .mmap = generic_file_mmap, 120 .open = generic_file_open, 121 .release = ext3_release_file, 122 .fsync = ext3_sync_file, 123 .sendfile = generic_file_sendfile, 124 .splice_read = generic_file_splice_read, 125 .splice_write = generic_file_splice_write, 126}; 127 128const struct inode_operations ext3_file_inode_operations = { 129 .truncate = ext3_truncate, 130 .setattr = ext3_setattr, 131#ifdef CONFIG_EXT3_FS_XATTR 132 .setxattr = generic_setxattr, 133 .getxattr = generic_getxattr, 134 .listxattr = ext3_listxattr, 135 .removexattr = generic_removexattr, 136#endif 137 .permission = ext3_permission, 138}; 139