1 /* 2 * file.c - NTFS kernel file operations. Part of the Linux-NTFS project. 3 * 4 * Copyright (c) 2001-2004 Anton Altaparmakov 5 * 6 * This program/include file is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as published 8 * by the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program/include file is distributed in the hope that it will be 12 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 13 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program (in the main directory of the Linux-NTFS 18 * distribution in the file COPYING); if not, write to the Free Software 19 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22 #include <linux/pagemap.h> 23 #include <linux/buffer_head.h> 24 25 #include "inode.h" 26 #include "debug.h" 27 #include "ntfs.h" 28 29 /** 30 * ntfs_file_open - called when an inode is about to be opened 31 * @vi: inode to be opened 32 * @filp: file structure describing the inode 33 * 34 * Limit file size to the page cache limit on architectures where unsigned long 35 * is 32-bits. This is the most we can do for now without overflowing the page 36 * cache page index. Doing it this way means we don't run into problems because 37 * of existing too large files. It would be better to allow the user to read 38 * the beginning of the file but I doubt very much anyone is going to hit this 39 * check on a 32-bit architecture, so there is no point in adding the extra 40 * complexity required to support this. 41 * 42 * On 64-bit architectures, the check is hopefully optimized away by the 43 * compiler. 44 * 45 * After the check passes, just call generic_file_open() to do its work. 46 */ 47 static int ntfs_file_open(struct inode *vi, struct file *filp) 48 { 49 if (sizeof(unsigned long) < 8) { 50 if (vi->i_size > MAX_LFS_FILESIZE) 51 return -EFBIG; 52 } 53 return generic_file_open(vi, filp); 54 } 55 56 #ifdef NTFS_RW 57 58 /** 59 * ntfs_file_fsync - sync a file to disk 60 * @filp: file to be synced 61 * @dentry: dentry describing the file to sync 62 * @datasync: if non-zero only flush user data and not metadata 63 * 64 * Data integrity sync of a file to disk. Used for fsync, fdatasync, and msync 65 * system calls. This function is inspired by fs/buffer.c::file_fsync(). 66 * 67 * If @datasync is false, write the mft record and all associated extent mft 68 * records as well as the $DATA attribute and then sync the block device. 69 * 70 * If @datasync is true and the attribute is non-resident, we skip the writing 71 * of the mft record and all associated extent mft records (this might still 72 * happen due to the write_inode_now() call). 73 * 74 * Also, if @datasync is true, we do not wait on the inode to be written out 75 * but we always wait on the page cache pages to be written out. 76 * 77 * Note: In the past @filp could be NULL so we ignore it as we don't need it 78 * anyway. 79 * 80 * Locking: Caller must hold i_sem on the inode. 81 * 82 * TODO: We should probably also write all attribute/index inodes associated 83 * with this inode but since we have no simple way of getting to them we ignore 84 * this problem for now. 85 */ 86 static int ntfs_file_fsync(struct file *filp, struct dentry *dentry, 87 int datasync) 88 { 89 struct inode *vi = dentry->d_inode; 90 int err, ret = 0; 91 92 ntfs_debug("Entering for inode 0x%lx.", vi->i_ino); 93 BUG_ON(S_ISDIR(vi->i_mode)); 94 if (!datasync || !NInoNonResident(NTFS_I(vi))) 95 ret = ntfs_write_inode(vi, 1); 96 write_inode_now(vi, !datasync); 97 err = sync_blockdev(vi->i_sb->s_bdev); 98 if (unlikely(err && !ret)) 99 ret = err; 100 if (likely(!ret)) 101 ntfs_debug("Done."); 102 else 103 ntfs_warning(vi->i_sb, "Failed to f%ssync inode 0x%lx. Error " 104 "%u.", datasync ? "data" : "", vi->i_ino, -ret); 105 return ret; 106 } 107 108 #endif /* NTFS_RW */ 109 110 struct file_operations ntfs_file_ops = { 111 .llseek = generic_file_llseek, /* Seek inside file. */ 112 .read = generic_file_read, /* Read from file. */ 113 .aio_read = generic_file_aio_read, /* Async read from file. */ 114 .readv = generic_file_readv, /* Read from file. */ 115 #ifdef NTFS_RW 116 .write = generic_file_write, /* Write to file. */ 117 .aio_write = generic_file_aio_write, /* Async write to file. */ 118 .writev = generic_file_writev, /* Write to file. */ 119 /*.release = ,*/ /* Last file is closed. See 120 fs/ext2/file.c:: 121 ext2_release_file() for 122 how to use this to discard 123 preallocated space for 124 write opened files. */ 125 .fsync = ntfs_file_fsync, /* Sync a file to disk. */ 126 /*.aio_fsync = ,*/ /* Sync all outstanding async 127 i/o operations on a 128 kiocb. */ 129 #endif /* NTFS_RW */ 130 /*.ioctl = ,*/ /* Perform function on the 131 mounted filesystem. */ 132 .mmap = generic_file_mmap, /* Mmap file. */ 133 .open = ntfs_file_open, /* Open file. */ 134 .sendfile = generic_file_sendfile, /* Zero-copy data send with 135 the data source being on 136 the ntfs partition. We 137 do not need to care about 138 the data destination. */ 139 /*.sendpage = ,*/ /* Zero-copy data send with 140 the data destination being 141 on the ntfs partition. We 142 do not need to care about 143 the data source. */ 144 }; 145 146 struct inode_operations ntfs_file_inode_ops = { 147 #ifdef NTFS_RW 148 .truncate = ntfs_truncate_vfs, 149 .setattr = ntfs_setattr, 150 #endif /* NTFS_RW */ 151 }; 152 153 struct file_operations ntfs_empty_file_ops = {}; 154 155 struct inode_operations ntfs_empty_inode_ops = {}; 156