fs/ntfs/file.c

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