1
2
3
4
5
6#include "xfs.h"
7#include "xfs_fs.h"
8#include "xfs_shared.h"
9#include "xfs_format.h"
10#include "xfs_log_format.h"
11#include "xfs_trans_resv.h"
12#include "xfs_mount.h"
13#include "xfs_inode.h"
14#include "xfs_trans.h"
15#include "xfs_inode_item.h"
16#include "xfs_bmap.h"
17#include "xfs_bmap_util.h"
18#include "xfs_dir2.h"
19#include "xfs_dir2_priv.h"
20#include "xfs_ioctl.h"
21#include "xfs_trace.h"
22#include "xfs_log.h"
23#include "xfs_icache.h"
24#include "xfs_pnfs.h"
25#include "xfs_iomap.h"
26#include "xfs_reflink.h"
27
28#include <linux/falloc.h>
29#include <linux/backing-dev.h>
30#include <linux/mman.h>
31#include <linux/fadvise.h>
32
33static const struct vm_operations_struct xfs_file_vm_ops;
34
35int
36xfs_update_prealloc_flags(
37 struct xfs_inode *ip,
38 enum xfs_prealloc_flags flags)
39{
40 struct xfs_trans *tp;
41 int error;
42
43 error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_writeid,
44 0, 0, 0, &tp);
45 if (error)
46 return error;
47
48 xfs_ilock(ip, XFS_ILOCK_EXCL);
49 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
50
51 if (!(flags & XFS_PREALLOC_INVISIBLE)) {
52 VFS_I(ip)->i_mode &= ~S_ISUID;
53 if (VFS_I(ip)->i_mode & S_IXGRP)
54 VFS_I(ip)->i_mode &= ~S_ISGID;
55 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
56 }
57
58 if (flags & XFS_PREALLOC_SET)
59 ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
60 if (flags & XFS_PREALLOC_CLEAR)
61 ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
62
63 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
64 if (flags & XFS_PREALLOC_SYNC)
65 xfs_trans_set_sync(tp);
66 return xfs_trans_commit(tp);
67}
68
69
70
71
72
73
74
75STATIC int
76xfs_dir_fsync(
77 struct file *file,
78 loff_t start,
79 loff_t end,
80 int datasync)
81{
82 struct xfs_inode *ip = XFS_I(file->f_mapping->host);
83 struct xfs_mount *mp = ip->i_mount;
84 xfs_lsn_t lsn = 0;
85
86 trace_xfs_dir_fsync(ip);
87
88 xfs_ilock(ip, XFS_ILOCK_SHARED);
89 if (xfs_ipincount(ip))
90 lsn = ip->i_itemp->ili_last_lsn;
91 xfs_iunlock(ip, XFS_ILOCK_SHARED);
92
93 if (!lsn)
94 return 0;
95 return xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
96}
97
98STATIC int
99xfs_file_fsync(
100 struct file *file,
101 loff_t start,
102 loff_t end,
103 int datasync)
104{
105 struct inode *inode = file->f_mapping->host;
106 struct xfs_inode *ip = XFS_I(inode);
107 struct xfs_mount *mp = ip->i_mount;
108 int error = 0;
109 int log_flushed = 0;
110 xfs_lsn_t lsn = 0;
111
112 trace_xfs_file_fsync(ip);
113
114 error = file_write_and_wait_range(file, start, end);
115 if (error)
116 return error;
117
118 if (XFS_FORCED_SHUTDOWN(mp))
119 return -EIO;
120
121 xfs_iflags_clear(ip, XFS_ITRUNCATED);
122
123
124
125
126
127
128
129 if (XFS_IS_REALTIME_INODE(ip))
130 xfs_blkdev_issue_flush(mp->m_rtdev_targp);
131 else if (mp->m_logdev_targp != mp->m_ddev_targp)
132 xfs_blkdev_issue_flush(mp->m_ddev_targp);
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147 xfs_ilock(ip, XFS_ILOCK_SHARED);
148 if (xfs_ipincount(ip)) {
149 if (!datasync ||
150 (ip->i_itemp->ili_fsync_fields & ~XFS_ILOG_TIMESTAMP))
151 lsn = ip->i_itemp->ili_last_lsn;
152 }
153
154 if (lsn) {
155 error = xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, &log_flushed);
156 ip->i_itemp->ili_fsync_fields = 0;
157 }
158 xfs_iunlock(ip, XFS_ILOCK_SHARED);
159
160
161
162
163
164
165
166
167 if (!log_flushed && !XFS_IS_REALTIME_INODE(ip) &&
168 mp->m_logdev_targp == mp->m_ddev_targp)
169 xfs_blkdev_issue_flush(mp->m_ddev_targp);
170
171 return error;
172}
173
174STATIC ssize_t
175xfs_file_dio_aio_read(
176 struct kiocb *iocb,
177 struct iov_iter *to)
178{
179 struct xfs_inode *ip = XFS_I(file_inode(iocb->ki_filp));
180 size_t count = iov_iter_count(to);
181 ssize_t ret;
182
183 trace_xfs_file_direct_read(ip, count, iocb->ki_pos);
184
185 if (!count)
186 return 0;
187
188 file_accessed(iocb->ki_filp);
189
190 xfs_ilock(ip, XFS_IOLOCK_SHARED);
191 ret = iomap_dio_rw(iocb, to, &xfs_read_iomap_ops, NULL,
192 is_sync_kiocb(iocb));
193 xfs_iunlock(ip, XFS_IOLOCK_SHARED);
194
195 return ret;
196}
197
198static noinline ssize_t
199xfs_file_dax_read(
200 struct kiocb *iocb,
201 struct iov_iter *to)
202{
203 struct xfs_inode *ip = XFS_I(iocb->ki_filp->f_mapping->host);
204 size_t count = iov_iter_count(to);
205 ssize_t ret = 0;
206
207 trace_xfs_file_dax_read(ip, count, iocb->ki_pos);
208
209 if (!count)
210 return 0;
211
212 if (iocb->ki_flags & IOCB_NOWAIT) {
213 if (!xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED))
214 return -EAGAIN;
215 } else {
216 xfs_ilock(ip, XFS_IOLOCK_SHARED);
217 }
218
219 ret = dax_iomap_rw(iocb, to, &xfs_read_iomap_ops);
220 xfs_iunlock(ip, XFS_IOLOCK_SHARED);
221
222 file_accessed(iocb->ki_filp);
223 return ret;
224}
225
226STATIC ssize_t
227xfs_file_buffered_aio_read(
228 struct kiocb *iocb,
229 struct iov_iter *to)
230{
231 struct xfs_inode *ip = XFS_I(file_inode(iocb->ki_filp));
232 ssize_t ret;
233
234 trace_xfs_file_buffered_read(ip, iov_iter_count(to), iocb->ki_pos);
235
236 if (iocb->ki_flags & IOCB_NOWAIT) {
237 if (!xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED))
238 return -EAGAIN;
239 } else {
240 xfs_ilock(ip, XFS_IOLOCK_SHARED);
241 }
242 ret = generic_file_read_iter(iocb, to);
243 xfs_iunlock(ip, XFS_IOLOCK_SHARED);
244
245 return ret;
246}
247
248STATIC ssize_t
249xfs_file_read_iter(
250 struct kiocb *iocb,
251 struct iov_iter *to)
252{
253 struct inode *inode = file_inode(iocb->ki_filp);
254 struct xfs_mount *mp = XFS_I(inode)->i_mount;
255 ssize_t ret = 0;
256
257 XFS_STATS_INC(mp, xs_read_calls);
258
259 if (XFS_FORCED_SHUTDOWN(mp))
260 return -EIO;
261
262 if (IS_DAX(inode))
263 ret = xfs_file_dax_read(iocb, to);
264 else if (iocb->ki_flags & IOCB_DIRECT)
265 ret = xfs_file_dio_aio_read(iocb, to);
266 else
267 ret = xfs_file_buffered_aio_read(iocb, to);
268
269 if (ret > 0)
270 XFS_STATS_ADD(mp, xs_read_bytes, ret);
271 return ret;
272}
273
274
275
276
277
278
279
280
281STATIC ssize_t
282xfs_file_aio_write_checks(
283 struct kiocb *iocb,
284 struct iov_iter *from,
285 int *iolock)
286{
287 struct file *file = iocb->ki_filp;
288 struct inode *inode = file->f_mapping->host;
289 struct xfs_inode *ip = XFS_I(inode);
290 ssize_t error = 0;
291 size_t count = iov_iter_count(from);
292 bool drained_dio = false;
293 loff_t isize;
294
295restart:
296 error = generic_write_checks(iocb, from);
297 if (error <= 0)
298 return error;
299
300 error = xfs_break_layouts(inode, iolock, BREAK_WRITE);
301 if (error)
302 return error;
303
304
305
306
307
308 if (*iolock == XFS_IOLOCK_SHARED && !IS_NOSEC(inode)) {
309 xfs_iunlock(ip, *iolock);
310 *iolock = XFS_IOLOCK_EXCL;
311 xfs_ilock(ip, *iolock);
312 goto restart;
313 }
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329 spin_lock(&ip->i_flags_lock);
330 isize = i_size_read(inode);
331 if (iocb->ki_pos > isize) {
332 spin_unlock(&ip->i_flags_lock);
333 if (!drained_dio) {
334 if (*iolock == XFS_IOLOCK_SHARED) {
335 xfs_iunlock(ip, *iolock);
336 *iolock = XFS_IOLOCK_EXCL;
337 xfs_ilock(ip, *iolock);
338 iov_iter_reexpand(from, count);
339 }
340
341
342
343
344
345
346
347
348 inode_dio_wait(inode);
349 drained_dio = true;
350 goto restart;
351 }
352
353 trace_xfs_zero_eof(ip, isize, iocb->ki_pos - isize);
354 error = iomap_zero_range(inode, isize, iocb->ki_pos - isize,
355 NULL, &xfs_buffered_write_iomap_ops);
356 if (error)
357 return error;
358 } else
359 spin_unlock(&ip->i_flags_lock);
360
361
362
363
364
365
366
367 return file_modified(file);
368}
369
370static int
371xfs_dio_write_end_io(
372 struct kiocb *iocb,
373 ssize_t size,
374 int error,
375 unsigned flags)
376{
377 struct inode *inode = file_inode(iocb->ki_filp);
378 struct xfs_inode *ip = XFS_I(inode);
379 loff_t offset = iocb->ki_pos;
380 unsigned int nofs_flag;
381
382 trace_xfs_end_io_direct_write(ip, offset, size);
383
384 if (XFS_FORCED_SHUTDOWN(ip->i_mount))
385 return -EIO;
386
387 if (error)
388 return error;
389 if (!size)
390 return 0;
391
392
393
394
395
396 XFS_STATS_ADD(ip->i_mount, xs_write_bytes, size);
397
398
399
400
401
402
403 nofs_flag = memalloc_nofs_save();
404
405 if (flags & IOMAP_DIO_COW) {
406 error = xfs_reflink_end_cow(ip, offset, size);
407 if (error)
408 goto out;
409 }
410
411
412
413
414
415
416
417 if (flags & IOMAP_DIO_UNWRITTEN) {
418 error = xfs_iomap_write_unwritten(ip, offset, size, true);
419 goto out;
420 }
421
422
423
424
425
426
427
428
429
430
431
432
433 spin_lock(&ip->i_flags_lock);
434 if (offset + size > i_size_read(inode)) {
435 i_size_write(inode, offset + size);
436 spin_unlock(&ip->i_flags_lock);
437 error = xfs_setfilesize(ip, offset, size);
438 } else {
439 spin_unlock(&ip->i_flags_lock);
440 }
441
442out:
443 memalloc_nofs_restore(nofs_flag);
444 return error;
445}
446
447static const struct iomap_dio_ops xfs_dio_write_ops = {
448 .end_io = xfs_dio_write_end_io,
449};
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476STATIC ssize_t
477xfs_file_dio_aio_write(
478 struct kiocb *iocb,
479 struct iov_iter *from)
480{
481 struct file *file = iocb->ki_filp;
482 struct address_space *mapping = file->f_mapping;
483 struct inode *inode = mapping->host;
484 struct xfs_inode *ip = XFS_I(inode);
485 struct xfs_mount *mp = ip->i_mount;
486 ssize_t ret = 0;
487 int unaligned_io = 0;
488 int iolock;
489 size_t count = iov_iter_count(from);
490 struct xfs_buftarg *target = xfs_inode_buftarg(ip);
491
492
493 if ((iocb->ki_pos | count) & target->bt_logical_sectormask)
494 return -EINVAL;
495
496
497
498
499
500
501
502
503 if ((iocb->ki_pos & mp->m_blockmask) ||
504 ((iocb->ki_pos + count) & mp->m_blockmask)) {
505 unaligned_io = 1;
506
507
508
509
510
511 if (xfs_is_cow_inode(ip)) {
512 trace_xfs_reflink_bounce_dio_write(ip, iocb->ki_pos, count);
513 return -EREMCHG;
514 }
515 iolock = XFS_IOLOCK_EXCL;
516 } else {
517 iolock = XFS_IOLOCK_SHARED;
518 }
519
520 if (iocb->ki_flags & IOCB_NOWAIT) {
521
522 if (unaligned_io)
523 return -EAGAIN;
524 if (!xfs_ilock_nowait(ip, iolock))
525 return -EAGAIN;
526 } else {
527 xfs_ilock(ip, iolock);
528 }
529
530 ret = xfs_file_aio_write_checks(iocb, from, &iolock);
531 if (ret)
532 goto out;
533 count = iov_iter_count(from);
534
535
536
537
538
539
540
541
542 if (unaligned_io) {
543 inode_dio_wait(inode);
544 } else if (iolock == XFS_IOLOCK_EXCL) {
545 xfs_ilock_demote(ip, XFS_IOLOCK_EXCL);
546 iolock = XFS_IOLOCK_SHARED;
547 }
548
549 trace_xfs_file_direct_write(ip, count, iocb->ki_pos);
550
551
552
553
554 ret = iomap_dio_rw(iocb, from, &xfs_direct_write_iomap_ops,
555 &xfs_dio_write_ops,
556 is_sync_kiocb(iocb) || unaligned_io);
557out:
558 xfs_iunlock(ip, iolock);
559
560
561
562
563
564 ASSERT(ret < 0 || ret == count);
565 return ret;
566}
567
568static noinline ssize_t
569xfs_file_dax_write(
570 struct kiocb *iocb,
571 struct iov_iter *from)
572{
573 struct inode *inode = iocb->ki_filp->f_mapping->host;
574 struct xfs_inode *ip = XFS_I(inode);
575 int iolock = XFS_IOLOCK_EXCL;
576 ssize_t ret, error = 0;
577 size_t count;
578 loff_t pos;
579
580 if (iocb->ki_flags & IOCB_NOWAIT) {
581 if (!xfs_ilock_nowait(ip, iolock))
582 return -EAGAIN;
583 } else {
584 xfs_ilock(ip, iolock);
585 }
586
587 ret = xfs_file_aio_write_checks(iocb, from, &iolock);
588 if (ret)
589 goto out;
590
591 pos = iocb->ki_pos;
592 count = iov_iter_count(from);
593
594 trace_xfs_file_dax_write(ip, count, pos);
595 ret = dax_iomap_rw(iocb, from, &xfs_direct_write_iomap_ops);
596 if (ret > 0 && iocb->ki_pos > i_size_read(inode)) {
597 i_size_write(inode, iocb->ki_pos);
598 error = xfs_setfilesize(ip, pos, ret);
599 }
600out:
601 xfs_iunlock(ip, iolock);
602 if (error)
603 return error;
604
605 if (ret > 0) {
606 XFS_STATS_ADD(ip->i_mount, xs_write_bytes, ret);
607
608
609 ret = generic_write_sync(iocb, ret);
610 }
611 return ret;
612}
613
614STATIC ssize_t
615xfs_file_buffered_aio_write(
616 struct kiocb *iocb,
617 struct iov_iter *from)
618{
619 struct file *file = iocb->ki_filp;
620 struct address_space *mapping = file->f_mapping;
621 struct inode *inode = mapping->host;
622 struct xfs_inode *ip = XFS_I(inode);
623 ssize_t ret;
624 int enospc = 0;
625 int iolock;
626
627 if (iocb->ki_flags & IOCB_NOWAIT)
628 return -EOPNOTSUPP;
629
630write_retry:
631 iolock = XFS_IOLOCK_EXCL;
632 xfs_ilock(ip, iolock);
633
634 ret = xfs_file_aio_write_checks(iocb, from, &iolock);
635 if (ret)
636 goto out;
637
638
639 current->backing_dev_info = inode_to_bdi(inode);
640
641 trace_xfs_file_buffered_write(ip, iov_iter_count(from), iocb->ki_pos);
642 ret = iomap_file_buffered_write(iocb, from,
643 &xfs_buffered_write_iomap_ops);
644 if (likely(ret >= 0))
645 iocb->ki_pos += ret;
646
647
648
649
650
651
652
653
654
655
656 if (ret == -EDQUOT && !enospc) {
657 xfs_iunlock(ip, iolock);
658 enospc = xfs_inode_free_quota_eofblocks(ip);
659 if (enospc)
660 goto write_retry;
661 enospc = xfs_inode_free_quota_cowblocks(ip);
662 if (enospc)
663 goto write_retry;
664 iolock = 0;
665 } else if (ret == -ENOSPC && !enospc) {
666 struct xfs_eofblocks eofb = {0};
667
668 enospc = 1;
669 xfs_flush_inodes(ip->i_mount);
670
671 xfs_iunlock(ip, iolock);
672 eofb.eof_flags = XFS_EOF_FLAGS_SYNC;
673 xfs_icache_free_eofblocks(ip->i_mount, &eofb);
674 xfs_icache_free_cowblocks(ip->i_mount, &eofb);
675 goto write_retry;
676 }
677
678 current->backing_dev_info = NULL;
679out:
680 if (iolock)
681 xfs_iunlock(ip, iolock);
682
683 if (ret > 0) {
684 XFS_STATS_ADD(ip->i_mount, xs_write_bytes, ret);
685
686 ret = generic_write_sync(iocb, ret);
687 }
688 return ret;
689}
690
691STATIC ssize_t
692xfs_file_write_iter(
693 struct kiocb *iocb,
694 struct iov_iter *from)
695{
696 struct file *file = iocb->ki_filp;
697 struct address_space *mapping = file->f_mapping;
698 struct inode *inode = mapping->host;
699 struct xfs_inode *ip = XFS_I(inode);
700 ssize_t ret;
701 size_t ocount = iov_iter_count(from);
702
703 XFS_STATS_INC(ip->i_mount, xs_write_calls);
704
705 if (ocount == 0)
706 return 0;
707
708 if (XFS_FORCED_SHUTDOWN(ip->i_mount))
709 return -EIO;
710
711 if (IS_DAX(inode))
712 return xfs_file_dax_write(iocb, from);
713
714 if (iocb->ki_flags & IOCB_DIRECT) {
715
716
717
718
719
720
721 ret = xfs_file_dio_aio_write(iocb, from);
722 if (ret != -EREMCHG)
723 return ret;
724 }
725
726 return xfs_file_buffered_aio_write(iocb, from);
727}
728
729static void
730xfs_wait_dax_page(
731 struct inode *inode)
732{
733 struct xfs_inode *ip = XFS_I(inode);
734
735 xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
736 schedule();
737 xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
738}
739
740static int
741xfs_break_dax_layouts(
742 struct inode *inode,
743 bool *retry)
744{
745 struct page *page;
746
747 ASSERT(xfs_isilocked(XFS_I(inode), XFS_MMAPLOCK_EXCL));
748
749 page = dax_layout_busy_page(inode->i_mapping);
750 if (!page)
751 return 0;
752
753 *retry = true;
754 return ___wait_var_event(&page->_refcount,
755 atomic_read(&page->_refcount) == 1, TASK_INTERRUPTIBLE,
756 0, 0, xfs_wait_dax_page(inode));
757}
758
759int
760xfs_break_layouts(
761 struct inode *inode,
762 uint *iolock,
763 enum layout_break_reason reason)
764{
765 bool retry;
766 int error;
767
768 ASSERT(xfs_isilocked(XFS_I(inode), XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL));
769
770 do {
771 retry = false;
772 switch (reason) {
773 case BREAK_UNMAP:
774 error = xfs_break_dax_layouts(inode, &retry);
775 if (error || retry)
776 break;
777
778 case BREAK_WRITE:
779 error = xfs_break_leased_layouts(inode, iolock, &retry);
780 break;
781 default:
782 WARN_ON_ONCE(1);
783 error = -EINVAL;
784 }
785 } while (error == 0 && retry);
786
787 return error;
788}
789
790#define XFS_FALLOC_FL_SUPPORTED \
791 (FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE | \
792 FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE | \
793 FALLOC_FL_INSERT_RANGE | FALLOC_FL_UNSHARE_RANGE)
794
795STATIC long
796xfs_file_fallocate(
797 struct file *file,
798 int mode,
799 loff_t offset,
800 loff_t len)
801{
802 struct inode *inode = file_inode(file);
803 struct xfs_inode *ip = XFS_I(inode);
804 long error;
805 enum xfs_prealloc_flags flags = 0;
806 uint iolock = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
807 loff_t new_size = 0;
808 bool do_file_insert = false;
809
810 if (!S_ISREG(inode->i_mode))
811 return -EINVAL;
812 if (mode & ~XFS_FALLOC_FL_SUPPORTED)
813 return -EOPNOTSUPP;
814
815 xfs_ilock(ip, iolock);
816 error = xfs_break_layouts(inode, &iolock, BREAK_UNMAP);
817 if (error)
818 goto out_unlock;
819
820
821
822
823
824
825
826
827 inode_dio_wait(inode);
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843 if (mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_ZERO_RANGE |
844 FALLOC_FL_COLLAPSE_RANGE)) {
845 error = xfs_flush_unmap_range(ip, offset, len);
846 if (error)
847 goto out_unlock;
848 }
849
850 if (mode & FALLOC_FL_PUNCH_HOLE) {
851 error = xfs_free_file_space(ip, offset, len);
852 if (error)
853 goto out_unlock;
854 } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
855 unsigned int blksize_mask = i_blocksize(inode) - 1;
856
857 if (offset & blksize_mask || len & blksize_mask) {
858 error = -EINVAL;
859 goto out_unlock;
860 }
861
862
863
864
865
866 if (offset + len >= i_size_read(inode)) {
867 error = -EINVAL;
868 goto out_unlock;
869 }
870
871 new_size = i_size_read(inode) - len;
872
873 error = xfs_collapse_file_space(ip, offset, len);
874 if (error)
875 goto out_unlock;
876 } else if (mode & FALLOC_FL_INSERT_RANGE) {
877 unsigned int blksize_mask = i_blocksize(inode) - 1;
878 loff_t isize = i_size_read(inode);
879
880 if (offset & blksize_mask || len & blksize_mask) {
881 error = -EINVAL;
882 goto out_unlock;
883 }
884
885
886
887
888
889 if (inode->i_sb->s_maxbytes - isize < len) {
890 error = -EFBIG;
891 goto out_unlock;
892 }
893 new_size = isize + len;
894
895
896 if (offset >= isize) {
897 error = -EINVAL;
898 goto out_unlock;
899 }
900 do_file_insert = true;
901 } else {
902 flags |= XFS_PREALLOC_SET;
903
904 if (!(mode & FALLOC_FL_KEEP_SIZE) &&
905 offset + len > i_size_read(inode)) {
906 new_size = offset + len;
907 error = inode_newsize_ok(inode, new_size);
908 if (error)
909 goto out_unlock;
910 }
911
912 if (mode & FALLOC_FL_ZERO_RANGE) {
913
914
915
916
917
918
919
920
921
922 unsigned int blksize = i_blocksize(inode);
923
924 trace_xfs_zero_file_space(ip);
925
926 error = xfs_free_file_space(ip, offset, len);
927 if (error)
928 goto out_unlock;
929
930 len = round_up(offset + len, blksize) -
931 round_down(offset, blksize);
932 offset = round_down(offset, blksize);
933 } else if (mode & FALLOC_FL_UNSHARE_RANGE) {
934 error = xfs_reflink_unshare(ip, offset, len);
935 if (error)
936 goto out_unlock;
937 } else {
938
939
940
941
942 if (xfs_is_always_cow_inode(ip)) {
943 error = -EOPNOTSUPP;
944 goto out_unlock;
945 }
946 }
947
948 if (!xfs_is_always_cow_inode(ip)) {
949 error = xfs_alloc_file_space(ip, offset, len,
950 XFS_BMAPI_PREALLOC);
951 if (error)
952 goto out_unlock;
953 }
954 }
955
956 if (file->f_flags & O_DSYNC)
957 flags |= XFS_PREALLOC_SYNC;
958
959 error = xfs_update_prealloc_flags(ip, flags);
960 if (error)
961 goto out_unlock;
962
963
964 if (new_size) {
965 struct iattr iattr;
966
967 iattr.ia_valid = ATTR_SIZE;
968 iattr.ia_size = new_size;
969 error = xfs_vn_setattr_size(file_dentry(file), &iattr);
970 if (error)
971 goto out_unlock;
972 }
973
974
975
976
977
978
979
980 if (do_file_insert)
981 error = xfs_insert_file_space(ip, offset, len);
982
983out_unlock:
984 xfs_iunlock(ip, iolock);
985 return error;
986}
987
988STATIC int
989xfs_file_fadvise(
990 struct file *file,
991 loff_t start,
992 loff_t end,
993 int advice)
994{
995 struct xfs_inode *ip = XFS_I(file_inode(file));
996 int ret;
997 int lockflags = 0;
998
999
1000
1001
1002
1003 if (advice == POSIX_FADV_WILLNEED) {
1004 lockflags = XFS_IOLOCK_SHARED;
1005 xfs_ilock(ip, lockflags);
1006 }
1007 ret = generic_fadvise(file, start, end, advice);
1008 if (lockflags)
1009 xfs_iunlock(ip, lockflags);
1010 return ret;
1011}
1012
1013STATIC loff_t
1014xfs_file_remap_range(
1015 struct file *file_in,
1016 loff_t pos_in,
1017 struct file *file_out,
1018 loff_t pos_out,
1019 loff_t len,
1020 unsigned int remap_flags)
1021{
1022 struct inode *inode_in = file_inode(file_in);
1023 struct xfs_inode *src = XFS_I(inode_in);
1024 struct inode *inode_out = file_inode(file_out);
1025 struct xfs_inode *dest = XFS_I(inode_out);
1026 struct xfs_mount *mp = src->i_mount;
1027 loff_t remapped = 0;
1028 xfs_extlen_t cowextsize;
1029 int ret;
1030
1031 if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1032 return -EINVAL;
1033
1034 if (!xfs_sb_version_hasreflink(&mp->m_sb))
1035 return -EOPNOTSUPP;
1036
1037 if (XFS_FORCED_SHUTDOWN(mp))
1038 return -EIO;
1039
1040
1041 ret = xfs_reflink_remap_prep(file_in, pos_in, file_out, pos_out,
1042 &len, remap_flags);
1043 if (ret < 0 || len == 0)
1044 return ret;
1045
1046 trace_xfs_reflink_remap_range(src, pos_in, len, dest, pos_out);
1047
1048 ret = xfs_reflink_remap_blocks(src, pos_in, dest, pos_out, len,
1049 &remapped);
1050 if (ret)
1051 goto out_unlock;
1052
1053
1054
1055
1056
1057
1058 cowextsize = 0;
1059 if (pos_in == 0 && len == i_size_read(inode_in) &&
1060 (src->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE) &&
1061 pos_out == 0 && len >= i_size_read(inode_out) &&
1062 !(dest->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE))
1063 cowextsize = src->i_d.di_cowextsize;
1064
1065 ret = xfs_reflink_update_dest(dest, pos_out + len, cowextsize,
1066 remap_flags);
1067
1068out_unlock:
1069 xfs_reflink_remap_unlock(file_in, file_out);
1070 if (ret)
1071 trace_xfs_reflink_remap_range_error(dest, ret, _RET_IP_);
1072 return remapped > 0 ? remapped : ret;
1073}
1074
1075STATIC int
1076xfs_file_open(
1077 struct inode *inode,
1078 struct file *file)
1079{
1080 if (!(file->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
1081 return -EFBIG;
1082 if (XFS_FORCED_SHUTDOWN(XFS_M(inode->i_sb)))
1083 return -EIO;
1084 file->f_mode |= FMODE_NOWAIT;
1085 return 0;
1086}
1087
1088STATIC int
1089xfs_dir_open(
1090 struct inode *inode,
1091 struct file *file)
1092{
1093 struct xfs_inode *ip = XFS_I(inode);
1094 int mode;
1095 int error;
1096
1097 error = xfs_file_open(inode, file);
1098 if (error)
1099 return error;
1100
1101
1102
1103
1104
1105 mode = xfs_ilock_data_map_shared(ip);
1106 if (ip->i_d.di_nextents > 0)
1107 error = xfs_dir3_data_readahead(ip, 0, 0);
1108 xfs_iunlock(ip, mode);
1109 return error;
1110}
1111
1112STATIC int
1113xfs_file_release(
1114 struct inode *inode,
1115 struct file *filp)
1116{
1117 return xfs_release(XFS_I(inode));
1118}
1119
1120STATIC int
1121xfs_file_readdir(
1122 struct file *file,
1123 struct dir_context *ctx)
1124{
1125 struct inode *inode = file_inode(file);
1126 xfs_inode_t *ip = XFS_I(inode);
1127 size_t bufsize;
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141 bufsize = (size_t)min_t(loff_t, XFS_READDIR_BUFSIZE, ip->i_d.di_size);
1142
1143 return xfs_readdir(NULL, ip, ctx, bufsize);
1144}
1145
1146STATIC loff_t
1147xfs_file_llseek(
1148 struct file *file,
1149 loff_t offset,
1150 int whence)
1151{
1152 struct inode *inode = file->f_mapping->host;
1153
1154 if (XFS_FORCED_SHUTDOWN(XFS_I(inode)->i_mount))
1155 return -EIO;
1156
1157 switch (whence) {
1158 default:
1159 return generic_file_llseek(file, offset, whence);
1160 case SEEK_HOLE:
1161 offset = iomap_seek_hole(inode, offset, &xfs_seek_iomap_ops);
1162 break;
1163 case SEEK_DATA:
1164 offset = iomap_seek_data(inode, offset, &xfs_seek_iomap_ops);
1165 break;
1166 }
1167
1168 if (offset < 0)
1169 return offset;
1170 return vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
1171}
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183static vm_fault_t
1184__xfs_filemap_fault(
1185 struct vm_fault *vmf,
1186 enum page_entry_size pe_size,
1187 bool write_fault)
1188{
1189 struct inode *inode = file_inode(vmf->vma->vm_file);
1190 struct xfs_inode *ip = XFS_I(inode);
1191 vm_fault_t ret;
1192
1193 trace_xfs_filemap_fault(ip, pe_size, write_fault);
1194
1195 if (write_fault) {
1196 sb_start_pagefault(inode->i_sb);
1197 file_update_time(vmf->vma->vm_file);
1198 }
1199
1200 xfs_ilock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
1201 if (IS_DAX(inode)) {
1202 pfn_t pfn;
1203
1204 ret = dax_iomap_fault(vmf, pe_size, &pfn, NULL,
1205 (write_fault && !vmf->cow_page) ?
1206 &xfs_direct_write_iomap_ops :
1207 &xfs_read_iomap_ops);
1208 if (ret & VM_FAULT_NEEDDSYNC)
1209 ret = dax_finish_sync_fault(vmf, pe_size, pfn);
1210 } else {
1211 if (write_fault)
1212 ret = iomap_page_mkwrite(vmf,
1213 &xfs_buffered_write_iomap_ops);
1214 else
1215 ret = filemap_fault(vmf);
1216 }
1217 xfs_iunlock(XFS_I(inode), XFS_MMAPLOCK_SHARED);
1218
1219 if (write_fault)
1220 sb_end_pagefault(inode->i_sb);
1221 return ret;
1222}
1223
1224static vm_fault_t
1225xfs_filemap_fault(
1226 struct vm_fault *vmf)
1227{
1228
1229 return __xfs_filemap_fault(vmf, PE_SIZE_PTE,
1230 IS_DAX(file_inode(vmf->vma->vm_file)) &&
1231 (vmf->flags & FAULT_FLAG_WRITE));
1232}
1233
1234static vm_fault_t
1235xfs_filemap_huge_fault(
1236 struct vm_fault *vmf,
1237 enum page_entry_size pe_size)
1238{
1239 if (!IS_DAX(file_inode(vmf->vma->vm_file)))
1240 return VM_FAULT_FALLBACK;
1241
1242
1243 return __xfs_filemap_fault(vmf, pe_size,
1244 (vmf->flags & FAULT_FLAG_WRITE));
1245}
1246
1247static vm_fault_t
1248xfs_filemap_page_mkwrite(
1249 struct vm_fault *vmf)
1250{
1251 return __xfs_filemap_fault(vmf, PE_SIZE_PTE, true);
1252}
1253
1254
1255
1256
1257
1258
1259static vm_fault_t
1260xfs_filemap_pfn_mkwrite(
1261 struct vm_fault *vmf)
1262{
1263
1264 return __xfs_filemap_fault(vmf, PE_SIZE_PTE, true);
1265}
1266
1267static const struct vm_operations_struct xfs_file_vm_ops = {
1268 .fault = xfs_filemap_fault,
1269 .huge_fault = xfs_filemap_huge_fault,
1270 .map_pages = filemap_map_pages,
1271 .page_mkwrite = xfs_filemap_page_mkwrite,
1272 .pfn_mkwrite = xfs_filemap_pfn_mkwrite,
1273};
1274
1275STATIC int
1276xfs_file_mmap(
1277 struct file *file,
1278 struct vm_area_struct *vma)
1279{
1280 struct inode *inode = file_inode(file);
1281 struct xfs_buftarg *target = xfs_inode_buftarg(XFS_I(inode));
1282
1283
1284
1285
1286
1287 if (!daxdev_mapping_supported(vma, target->bt_daxdev))
1288 return -EOPNOTSUPP;
1289
1290 file_accessed(file);
1291 vma->vm_ops = &xfs_file_vm_ops;
1292 if (IS_DAX(inode))
1293 vma->vm_flags |= VM_HUGEPAGE;
1294 return 0;
1295}
1296
1297const struct file_operations xfs_file_operations = {
1298 .llseek = xfs_file_llseek,
1299 .read_iter = xfs_file_read_iter,
1300 .write_iter = xfs_file_write_iter,
1301 .splice_read = generic_file_splice_read,
1302 .splice_write = iter_file_splice_write,
1303 .iopoll = iomap_dio_iopoll,
1304 .unlocked_ioctl = xfs_file_ioctl,
1305#ifdef CONFIG_COMPAT
1306 .compat_ioctl = xfs_file_compat_ioctl,
1307#endif
1308 .mmap = xfs_file_mmap,
1309 .mmap_supported_flags = MAP_SYNC,
1310 .open = xfs_file_open,
1311 .release = xfs_file_release,
1312 .fsync = xfs_file_fsync,
1313 .get_unmapped_area = thp_get_unmapped_area,
1314 .fallocate = xfs_file_fallocate,
1315 .fadvise = xfs_file_fadvise,
1316 .remap_file_range = xfs_file_remap_range,
1317};
1318
1319const struct file_operations xfs_dir_file_operations = {
1320 .open = xfs_dir_open,
1321 .read = generic_read_dir,
1322 .iterate_shared = xfs_file_readdir,
1323 .llseek = generic_file_llseek,
1324 .unlocked_ioctl = xfs_file_ioctl,
1325#ifdef CONFIG_COMPAT
1326 .compat_ioctl = xfs_file_compat_ioctl,
1327#endif
1328 .fsync = xfs_dir_fsync,
1329};
1330