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