xfs: Move handling of missing page into one place in xfs_find_get_desired_pgoff()
[sfrench/cifs-2.6.git] / fs / xfs / xfs_file.c
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_fs.h"
20 #include "xfs_shared.h"
21 #include "xfs_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
24 #include "xfs_mount.h"
25 #include "xfs_da_format.h"
26 #include "xfs_da_btree.h"
27 #include "xfs_inode.h"
28 #include "xfs_trans.h"
29 #include "xfs_inode_item.h"
30 #include "xfs_bmap.h"
31 #include "xfs_bmap_util.h"
32 #include "xfs_error.h"
33 #include "xfs_dir2.h"
34 #include "xfs_dir2_priv.h"
35 #include "xfs_ioctl.h"
36 #include "xfs_trace.h"
37 #include "xfs_log.h"
38 #include "xfs_icache.h"
39 #include "xfs_pnfs.h"
40 #include "xfs_iomap.h"
41 #include "xfs_reflink.h"
42
43 #include <linux/dcache.h>
44 #include <linux/falloc.h>
45 #include <linux/pagevec.h>
46 #include <linux/backing-dev.h>
47
48 static const struct vm_operations_struct xfs_file_vm_ops;
49
50 /*
51  * Clear the specified ranges to zero through either the pagecache or DAX.
52  * Holes and unwritten extents will be left as-is as they already are zeroed.
53  */
54 int
55 xfs_zero_range(
56         struct xfs_inode        *ip,
57         xfs_off_t               pos,
58         xfs_off_t               count,
59         bool                    *did_zero)
60 {
61         return iomap_zero_range(VFS_I(ip), pos, count, NULL, &xfs_iomap_ops);
62 }
63
64 int
65 xfs_update_prealloc_flags(
66         struct xfs_inode        *ip,
67         enum xfs_prealloc_flags flags)
68 {
69         struct xfs_trans        *tp;
70         int                     error;
71
72         error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_writeid,
73                         0, 0, 0, &tp);
74         if (error)
75                 return error;
76
77         xfs_ilock(ip, XFS_ILOCK_EXCL);
78         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
79
80         if (!(flags & XFS_PREALLOC_INVISIBLE)) {
81                 VFS_I(ip)->i_mode &= ~S_ISUID;
82                 if (VFS_I(ip)->i_mode & S_IXGRP)
83                         VFS_I(ip)->i_mode &= ~S_ISGID;
84                 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
85         }
86
87         if (flags & XFS_PREALLOC_SET)
88                 ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
89         if (flags & XFS_PREALLOC_CLEAR)
90                 ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
91
92         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
93         if (flags & XFS_PREALLOC_SYNC)
94                 xfs_trans_set_sync(tp);
95         return xfs_trans_commit(tp);
96 }
97
98 /*
99  * Fsync operations on directories are much simpler than on regular files,
100  * as there is no file data to flush, and thus also no need for explicit
101  * cache flush operations, and there are no non-transaction metadata updates
102  * on directories either.
103  */
104 STATIC int
105 xfs_dir_fsync(
106         struct file             *file,
107         loff_t                  start,
108         loff_t                  end,
109         int                     datasync)
110 {
111         struct xfs_inode        *ip = XFS_I(file->f_mapping->host);
112         struct xfs_mount        *mp = ip->i_mount;
113         xfs_lsn_t               lsn = 0;
114
115         trace_xfs_dir_fsync(ip);
116
117         xfs_ilock(ip, XFS_ILOCK_SHARED);
118         if (xfs_ipincount(ip))
119                 lsn = ip->i_itemp->ili_last_lsn;
120         xfs_iunlock(ip, XFS_ILOCK_SHARED);
121
122         if (!lsn)
123                 return 0;
124         return _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
125 }
126
127 STATIC int
128 xfs_file_fsync(
129         struct file             *file,
130         loff_t                  start,
131         loff_t                  end,
132         int                     datasync)
133 {
134         struct inode            *inode = file->f_mapping->host;
135         struct xfs_inode        *ip = XFS_I(inode);
136         struct xfs_mount        *mp = ip->i_mount;
137         int                     error = 0;
138         int                     log_flushed = 0;
139         xfs_lsn_t               lsn = 0;
140
141         trace_xfs_file_fsync(ip);
142
143         error = filemap_write_and_wait_range(inode->i_mapping, start, end);
144         if (error)
145                 return error;
146
147         if (XFS_FORCED_SHUTDOWN(mp))
148                 return -EIO;
149
150         xfs_iflags_clear(ip, XFS_ITRUNCATED);
151
152         /*
153          * If we have an RT and/or log subvolume we need to make sure to flush
154          * the write cache the device used for file data first.  This is to
155          * ensure newly written file data make it to disk before logging the new
156          * inode size in case of an extending write.
157          */
158         if (XFS_IS_REALTIME_INODE(ip))
159                 xfs_blkdev_issue_flush(mp->m_rtdev_targp);
160         else if (mp->m_logdev_targp != mp->m_ddev_targp)
161                 xfs_blkdev_issue_flush(mp->m_ddev_targp);
162
163         /*
164          * All metadata updates are logged, which means that we just have to
165          * flush the log up to the latest LSN that touched the inode. If we have
166          * concurrent fsync/fdatasync() calls, we need them to all block on the
167          * log force before we clear the ili_fsync_fields field. This ensures
168          * that we don't get a racing sync operation that does not wait for the
169          * metadata to hit the journal before returning. If we race with
170          * clearing the ili_fsync_fields, then all that will happen is the log
171          * force will do nothing as the lsn will already be on disk. We can't
172          * race with setting ili_fsync_fields because that is done under
173          * XFS_ILOCK_EXCL, and that can't happen because we hold the lock shared
174          * until after the ili_fsync_fields is cleared.
175          */
176         xfs_ilock(ip, XFS_ILOCK_SHARED);
177         if (xfs_ipincount(ip)) {
178                 if (!datasync ||
179                     (ip->i_itemp->ili_fsync_fields & ~XFS_ILOG_TIMESTAMP))
180                         lsn = ip->i_itemp->ili_last_lsn;
181         }
182
183         if (lsn) {
184                 error = _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, &log_flushed);
185                 ip->i_itemp->ili_fsync_fields = 0;
186         }
187         xfs_iunlock(ip, XFS_ILOCK_SHARED);
188
189         /*
190          * If we only have a single device, and the log force about was
191          * a no-op we might have to flush the data device cache here.
192          * This can only happen for fdatasync/O_DSYNC if we were overwriting
193          * an already allocated file and thus do not have any metadata to
194          * commit.
195          */
196         if (!log_flushed && !XFS_IS_REALTIME_INODE(ip) &&
197             mp->m_logdev_targp == mp->m_ddev_targp)
198                 xfs_blkdev_issue_flush(mp->m_ddev_targp);
199
200         return error;
201 }
202
203 STATIC ssize_t
204 xfs_file_dio_aio_read(
205         struct kiocb            *iocb,
206         struct iov_iter         *to)
207 {
208         struct xfs_inode        *ip = XFS_I(file_inode(iocb->ki_filp));
209         size_t                  count = iov_iter_count(to);
210         ssize_t                 ret;
211
212         trace_xfs_file_direct_read(ip, count, iocb->ki_pos);
213
214         if (!count)
215                 return 0; /* skip atime */
216
217         file_accessed(iocb->ki_filp);
218
219         xfs_ilock(ip, XFS_IOLOCK_SHARED);
220         ret = iomap_dio_rw(iocb, to, &xfs_iomap_ops, NULL);
221         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
222
223         return ret;
224 }
225
226 static noinline ssize_t
227 xfs_file_dax_read(
228         struct kiocb            *iocb,
229         struct iov_iter         *to)
230 {
231         struct xfs_inode        *ip = XFS_I(iocb->ki_filp->f_mapping->host);
232         size_t                  count = iov_iter_count(to);
233         ssize_t                 ret = 0;
234
235         trace_xfs_file_dax_read(ip, count, iocb->ki_pos);
236
237         if (!count)
238                 return 0; /* skip atime */
239
240         xfs_ilock(ip, XFS_IOLOCK_SHARED);
241         ret = dax_iomap_rw(iocb, to, &xfs_iomap_ops);
242         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
243
244         file_accessed(iocb->ki_filp);
245         return ret;
246 }
247
248 STATIC ssize_t
249 xfs_file_buffered_aio_read(
250         struct kiocb            *iocb,
251         struct iov_iter         *to)
252 {
253         struct xfs_inode        *ip = XFS_I(file_inode(iocb->ki_filp));
254         ssize_t                 ret;
255
256         trace_xfs_file_buffered_read(ip, iov_iter_count(to), iocb->ki_pos);
257
258         xfs_ilock(ip, XFS_IOLOCK_SHARED);
259         ret = generic_file_read_iter(iocb, to);
260         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
261
262         return ret;
263 }
264
265 STATIC ssize_t
266 xfs_file_read_iter(
267         struct kiocb            *iocb,
268         struct iov_iter         *to)
269 {
270         struct inode            *inode = file_inode(iocb->ki_filp);
271         struct xfs_mount        *mp = XFS_I(inode)->i_mount;
272         ssize_t                 ret = 0;
273
274         XFS_STATS_INC(mp, xs_read_calls);
275
276         if (XFS_FORCED_SHUTDOWN(mp))
277                 return -EIO;
278
279         if (IS_DAX(inode))
280                 ret = xfs_file_dax_read(iocb, to);
281         else if (iocb->ki_flags & IOCB_DIRECT)
282                 ret = xfs_file_dio_aio_read(iocb, to);
283         else
284                 ret = xfs_file_buffered_aio_read(iocb, to);
285
286         if (ret > 0)
287                 XFS_STATS_ADD(mp, xs_read_bytes, ret);
288         return ret;
289 }
290
291 /*
292  * Zero any on disk space between the current EOF and the new, larger EOF.
293  *
294  * This handles the normal case of zeroing the remainder of the last block in
295  * the file and the unusual case of zeroing blocks out beyond the size of the
296  * file.  This second case only happens with fixed size extents and when the
297  * system crashes before the inode size was updated but after blocks were
298  * allocated.
299  *
300  * Expects the iolock to be held exclusive, and will take the ilock internally.
301  */
302 int                                     /* error (positive) */
303 xfs_zero_eof(
304         struct xfs_inode        *ip,
305         xfs_off_t               offset,         /* starting I/O offset */
306         xfs_fsize_t             isize,          /* current inode size */
307         bool                    *did_zeroing)
308 {
309         ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
310         ASSERT(offset > isize);
311
312         trace_xfs_zero_eof(ip, isize, offset - isize);
313         return xfs_zero_range(ip, isize, offset - isize, did_zeroing);
314 }
315
316 /*
317  * Common pre-write limit and setup checks.
318  *
319  * Called with the iolocked held either shared and exclusive according to
320  * @iolock, and returns with it held.  Might upgrade the iolock to exclusive
321  * if called for a direct write beyond i_size.
322  */
323 STATIC ssize_t
324 xfs_file_aio_write_checks(
325         struct kiocb            *iocb,
326         struct iov_iter         *from,
327         int                     *iolock)
328 {
329         struct file             *file = iocb->ki_filp;
330         struct inode            *inode = file->f_mapping->host;
331         struct xfs_inode        *ip = XFS_I(inode);
332         ssize_t                 error = 0;
333         size_t                  count = iov_iter_count(from);
334         bool                    drained_dio = false;
335
336 restart:
337         error = generic_write_checks(iocb, from);
338         if (error <= 0)
339                 return error;
340
341         error = xfs_break_layouts(inode, iolock);
342         if (error)
343                 return error;
344
345         /*
346          * For changing security info in file_remove_privs() we need i_rwsem
347          * exclusively.
348          */
349         if (*iolock == XFS_IOLOCK_SHARED && !IS_NOSEC(inode)) {
350                 xfs_iunlock(ip, *iolock);
351                 *iolock = XFS_IOLOCK_EXCL;
352                 xfs_ilock(ip, *iolock);
353                 goto restart;
354         }
355         /*
356          * If the offset is beyond the size of the file, we need to zero any
357          * blocks that fall between the existing EOF and the start of this
358          * write.  If zeroing is needed and we are currently holding the
359          * iolock shared, we need to update it to exclusive which implies
360          * having to redo all checks before.
361          *
362          * We need to serialise against EOF updates that occur in IO
363          * completions here. We want to make sure that nobody is changing the
364          * size while we do this check until we have placed an IO barrier (i.e.
365          * hold the XFS_IOLOCK_EXCL) that prevents new IO from being dispatched.
366          * The spinlock effectively forms a memory barrier once we have the
367          * XFS_IOLOCK_EXCL so we are guaranteed to see the latest EOF value
368          * and hence be able to correctly determine if we need to run zeroing.
369          */
370         spin_lock(&ip->i_flags_lock);
371         if (iocb->ki_pos > i_size_read(inode)) {
372                 bool    zero = false;
373
374                 spin_unlock(&ip->i_flags_lock);
375                 if (!drained_dio) {
376                         if (*iolock == XFS_IOLOCK_SHARED) {
377                                 xfs_iunlock(ip, *iolock);
378                                 *iolock = XFS_IOLOCK_EXCL;
379                                 xfs_ilock(ip, *iolock);
380                                 iov_iter_reexpand(from, count);
381                         }
382                         /*
383                          * We now have an IO submission barrier in place, but
384                          * AIO can do EOF updates during IO completion and hence
385                          * we now need to wait for all of them to drain. Non-AIO
386                          * DIO will have drained before we are given the
387                          * XFS_IOLOCK_EXCL, and so for most cases this wait is a
388                          * no-op.
389                          */
390                         inode_dio_wait(inode);
391                         drained_dio = true;
392                         goto restart;
393                 }
394                 error = xfs_zero_eof(ip, iocb->ki_pos, i_size_read(inode), &zero);
395                 if (error)
396                         return error;
397         } else
398                 spin_unlock(&ip->i_flags_lock);
399
400         /*
401          * Updating the timestamps will grab the ilock again from
402          * xfs_fs_dirty_inode, so we have to call it after dropping the
403          * lock above.  Eventually we should look into a way to avoid
404          * the pointless lock roundtrip.
405          */
406         if (likely(!(file->f_mode & FMODE_NOCMTIME))) {
407                 error = file_update_time(file);
408                 if (error)
409                         return error;
410         }
411
412         /*
413          * If we're writing the file then make sure to clear the setuid and
414          * setgid bits if the process is not being run by root.  This keeps
415          * people from modifying setuid and setgid binaries.
416          */
417         if (!IS_NOSEC(inode))
418                 return file_remove_privs(file);
419         return 0;
420 }
421
422 static int
423 xfs_dio_write_end_io(
424         struct kiocb            *iocb,
425         ssize_t                 size,
426         unsigned                flags)
427 {
428         struct inode            *inode = file_inode(iocb->ki_filp);
429         struct xfs_inode        *ip = XFS_I(inode);
430         loff_t                  offset = iocb->ki_pos;
431         bool                    update_size = false;
432         int                     error = 0;
433
434         trace_xfs_end_io_direct_write(ip, offset, size);
435
436         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
437                 return -EIO;
438
439         if (size <= 0)
440                 return size;
441
442         /*
443          * We need to update the in-core inode size here so that we don't end up
444          * with the on-disk inode size being outside the in-core inode size. We
445          * have no other method of updating EOF for AIO, so always do it here
446          * if necessary.
447          *
448          * We need to lock the test/set EOF update as we can be racing with
449          * other IO completions here to update the EOF. Failing to serialise
450          * here can result in EOF moving backwards and Bad Things Happen when
451          * that occurs.
452          */
453         spin_lock(&ip->i_flags_lock);
454         if (offset + size > i_size_read(inode)) {
455                 i_size_write(inode, offset + size);
456                 update_size = true;
457         }
458         spin_unlock(&ip->i_flags_lock);
459
460         if (flags & IOMAP_DIO_COW) {
461                 error = xfs_reflink_end_cow(ip, offset, size);
462                 if (error)
463                         return error;
464         }
465
466         if (flags & IOMAP_DIO_UNWRITTEN)
467                 error = xfs_iomap_write_unwritten(ip, offset, size);
468         else if (update_size)
469                 error = xfs_setfilesize(ip, offset, size);
470
471         return error;
472 }
473
474 /*
475  * xfs_file_dio_aio_write - handle direct IO writes
476  *
477  * Lock the inode appropriately to prepare for and issue a direct IO write.
478  * By separating it from the buffered write path we remove all the tricky to
479  * follow locking changes and looping.
480  *
481  * If there are cached pages or we're extending the file, we need IOLOCK_EXCL
482  * until we're sure the bytes at the new EOF have been zeroed and/or the cached
483  * pages are flushed out.
484  *
485  * In most cases the direct IO writes will be done holding IOLOCK_SHARED
486  * allowing them to be done in parallel with reads and other direct IO writes.
487  * However, if the IO is not aligned to filesystem blocks, the direct IO layer
488  * needs to do sub-block zeroing and that requires serialisation against other
489  * direct IOs to the same block. In this case we need to serialise the
490  * submission of the unaligned IOs so that we don't get racing block zeroing in
491  * the dio layer.  To avoid the problem with aio, we also need to wait for
492  * outstanding IOs to complete so that unwritten extent conversion is completed
493  * before we try to map the overlapping block. This is currently implemented by
494  * hitting it with a big hammer (i.e. inode_dio_wait()).
495  *
496  * Returns with locks held indicated by @iolock and errors indicated by
497  * negative return values.
498  */
499 STATIC ssize_t
500 xfs_file_dio_aio_write(
501         struct kiocb            *iocb,
502         struct iov_iter         *from)
503 {
504         struct file             *file = iocb->ki_filp;
505         struct address_space    *mapping = file->f_mapping;
506         struct inode            *inode = mapping->host;
507         struct xfs_inode        *ip = XFS_I(inode);
508         struct xfs_mount        *mp = ip->i_mount;
509         ssize_t                 ret = 0;
510         int                     unaligned_io = 0;
511         int                     iolock;
512         size_t                  count = iov_iter_count(from);
513         struct xfs_buftarg      *target = XFS_IS_REALTIME_INODE(ip) ?
514                                         mp->m_rtdev_targp : mp->m_ddev_targp;
515
516         /* DIO must be aligned to device logical sector size */
517         if ((iocb->ki_pos | count) & target->bt_logical_sectormask)
518                 return -EINVAL;
519
520         /*
521          * Don't take the exclusive iolock here unless the I/O is unaligned to
522          * the file system block size.  We don't need to consider the EOF
523          * extension case here because xfs_file_aio_write_checks() will relock
524          * the inode as necessary for EOF zeroing cases and fill out the new
525          * inode size as appropriate.
526          */
527         if ((iocb->ki_pos & mp->m_blockmask) ||
528             ((iocb->ki_pos + count) & mp->m_blockmask)) {
529                 unaligned_io = 1;
530
531                 /*
532                  * We can't properly handle unaligned direct I/O to reflink
533                  * files yet, as we can't unshare a partial block.
534                  */
535                 if (xfs_is_reflink_inode(ip)) {
536                         trace_xfs_reflink_bounce_dio_write(ip, iocb->ki_pos, count);
537                         return -EREMCHG;
538                 }
539                 iolock = XFS_IOLOCK_EXCL;
540         } else {
541                 iolock = XFS_IOLOCK_SHARED;
542         }
543
544         xfs_ilock(ip, iolock);
545
546         ret = xfs_file_aio_write_checks(iocb, from, &iolock);
547         if (ret)
548                 goto out;
549         count = iov_iter_count(from);
550
551         /*
552          * If we are doing unaligned IO, wait for all other IO to drain,
553          * otherwise demote the lock if we had to take the exclusive lock
554          * for other reasons in xfs_file_aio_write_checks.
555          */
556         if (unaligned_io)
557                 inode_dio_wait(inode);
558         else if (iolock == XFS_IOLOCK_EXCL) {
559                 xfs_ilock_demote(ip, XFS_IOLOCK_EXCL);
560                 iolock = XFS_IOLOCK_SHARED;
561         }
562
563         trace_xfs_file_direct_write(ip, count, iocb->ki_pos);
564         ret = iomap_dio_rw(iocb, from, &xfs_iomap_ops, xfs_dio_write_end_io);
565 out:
566         xfs_iunlock(ip, iolock);
567
568         /*
569          * No fallback to buffered IO on errors for XFS, direct IO will either
570          * complete fully or fail.
571          */
572         ASSERT(ret < 0 || ret == count);
573         return ret;
574 }
575
576 static noinline ssize_t
577 xfs_file_dax_write(
578         struct kiocb            *iocb,
579         struct iov_iter         *from)
580 {
581         struct inode            *inode = iocb->ki_filp->f_mapping->host;
582         struct xfs_inode        *ip = XFS_I(inode);
583         int                     iolock = XFS_IOLOCK_EXCL;
584         ssize_t                 ret, error = 0;
585         size_t                  count;
586         loff_t                  pos;
587
588         xfs_ilock(ip, iolock);
589         ret = xfs_file_aio_write_checks(iocb, from, &iolock);
590         if (ret)
591                 goto out;
592
593         pos = iocb->ki_pos;
594         count = iov_iter_count(from);
595
596         trace_xfs_file_dax_write(ip, count, pos);
597         ret = dax_iomap_rw(iocb, from, &xfs_iomap_ops);
598         if (ret > 0 && iocb->ki_pos > i_size_read(inode)) {
599                 i_size_write(inode, iocb->ki_pos);
600                 error = xfs_setfilesize(ip, pos, ret);
601         }
602 out:
603         xfs_iunlock(ip, iolock);
604         return error ? error : ret;
605 }
606
607 STATIC ssize_t
608 xfs_file_buffered_aio_write(
609         struct kiocb            *iocb,
610         struct iov_iter         *from)
611 {
612         struct file             *file = iocb->ki_filp;
613         struct address_space    *mapping = file->f_mapping;
614         struct inode            *inode = mapping->host;
615         struct xfs_inode        *ip = XFS_I(inode);
616         ssize_t                 ret;
617         int                     enospc = 0;
618         int                     iolock;
619
620 write_retry:
621         iolock = XFS_IOLOCK_EXCL;
622         xfs_ilock(ip, iolock);
623
624         ret = xfs_file_aio_write_checks(iocb, from, &iolock);
625         if (ret)
626                 goto out;
627
628         /* We can write back this queue in page reclaim */
629         current->backing_dev_info = inode_to_bdi(inode);
630
631         trace_xfs_file_buffered_write(ip, iov_iter_count(from), iocb->ki_pos);
632         ret = iomap_file_buffered_write(iocb, from, &xfs_iomap_ops);
633         if (likely(ret >= 0))
634                 iocb->ki_pos += ret;
635
636         /*
637          * If we hit a space limit, try to free up some lingering preallocated
638          * space before returning an error. In the case of ENOSPC, first try to
639          * write back all dirty inodes to free up some of the excess reserved
640          * metadata space. This reduces the chances that the eofblocks scan
641          * waits on dirty mappings. Since xfs_flush_inodes() is serialized, this
642          * also behaves as a filter to prevent too many eofblocks scans from
643          * running at the same time.
644          */
645         if (ret == -EDQUOT && !enospc) {
646                 xfs_iunlock(ip, iolock);
647                 enospc = xfs_inode_free_quota_eofblocks(ip);
648                 if (enospc)
649                         goto write_retry;
650                 enospc = xfs_inode_free_quota_cowblocks(ip);
651                 if (enospc)
652                         goto write_retry;
653                 iolock = 0;
654         } else if (ret == -ENOSPC && !enospc) {
655                 struct xfs_eofblocks eofb = {0};
656
657                 enospc = 1;
658                 xfs_flush_inodes(ip->i_mount);
659
660                 xfs_iunlock(ip, iolock);
661                 eofb.eof_flags = XFS_EOF_FLAGS_SYNC;
662                 xfs_icache_free_eofblocks(ip->i_mount, &eofb);
663                 goto write_retry;
664         }
665
666         current->backing_dev_info = NULL;
667 out:
668         if (iolock)
669                 xfs_iunlock(ip, iolock);
670         return ret;
671 }
672
673 STATIC ssize_t
674 xfs_file_write_iter(
675         struct kiocb            *iocb,
676         struct iov_iter         *from)
677 {
678         struct file             *file = iocb->ki_filp;
679         struct address_space    *mapping = file->f_mapping;
680         struct inode            *inode = mapping->host;
681         struct xfs_inode        *ip = XFS_I(inode);
682         ssize_t                 ret;
683         size_t                  ocount = iov_iter_count(from);
684
685         XFS_STATS_INC(ip->i_mount, xs_write_calls);
686
687         if (ocount == 0)
688                 return 0;
689
690         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
691                 return -EIO;
692
693         if (IS_DAX(inode))
694                 ret = xfs_file_dax_write(iocb, from);
695         else if (iocb->ki_flags & IOCB_DIRECT) {
696                 /*
697                  * Allow a directio write to fall back to a buffered
698                  * write *only* in the case that we're doing a reflink
699                  * CoW.  In all other directio scenarios we do not
700                  * allow an operation to fall back to buffered mode.
701                  */
702                 ret = xfs_file_dio_aio_write(iocb, from);
703                 if (ret == -EREMCHG)
704                         goto buffered;
705         } else {
706 buffered:
707                 ret = xfs_file_buffered_aio_write(iocb, from);
708         }
709
710         if (ret > 0) {
711                 XFS_STATS_ADD(ip->i_mount, xs_write_bytes, ret);
712
713                 /* Handle various SYNC-type writes */
714                 ret = generic_write_sync(iocb, ret);
715         }
716         return ret;
717 }
718
719 #define XFS_FALLOC_FL_SUPPORTED                                         \
720                 (FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |           \
721                  FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |      \
722                  FALLOC_FL_INSERT_RANGE | FALLOC_FL_UNSHARE_RANGE)
723
724 STATIC long
725 xfs_file_fallocate(
726         struct file             *file,
727         int                     mode,
728         loff_t                  offset,
729         loff_t                  len)
730 {
731         struct inode            *inode = file_inode(file);
732         struct xfs_inode        *ip = XFS_I(inode);
733         long                    error;
734         enum xfs_prealloc_flags flags = 0;
735         uint                    iolock = XFS_IOLOCK_EXCL;
736         loff_t                  new_size = 0;
737         bool                    do_file_insert = 0;
738
739         if (!S_ISREG(inode->i_mode))
740                 return -EINVAL;
741         if (mode & ~XFS_FALLOC_FL_SUPPORTED)
742                 return -EOPNOTSUPP;
743
744         xfs_ilock(ip, iolock);
745         error = xfs_break_layouts(inode, &iolock);
746         if (error)
747                 goto out_unlock;
748
749         xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
750         iolock |= XFS_MMAPLOCK_EXCL;
751
752         if (mode & FALLOC_FL_PUNCH_HOLE) {
753                 error = xfs_free_file_space(ip, offset, len);
754                 if (error)
755                         goto out_unlock;
756         } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
757                 unsigned int blksize_mask = i_blocksize(inode) - 1;
758
759                 if (offset & blksize_mask || len & blksize_mask) {
760                         error = -EINVAL;
761                         goto out_unlock;
762                 }
763
764                 /*
765                  * There is no need to overlap collapse range with EOF,
766                  * in which case it is effectively a truncate operation
767                  */
768                 if (offset + len >= i_size_read(inode)) {
769                         error = -EINVAL;
770                         goto out_unlock;
771                 }
772
773                 new_size = i_size_read(inode) - len;
774
775                 error = xfs_collapse_file_space(ip, offset, len);
776                 if (error)
777                         goto out_unlock;
778         } else if (mode & FALLOC_FL_INSERT_RANGE) {
779                 unsigned int blksize_mask = i_blocksize(inode) - 1;
780
781                 new_size = i_size_read(inode) + len;
782                 if (offset & blksize_mask || len & blksize_mask) {
783                         error = -EINVAL;
784                         goto out_unlock;
785                 }
786
787                 /* check the new inode size does not wrap through zero */
788                 if (new_size > inode->i_sb->s_maxbytes) {
789                         error = -EFBIG;
790                         goto out_unlock;
791                 }
792
793                 /* Offset should be less than i_size */
794                 if (offset >= i_size_read(inode)) {
795                         error = -EINVAL;
796                         goto out_unlock;
797                 }
798                 do_file_insert = 1;
799         } else {
800                 flags |= XFS_PREALLOC_SET;
801
802                 if (!(mode & FALLOC_FL_KEEP_SIZE) &&
803                     offset + len > i_size_read(inode)) {
804                         new_size = offset + len;
805                         error = inode_newsize_ok(inode, new_size);
806                         if (error)
807                                 goto out_unlock;
808                 }
809
810                 if (mode & FALLOC_FL_ZERO_RANGE)
811                         error = xfs_zero_file_space(ip, offset, len);
812                 else {
813                         if (mode & FALLOC_FL_UNSHARE_RANGE) {
814                                 error = xfs_reflink_unshare(ip, offset, len);
815                                 if (error)
816                                         goto out_unlock;
817                         }
818                         error = xfs_alloc_file_space(ip, offset, len,
819                                                      XFS_BMAPI_PREALLOC);
820                 }
821                 if (error)
822                         goto out_unlock;
823         }
824
825         if (file->f_flags & O_DSYNC)
826                 flags |= XFS_PREALLOC_SYNC;
827
828         error = xfs_update_prealloc_flags(ip, flags);
829         if (error)
830                 goto out_unlock;
831
832         /* Change file size if needed */
833         if (new_size) {
834                 struct iattr iattr;
835
836                 iattr.ia_valid = ATTR_SIZE;
837                 iattr.ia_size = new_size;
838                 error = xfs_vn_setattr_size(file_dentry(file), &iattr);
839                 if (error)
840                         goto out_unlock;
841         }
842
843         /*
844          * Perform hole insertion now that the file size has been
845          * updated so that if we crash during the operation we don't
846          * leave shifted extents past EOF and hence losing access to
847          * the data that is contained within them.
848          */
849         if (do_file_insert)
850                 error = xfs_insert_file_space(ip, offset, len);
851
852 out_unlock:
853         xfs_iunlock(ip, iolock);
854         return error;
855 }
856
857 STATIC int
858 xfs_file_clone_range(
859         struct file     *file_in,
860         loff_t          pos_in,
861         struct file     *file_out,
862         loff_t          pos_out,
863         u64             len)
864 {
865         return xfs_reflink_remap_range(file_in, pos_in, file_out, pos_out,
866                                      len, false);
867 }
868
869 STATIC ssize_t
870 xfs_file_dedupe_range(
871         struct file     *src_file,
872         u64             loff,
873         u64             len,
874         struct file     *dst_file,
875         u64             dst_loff)
876 {
877         int             error;
878
879         error = xfs_reflink_remap_range(src_file, loff, dst_file, dst_loff,
880                                      len, true);
881         if (error)
882                 return error;
883         return len;
884 }
885
886 STATIC int
887 xfs_file_open(
888         struct inode    *inode,
889         struct file     *file)
890 {
891         if (!(file->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
892                 return -EFBIG;
893         if (XFS_FORCED_SHUTDOWN(XFS_M(inode->i_sb)))
894                 return -EIO;
895         return 0;
896 }
897
898 STATIC int
899 xfs_dir_open(
900         struct inode    *inode,
901         struct file     *file)
902 {
903         struct xfs_inode *ip = XFS_I(inode);
904         int             mode;
905         int             error;
906
907         error = xfs_file_open(inode, file);
908         if (error)
909                 return error;
910
911         /*
912          * If there are any blocks, read-ahead block 0 as we're almost
913          * certain to have the next operation be a read there.
914          */
915         mode = xfs_ilock_data_map_shared(ip);
916         if (ip->i_d.di_nextents > 0)
917                 error = xfs_dir3_data_readahead(ip, 0, -1);
918         xfs_iunlock(ip, mode);
919         return error;
920 }
921
922 STATIC int
923 xfs_file_release(
924         struct inode    *inode,
925         struct file     *filp)
926 {
927         return xfs_release(XFS_I(inode));
928 }
929
930 STATIC int
931 xfs_file_readdir(
932         struct file     *file,
933         struct dir_context *ctx)
934 {
935         struct inode    *inode = file_inode(file);
936         xfs_inode_t     *ip = XFS_I(inode);
937         size_t          bufsize;
938
939         /*
940          * The Linux API doesn't pass down the total size of the buffer
941          * we read into down to the filesystem.  With the filldir concept
942          * it's not needed for correct information, but the XFS dir2 leaf
943          * code wants an estimate of the buffer size to calculate it's
944          * readahead window and size the buffers used for mapping to
945          * physical blocks.
946          *
947          * Try to give it an estimate that's good enough, maybe at some
948          * point we can change the ->readdir prototype to include the
949          * buffer size.  For now we use the current glibc buffer size.
950          */
951         bufsize = (size_t)min_t(loff_t, 32768, ip->i_d.di_size);
952
953         return xfs_readdir(ip, ctx, bufsize);
954 }
955
956 /*
957  * This type is designed to indicate the type of offset we would like
958  * to search from page cache for xfs_seek_hole_data().
959  */
960 enum {
961         HOLE_OFF = 0,
962         DATA_OFF,
963 };
964
965 /*
966  * Lookup the desired type of offset from the given page.
967  *
968  * On success, return true and the offset argument will point to the
969  * start of the region that was found.  Otherwise this function will
970  * return false and keep the offset argument unchanged.
971  */
972 STATIC bool
973 xfs_lookup_buffer_offset(
974         struct page             *page,
975         loff_t                  *offset,
976         unsigned int            type)
977 {
978         loff_t                  lastoff = page_offset(page);
979         bool                    found = false;
980         struct buffer_head      *bh, *head;
981
982         bh = head = page_buffers(page);
983         do {
984                 /*
985                  * Unwritten extents that have data in the page
986                  * cache covering them can be identified by the
987                  * BH_Unwritten state flag.  Pages with multiple
988                  * buffers might have a mix of holes, data and
989                  * unwritten extents - any buffer with valid
990                  * data in it should have BH_Uptodate flag set
991                  * on it.
992                  */
993                 if (buffer_unwritten(bh) ||
994                     buffer_uptodate(bh)) {
995                         if (type == DATA_OFF)
996                                 found = true;
997                 } else {
998                         if (type == HOLE_OFF)
999                                 found = true;
1000                 }
1001
1002                 if (found) {
1003                         *offset = lastoff;
1004                         break;
1005                 }
1006                 lastoff += bh->b_size;
1007         } while ((bh = bh->b_this_page) != head);
1008
1009         return found;
1010 }
1011
1012 /*
1013  * This routine is called to find out and return a data or hole offset
1014  * from the page cache for unwritten extents according to the desired
1015  * type for xfs_seek_hole_data().
1016  *
1017  * The argument offset is used to tell where we start to search from the
1018  * page cache.  Map is used to figure out the end points of the range to
1019  * lookup pages.
1020  *
1021  * Return true if the desired type of offset was found, and the argument
1022  * offset is filled with that address.  Otherwise, return false and keep
1023  * offset unchanged.
1024  */
1025 STATIC bool
1026 xfs_find_get_desired_pgoff(
1027         struct inode            *inode,
1028         struct xfs_bmbt_irec    *map,
1029         unsigned int            type,
1030         loff_t                  *offset)
1031 {
1032         struct xfs_inode        *ip = XFS_I(inode);
1033         struct xfs_mount        *mp = ip->i_mount;
1034         struct pagevec          pvec;
1035         pgoff_t                 index;
1036         pgoff_t                 end;
1037         loff_t                  endoff;
1038         loff_t                  startoff = *offset;
1039         loff_t                  lastoff = startoff;
1040         bool                    found = false;
1041
1042         pagevec_init(&pvec, 0);
1043
1044         index = startoff >> PAGE_SHIFT;
1045         endoff = XFS_FSB_TO_B(mp, map->br_startoff + map->br_blockcount);
1046         end = (endoff - 1) >> PAGE_SHIFT;
1047         do {
1048                 int             want;
1049                 unsigned        nr_pages;
1050                 unsigned int    i;
1051
1052                 want = min_t(pgoff_t, end - index, PAGEVEC_SIZE - 1) + 1;
1053                 nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
1054                                           want);
1055                 if (nr_pages == 0)
1056                         break;
1057
1058                 for (i = 0; i < nr_pages; i++) {
1059                         struct page     *page = pvec.pages[i];
1060                         loff_t          b_offset;
1061
1062                         /*
1063                          * At this point, the page may be truncated or
1064                          * invalidated (changing page->mapping to NULL),
1065                          * or even swizzled back from swapper_space to tmpfs
1066                          * file mapping. However, page->index will not change
1067                          * because we have a reference on the page.
1068                          *
1069                          * If current page offset is beyond where we've ended,
1070                          * we've found a hole.
1071                          */
1072                         if (type == HOLE_OFF && lastoff < endoff &&
1073                             lastoff < page_offset(pvec.pages[i])) {
1074                                 found = true;
1075                                 *offset = lastoff;
1076                                 goto out;
1077                         }
1078                         /* Searching done if the page index is out of range. */
1079                         if (page->index > end)
1080                                 goto out;
1081
1082                         lock_page(page);
1083                         /*
1084                          * Page truncated or invalidated(page->mapping == NULL).
1085                          * We can freely skip it and proceed to check the next
1086                          * page.
1087                          */
1088                         if (unlikely(page->mapping != inode->i_mapping)) {
1089                                 unlock_page(page);
1090                                 continue;
1091                         }
1092
1093                         if (!page_has_buffers(page)) {
1094                                 unlock_page(page);
1095                                 continue;
1096                         }
1097
1098                         found = xfs_lookup_buffer_offset(page, &b_offset, type);
1099                         if (found) {
1100                                 /*
1101                                  * The found offset may be less than the start
1102                                  * point to search if this is the first time to
1103                                  * come here.
1104                                  */
1105                                 *offset = max_t(loff_t, startoff, b_offset);
1106                                 unlock_page(page);
1107                                 goto out;
1108                         }
1109
1110                         /*
1111                          * We either searching data but nothing was found, or
1112                          * searching hole but found a data buffer.  In either
1113                          * case, probably the next page contains the desired
1114                          * things, update the last offset to it so.
1115                          */
1116                         lastoff = page_offset(page) + PAGE_SIZE;
1117                         unlock_page(page);
1118                 }
1119
1120                 /*
1121                  * The number of returned pages less than our desired, search
1122                  * done.
1123                  */
1124                 if (nr_pages < want)
1125                         break;
1126
1127                 index = pvec.pages[i - 1]->index + 1;
1128                 pagevec_release(&pvec);
1129         } while (index <= end);
1130
1131         /* No page at lastoff and we are not done - we found a hole. */
1132         if (type == HOLE_OFF && lastoff < endoff) {
1133                 *offset = lastoff;
1134                 found = true;
1135         }
1136 out:
1137         pagevec_release(&pvec);
1138         return found;
1139 }
1140
1141 /*
1142  * caller must lock inode with xfs_ilock_data_map_shared,
1143  * can we craft an appropriate ASSERT?
1144  *
1145  * end is because the VFS-level lseek interface is defined such that any
1146  * offset past i_size shall return -ENXIO, but we use this for quota code
1147  * which does not maintain i_size, and we want to SEEK_DATA past i_size.
1148  */
1149 loff_t
1150 __xfs_seek_hole_data(
1151         struct inode            *inode,
1152         loff_t                  start,
1153         loff_t                  end,
1154         int                     whence)
1155 {
1156         struct xfs_inode        *ip = XFS_I(inode);
1157         struct xfs_mount        *mp = ip->i_mount;
1158         loff_t                  uninitialized_var(offset);
1159         xfs_fileoff_t           fsbno;
1160         xfs_filblks_t           lastbno;
1161         int                     error;
1162
1163         if (start >= end) {
1164                 error = -ENXIO;
1165                 goto out_error;
1166         }
1167
1168         /*
1169          * Try to read extents from the first block indicated
1170          * by fsbno to the end block of the file.
1171          */
1172         fsbno = XFS_B_TO_FSBT(mp, start);
1173         lastbno = XFS_B_TO_FSB(mp, end);
1174
1175         for (;;) {
1176                 struct xfs_bmbt_irec    map[2];
1177                 int                     nmap = 2;
1178                 unsigned int            i;
1179
1180                 error = xfs_bmapi_read(ip, fsbno, lastbno - fsbno, map, &nmap,
1181                                        XFS_BMAPI_ENTIRE);
1182                 if (error)
1183                         goto out_error;
1184
1185                 /* No extents at given offset, must be beyond EOF */
1186                 if (nmap == 0) {
1187                         error = -ENXIO;
1188                         goto out_error;
1189                 }
1190
1191                 for (i = 0; i < nmap; i++) {
1192                         offset = max_t(loff_t, start,
1193                                        XFS_FSB_TO_B(mp, map[i].br_startoff));
1194
1195                         /* Landed in the hole we wanted? */
1196                         if (whence == SEEK_HOLE &&
1197                             map[i].br_startblock == HOLESTARTBLOCK)
1198                                 goto out;
1199
1200                         /* Landed in the data extent we wanted? */
1201                         if (whence == SEEK_DATA &&
1202                             (map[i].br_startblock == DELAYSTARTBLOCK ||
1203                              (map[i].br_state == XFS_EXT_NORM &&
1204                               !isnullstartblock(map[i].br_startblock))))
1205                                 goto out;
1206
1207                         /*
1208                          * Landed in an unwritten extent, try to search
1209                          * for hole or data from page cache.
1210                          */
1211                         if (map[i].br_state == XFS_EXT_UNWRITTEN) {
1212                                 if (xfs_find_get_desired_pgoff(inode, &map[i],
1213                                       whence == SEEK_HOLE ? HOLE_OFF : DATA_OFF,
1214                                                         &offset))
1215                                         goto out;
1216                         }
1217                 }
1218
1219                 /*
1220                  * We only received one extent out of the two requested. This
1221                  * means we've hit EOF and didn't find what we are looking for.
1222                  */
1223                 if (nmap == 1) {
1224                         /*
1225                          * If we were looking for a hole, set offset to
1226                          * the end of the file (i.e., there is an implicit
1227                          * hole at the end of any file).
1228                          */
1229                         if (whence == SEEK_HOLE) {
1230                                 offset = end;
1231                                 break;
1232                         }
1233                         /*
1234                          * If we were looking for data, it's nowhere to be found
1235                          */
1236                         ASSERT(whence == SEEK_DATA);
1237                         error = -ENXIO;
1238                         goto out_error;
1239                 }
1240
1241                 ASSERT(i > 1);
1242
1243                 /*
1244                  * Nothing was found, proceed to the next round of search
1245                  * if the next reading offset is not at or beyond EOF.
1246                  */
1247                 fsbno = map[i - 1].br_startoff + map[i - 1].br_blockcount;
1248                 start = XFS_FSB_TO_B(mp, fsbno);
1249                 if (start >= end) {
1250                         if (whence == SEEK_HOLE) {
1251                                 offset = end;
1252                                 break;
1253                         }
1254                         ASSERT(whence == SEEK_DATA);
1255                         error = -ENXIO;
1256                         goto out_error;
1257                 }
1258         }
1259
1260 out:
1261         /*
1262          * If at this point we have found the hole we wanted, the returned
1263          * offset may be bigger than the file size as it may be aligned to
1264          * page boundary for unwritten extents.  We need to deal with this
1265          * situation in particular.
1266          */
1267         if (whence == SEEK_HOLE)
1268                 offset = min_t(loff_t, offset, end);
1269
1270         return offset;
1271
1272 out_error:
1273         return error;
1274 }
1275
1276 STATIC loff_t
1277 xfs_seek_hole_data(
1278         struct file             *file,
1279         loff_t                  start,
1280         int                     whence)
1281 {
1282         struct inode            *inode = file->f_mapping->host;
1283         struct xfs_inode        *ip = XFS_I(inode);
1284         struct xfs_mount        *mp = ip->i_mount;
1285         uint                    lock;
1286         loff_t                  offset, end;
1287         int                     error = 0;
1288
1289         if (XFS_FORCED_SHUTDOWN(mp))
1290                 return -EIO;
1291
1292         lock = xfs_ilock_data_map_shared(ip);
1293
1294         end = i_size_read(inode);
1295         offset = __xfs_seek_hole_data(inode, start, end, whence);
1296         if (offset < 0) {
1297                 error = offset;
1298                 goto out_unlock;
1299         }
1300
1301         offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
1302
1303 out_unlock:
1304         xfs_iunlock(ip, lock);
1305
1306         if (error)
1307                 return error;
1308         return offset;
1309 }
1310
1311 STATIC loff_t
1312 xfs_file_llseek(
1313         struct file     *file,
1314         loff_t          offset,
1315         int             whence)
1316 {
1317         switch (whence) {
1318         case SEEK_END:
1319         case SEEK_CUR:
1320         case SEEK_SET:
1321                 return generic_file_llseek(file, offset, whence);
1322         case SEEK_HOLE:
1323         case SEEK_DATA:
1324                 return xfs_seek_hole_data(file, offset, whence);
1325         default:
1326                 return -EINVAL;
1327         }
1328 }
1329
1330 /*
1331  * Locking for serialisation of IO during page faults. This results in a lock
1332  * ordering of:
1333  *
1334  * mmap_sem (MM)
1335  *   sb_start_pagefault(vfs, freeze)
1336  *     i_mmaplock (XFS - truncate serialisation)
1337  *       page_lock (MM)
1338  *         i_lock (XFS - extent map serialisation)
1339  */
1340
1341 /*
1342  * mmap()d file has taken write protection fault and is being made writable. We
1343  * can set the page state up correctly for a writable page, which means we can
1344  * do correct delalloc accounting (ENOSPC checking!) and unwritten extent
1345  * mapping.
1346  */
1347 STATIC int
1348 xfs_filemap_page_mkwrite(
1349         struct vm_fault         *vmf)
1350 {
1351         struct inode            *inode = file_inode(vmf->vma->vm_file);
1352         int                     ret;
1353
1354         trace_xfs_filemap_page_mkwrite(XFS_I(inode));
1355
1356         sb_start_pagefault(inode->i_sb);
1357         file_update_time(vmf->vma->vm_file);
1358         xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
1359
1360         if (IS_DAX(inode)) {
1361                 ret = dax_iomap_fault(vmf, PE_SIZE_PTE, &xfs_iomap_ops);
1362         } else {
1363                 ret = iomap_page_mkwrite(vmf, &xfs_iomap_ops);
1364                 ret = block_page_mkwrite_return(ret);
1365         }
1366
1367         xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
1368         sb_end_pagefault(inode->i_sb);
1369
1370         return ret;
1371 }
1372
1373 STATIC int
1374 xfs_filemap_fault(
1375         struct vm_fault         *vmf)
1376 {
1377         struct inode            *inode = file_inode(vmf->vma->vm_file);
1378         int                     ret;
1379
1380         trace_xfs_filemap_fault(XFS_I(inode));
1381
1382         /* DAX can shortcut the normal fault path on write faults! */
1383         if ((vmf->flags & FAULT_FLAG_WRITE) && IS_DAX(inode))
1384                 return xfs_filemap_page_mkwrite(vmf);
1385
1386         xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
1387         if (IS_DAX(inode))
1388                 ret = dax_iomap_fault(vmf, PE_SIZE_PTE, &xfs_iomap_ops);
1389         else
1390                 ret = filemap_fault(vmf);
1391         xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
1392
1393         return ret;
1394 }
1395
1396 /*
1397  * Similar to xfs_filemap_fault(), the DAX fault path can call into here on
1398  * both read and write faults. Hence we need to handle both cases. There is no
1399  * ->huge_mkwrite callout for huge pages, so we have a single function here to
1400  * handle both cases here. @flags carries the information on the type of fault
1401  * occuring.
1402  */
1403 STATIC int
1404 xfs_filemap_huge_fault(
1405         struct vm_fault         *vmf,
1406         enum page_entry_size    pe_size)
1407 {
1408         struct inode            *inode = file_inode(vmf->vma->vm_file);
1409         struct xfs_inode        *ip = XFS_I(inode);
1410         int                     ret;
1411
1412         if (!IS_DAX(inode))
1413                 return VM_FAULT_FALLBACK;
1414
1415         trace_xfs_filemap_huge_fault(ip);
1416
1417         if (vmf->flags & FAULT_FLAG_WRITE) {
1418                 sb_start_pagefault(inode->i_sb);
1419                 file_update_time(vmf->vma->vm_file);
1420         }
1421
1422         xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
1423         ret = dax_iomap_fault(vmf, pe_size, &xfs_iomap_ops);
1424         xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
1425
1426         if (vmf->flags & FAULT_FLAG_WRITE)
1427                 sb_end_pagefault(inode->i_sb);
1428
1429         return ret;
1430 }
1431
1432 /*
1433  * pfn_mkwrite was originally inteneded to ensure we capture time stamp
1434  * updates on write faults. In reality, it's need to serialise against
1435  * truncate similar to page_mkwrite. Hence we cycle the XFS_MMAPLOCK_SHARED
1436  * to ensure we serialise the fault barrier in place.
1437  */
1438 static int
1439 xfs_filemap_pfn_mkwrite(
1440         struct vm_fault         *vmf)
1441 {
1442
1443         struct inode            *inode = file_inode(vmf->vma->vm_file);
1444         struct xfs_inode        *ip = XFS_I(inode);
1445         int                     ret = VM_FAULT_NOPAGE;
1446         loff_t                  size;
1447
1448         trace_xfs_filemap_pfn_mkwrite(ip);
1449
1450         sb_start_pagefault(inode->i_sb);
1451         file_update_time(vmf->vma->vm_file);
1452
1453         /* check if the faulting page hasn't raced with truncate */
1454         xfs_ilock(ip, XFS_MMAPLOCK_SHARED);
1455         size = (i_size_read(inode) + PAGE_SIZE - 1) >> PAGE_SHIFT;
1456         if (vmf->pgoff >= size)
1457                 ret = VM_FAULT_SIGBUS;
1458         else if (IS_DAX(inode))
1459                 ret = dax_pfn_mkwrite(vmf);
1460         xfs_iunlock(ip, XFS_MMAPLOCK_SHARED);
1461         sb_end_pagefault(inode->i_sb);
1462         return ret;
1463
1464 }
1465
1466 static const struct vm_operations_struct xfs_file_vm_ops = {
1467         .fault          = xfs_filemap_fault,
1468         .huge_fault     = xfs_filemap_huge_fault,
1469         .map_pages      = filemap_map_pages,
1470         .page_mkwrite   = xfs_filemap_page_mkwrite,
1471         .pfn_mkwrite    = xfs_filemap_pfn_mkwrite,
1472 };
1473
1474 STATIC int
1475 xfs_file_mmap(
1476         struct file     *filp,
1477         struct vm_area_struct *vma)
1478 {
1479         file_accessed(filp);
1480         vma->vm_ops = &xfs_file_vm_ops;
1481         if (IS_DAX(file_inode(filp)))
1482                 vma->vm_flags |= VM_MIXEDMAP | VM_HUGEPAGE;
1483         return 0;
1484 }
1485
1486 const struct file_operations xfs_file_operations = {
1487         .llseek         = xfs_file_llseek,
1488         .read_iter      = xfs_file_read_iter,
1489         .write_iter     = xfs_file_write_iter,
1490         .splice_read    = generic_file_splice_read,
1491         .splice_write   = iter_file_splice_write,
1492         .unlocked_ioctl = xfs_file_ioctl,
1493 #ifdef CONFIG_COMPAT
1494         .compat_ioctl   = xfs_file_compat_ioctl,
1495 #endif
1496         .mmap           = xfs_file_mmap,
1497         .open           = xfs_file_open,
1498         .release        = xfs_file_release,
1499         .fsync          = xfs_file_fsync,
1500         .get_unmapped_area = thp_get_unmapped_area,
1501         .fallocate      = xfs_file_fallocate,
1502         .clone_file_range = xfs_file_clone_range,
1503         .dedupe_file_range = xfs_file_dedupe_range,
1504 };
1505
1506 const struct file_operations xfs_dir_file_operations = {
1507         .open           = xfs_dir_open,
1508         .read           = generic_read_dir,
1509         .iterate_shared = xfs_file_readdir,
1510         .llseek         = generic_file_llseek,
1511         .unlocked_ioctl = xfs_file_ioctl,
1512 #ifdef CONFIG_COMPAT
1513         .compat_ioctl   = xfs_file_compat_ioctl,
1514 #endif
1515         .fsync          = xfs_dir_fsync,
1516 };