1 /*
2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 #include "xfs.h"
19 #include "xfs_bit.h"
20 #include "xfs_log.h"
21 #include "xfs_inum.h"
22 #include "xfs_sb.h"
23 #include "xfs_ag.h"
24 #include "xfs_dir2.h"
25 #include "xfs_trans.h"
26 #include "xfs_dmapi.h"
27 #include "xfs_mount.h"
28 #include "xfs_bmap_btree.h"
29 #include "xfs_alloc_btree.h"
30 #include "xfs_ialloc_btree.h"
31 #include "xfs_alloc.h"
32 #include "xfs_btree.h"
33 #include "xfs_attr_sf.h"
34 #include "xfs_dir2_sf.h"
35 #include "xfs_dinode.h"
36 #include "xfs_inode.h"
37 #include "xfs_error.h"
38 #include "xfs_rw.h"
39 #include "xfs_vnodeops.h"
40 #include "xfs_da_btree.h"
41 #include "xfs_ioctl.h"
42
43 #include <linux/dcache.h>
44 #include <linux/smp_lock.h>
45
46 static struct vm_operations_struct xfs_file_vm_ops;
47
48 STATIC ssize_t
xfs_file_aio_read(struct kiocb * iocb,const struct iovec * iov,unsigned long nr_segs,loff_t pos)49 xfs_file_aio_read(
50 struct kiocb *iocb,
51 const struct iovec *iov,
52 unsigned long nr_segs,
53 loff_t pos)
54 {
55 struct file *file = iocb->ki_filp;
56 int ioflags = IO_ISAIO;
57
58 BUG_ON(iocb->ki_pos != pos);
59 if (unlikely(file->f_flags & O_DIRECT))
60 ioflags |= IO_ISDIRECT;
61 if (file->f_mode & FMODE_NOCMTIME)
62 ioflags |= IO_INVIS;
63 return xfs_read(XFS_I(file->f_path.dentry->d_inode), iocb, iov,
64 nr_segs, &iocb->ki_pos, ioflags);
65 }
66
67 STATIC ssize_t
xfs_file_aio_write(struct kiocb * iocb,const struct iovec * iov,unsigned long nr_segs,loff_t pos)68 xfs_file_aio_write(
69 struct kiocb *iocb,
70 const struct iovec *iov,
71 unsigned long nr_segs,
72 loff_t pos)
73 {
74 struct file *file = iocb->ki_filp;
75 int ioflags = IO_ISAIO;
76
77 BUG_ON(iocb->ki_pos != pos);
78 if (unlikely(file->f_flags & O_DIRECT))
79 ioflags |= IO_ISDIRECT;
80 if (file->f_mode & FMODE_NOCMTIME)
81 ioflags |= IO_INVIS;
82 return xfs_write(XFS_I(file->f_mapping->host), iocb, iov, nr_segs,
83 &iocb->ki_pos, ioflags);
84 }
85
86 STATIC ssize_t
xfs_file_splice_read(struct file * infilp,loff_t * ppos,struct pipe_inode_info * pipe,size_t len,unsigned int flags)87 xfs_file_splice_read(
88 struct file *infilp,
89 loff_t *ppos,
90 struct pipe_inode_info *pipe,
91 size_t len,
92 unsigned int flags)
93 {
94 int ioflags = 0;
95
96 if (infilp->f_mode & FMODE_NOCMTIME)
97 ioflags |= IO_INVIS;
98
99 return xfs_splice_read(XFS_I(infilp->f_path.dentry->d_inode),
100 infilp, ppos, pipe, len, flags, ioflags);
101 }
102
103 STATIC ssize_t
xfs_file_splice_write(struct pipe_inode_info * pipe,struct file * outfilp,loff_t * ppos,size_t len,unsigned int flags)104 xfs_file_splice_write(
105 struct pipe_inode_info *pipe,
106 struct file *outfilp,
107 loff_t *ppos,
108 size_t len,
109 unsigned int flags)
110 {
111 int ioflags = 0;
112
113 if (outfilp->f_mode & FMODE_NOCMTIME)
114 ioflags |= IO_INVIS;
115
116 return xfs_splice_write(XFS_I(outfilp->f_path.dentry->d_inode),
117 pipe, outfilp, ppos, len, flags, ioflags);
118 }
119
120 STATIC int
xfs_file_open(struct inode * inode,struct file * file)121 xfs_file_open(
122 struct inode *inode,
123 struct file *file)
124 {
125 if (!(file->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
126 return -EFBIG;
127 if (XFS_FORCED_SHUTDOWN(XFS_M(inode->i_sb)))
128 return -EIO;
129 return 0;
130 }
131
132 STATIC int
xfs_dir_open(struct inode * inode,struct file * file)133 xfs_dir_open(
134 struct inode *inode,
135 struct file *file)
136 {
137 struct xfs_inode *ip = XFS_I(inode);
138 int mode;
139 int error;
140
141 error = xfs_file_open(inode, file);
142 if (error)
143 return error;
144
145 /*
146 * If there are any blocks, read-ahead block 0 as we're almost
147 * certain to have the next operation be a read there.
148 */
149 mode = xfs_ilock_map_shared(ip);
150 if (ip->i_d.di_nextents > 0)
151 xfs_da_reada_buf(NULL, ip, 0, XFS_DATA_FORK);
152 xfs_iunlock(ip, mode);
153 return 0;
154 }
155
156 STATIC int
xfs_file_release(struct inode * inode,struct file * filp)157 xfs_file_release(
158 struct inode *inode,
159 struct file *filp)
160 {
161 return -xfs_release(XFS_I(inode));
162 }
163
164 /*
165 * We ignore the datasync flag here because a datasync is effectively
166 * identical to an fsync. That is, datasync implies that we need to write
167 * only the metadata needed to be able to access the data that is written
168 * if we crash after the call completes. Hence if we are writing beyond
169 * EOF we have to log the inode size change as well, which makes it a
170 * full fsync. If we don't write beyond EOF, the inode core will be
171 * clean in memory and so we don't need to log the inode, just like
172 * fsync.
173 */
174 STATIC int
xfs_file_fsync(struct file * filp,struct dentry * dentry,int datasync)175 xfs_file_fsync(
176 struct file *filp,
177 struct dentry *dentry,
178 int datasync)
179 {
180 xfs_iflags_clear(XFS_I(dentry->d_inode), XFS_ITRUNCATED);
181 return -xfs_fsync(XFS_I(dentry->d_inode));
182 }
183
184 STATIC int
xfs_file_readdir(struct file * filp,void * dirent,filldir_t filldir)185 xfs_file_readdir(
186 struct file *filp,
187 void *dirent,
188 filldir_t filldir)
189 {
190 struct inode *inode = filp->f_path.dentry->d_inode;
191 xfs_inode_t *ip = XFS_I(inode);
192 int error;
193 size_t bufsize;
194
195 /*
196 * The Linux API doesn't pass down the total size of the buffer
197 * we read into down to the filesystem. With the filldir concept
198 * it's not needed for correct information, but the XFS dir2 leaf
199 * code wants an estimate of the buffer size to calculate it's
200 * readahead window and size the buffers used for mapping to
201 * physical blocks.
202 *
203 * Try to give it an estimate that's good enough, maybe at some
204 * point we can change the ->readdir prototype to include the
205 * buffer size.
206 */
207 bufsize = (size_t)min_t(loff_t, PAGE_SIZE, ip->i_d.di_size);
208
209 error = xfs_readdir(ip, dirent, bufsize,
210 (xfs_off_t *)&filp->f_pos, filldir);
211 if (error)
212 return -error;
213 return 0;
214 }
215
216 STATIC int
xfs_file_mmap(struct file * filp,struct vm_area_struct * vma)217 xfs_file_mmap(
218 struct file *filp,
219 struct vm_area_struct *vma)
220 {
221 vma->vm_ops = &xfs_file_vm_ops;
222 vma->vm_flags |= VM_CAN_NONLINEAR;
223
224 file_accessed(filp);
225 return 0;
226 }
227
228 /*
229 * mmap()d file has taken write protection fault and is being made
230 * writable. We can set the page state up correctly for a writable
231 * page, which means we can do correct delalloc accounting (ENOSPC
232 * checking!) and unwritten extent mapping.
233 */
234 STATIC int
xfs_vm_page_mkwrite(struct vm_area_struct * vma,struct page * page)235 xfs_vm_page_mkwrite(
236 struct vm_area_struct *vma,
237 struct page *page)
238 {
239 return block_page_mkwrite(vma, page, xfs_get_blocks);
240 }
241
242 const struct file_operations xfs_file_operations = {
243 .llseek = generic_file_llseek,
244 .read = do_sync_read,
245 .write = do_sync_write,
246 .aio_read = xfs_file_aio_read,
247 .aio_write = xfs_file_aio_write,
248 .splice_read = xfs_file_splice_read,
249 .splice_write = xfs_file_splice_write,
250 .unlocked_ioctl = xfs_file_ioctl,
251 #ifdef CONFIG_COMPAT
252 .compat_ioctl = xfs_file_compat_ioctl,
253 #endif
254 .mmap = xfs_file_mmap,
255 .open = xfs_file_open,
256 .release = xfs_file_release,
257 .fsync = xfs_file_fsync,
258 #ifdef HAVE_FOP_OPEN_EXEC
259 .open_exec = xfs_file_open_exec,
260 #endif
261 };
262
263 const struct file_operations xfs_dir_file_operations = {
264 .open = xfs_dir_open,
265 .read = generic_read_dir,
266 .readdir = xfs_file_readdir,
267 .llseek = generic_file_llseek,
268 .unlocked_ioctl = xfs_file_ioctl,
269 #ifdef CONFIG_COMPAT
270 .compat_ioctl = xfs_file_compat_ioctl,
271 #endif
272 .fsync = xfs_file_fsync,
273 };
274
275 static struct vm_operations_struct xfs_file_vm_ops = {
276 .fault = filemap_fault,
277 .page_mkwrite = xfs_vm_page_mkwrite,
278 };
279