blob: e0f530ce6b996280eb718792a9ac048a348845c2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 */
47static int ntfs_file_open(struct inode *vi, struct file *filp)
48{
49 if (sizeof(unsigned long) < 8) {
Anton Altaparmakovd4b9ba72004-11-17 15:45:08 +000050 if (i_size_read(vi) > MAX_LFS_FILESIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 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 */
86static 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
110struct 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
146struct 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
153struct file_operations ntfs_empty_file_ops = {};
154
155struct inode_operations ntfs_empty_inode_ops = {};