1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (C) 1992, 1993, 1994, 1995
6 * Remy Card (card@masi.ibp.fr)
7 * Laboratoire MASI - Institut Blaise Pascal
8 * Universite Pierre et Marie Curie (Paris VI)
12 * linux/fs/minix/file.c
14 * Copyright (C) 1991, 1992 Linus Torvalds
16 * ext4 fs regular file handling primitives
18 * 64-bit file support on 64-bit platforms by Jakub Jelinek
19 * (jj@sunsite.ms.mff.cuni.cz)
22 #include <linux/time.h>
24 #include <linux/iomap.h>
25 #include <linux/mount.h>
26 #include <linux/path.h>
27 #include <linux/dax.h>
28 #include <linux/quotaops.h>
29 #include <linux/pagevec.h>
30 #include <linux/uio.h>
31 #include <linux/mman.h>
32 #include <linux/backing-dev.h>
34 #include "ext4_jbd2.h"
40 * Returns %true if the given DIO request should be attempted with DIO, or
41 * %false if it should fall back to buffered I/O.
43 * DIO isn't well specified; when it's unsupported (either due to the request
44 * being misaligned, or due to the file not supporting DIO at all), filesystems
45 * either fall back to buffered I/O or return EINVAL. For files that don't use
46 * any special features like encryption or verity, ext4 has traditionally
47 * returned EINVAL for misaligned DIO. iomap_dio_rw() uses this convention too.
48 * In this case, we should attempt the DIO, *not* fall back to buffered I/O.
50 * In contrast, in cases where DIO is unsupported due to ext4 features, ext4
51 * traditionally falls back to buffered I/O.
53 * This function implements the traditional ext4 behavior in all these cases.
55 static bool ext4_should_use_dio(struct kiocb
*iocb
, struct iov_iter
*iter
)
57 struct inode
*inode
= file_inode(iocb
->ki_filp
);
58 u32 dio_align
= ext4_dio_alignment(inode
);
66 return IS_ALIGNED(iocb
->ki_pos
| iov_iter_alignment(iter
), dio_align
);
69 static ssize_t
ext4_dio_read_iter(struct kiocb
*iocb
, struct iov_iter
*to
)
72 struct inode
*inode
= file_inode(iocb
->ki_filp
);
74 if (iocb
->ki_flags
& IOCB_NOWAIT
) {
75 if (!inode_trylock_shared(inode
))
78 inode_lock_shared(inode
);
81 if (!ext4_should_use_dio(iocb
, to
)) {
82 inode_unlock_shared(inode
);
84 * Fallback to buffered I/O if the operation being performed on
85 * the inode is not supported by direct I/O. The IOCB_DIRECT
86 * flag needs to be cleared here in order to ensure that the
87 * direct I/O path within generic_file_read_iter() is not
90 iocb
->ki_flags
&= ~IOCB_DIRECT
;
91 return generic_file_read_iter(iocb
, to
);
94 ret
= iomap_dio_rw(iocb
, to
, &ext4_iomap_ops
, NULL
, 0, NULL
, 0);
95 inode_unlock_shared(inode
);
97 file_accessed(iocb
->ki_filp
);
102 static ssize_t
ext4_dax_read_iter(struct kiocb
*iocb
, struct iov_iter
*to
)
104 struct inode
*inode
= file_inode(iocb
->ki_filp
);
107 if (iocb
->ki_flags
& IOCB_NOWAIT
) {
108 if (!inode_trylock_shared(inode
))
111 inode_lock_shared(inode
);
114 * Recheck under inode lock - at this point we are sure it cannot
117 if (!IS_DAX(inode
)) {
118 inode_unlock_shared(inode
);
119 /* Fallback to buffered IO in case we cannot support DAX */
120 return generic_file_read_iter(iocb
, to
);
122 ret
= dax_iomap_rw(iocb
, to
, &ext4_iomap_ops
);
123 inode_unlock_shared(inode
);
125 file_accessed(iocb
->ki_filp
);
130 static ssize_t
ext4_file_read_iter(struct kiocb
*iocb
, struct iov_iter
*to
)
132 struct inode
*inode
= file_inode(iocb
->ki_filp
);
134 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode
->i_sb
))))
137 if (!iov_iter_count(to
))
138 return 0; /* skip atime */
142 return ext4_dax_read_iter(iocb
, to
);
144 if (iocb
->ki_flags
& IOCB_DIRECT
)
145 return ext4_dio_read_iter(iocb
, to
);
147 return generic_file_read_iter(iocb
, to
);
150 static ssize_t
ext4_file_splice_read(struct file
*in
, loff_t
*ppos
,
151 struct pipe_inode_info
*pipe
,
152 size_t len
, unsigned int flags
)
154 struct inode
*inode
= file_inode(in
);
156 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode
->i_sb
))))
158 return filemap_splice_read(in
, ppos
, pipe
, len
, flags
);
162 * Called when an inode is released. Note that this is different
163 * from ext4_file_open: open gets called at every open, but release
164 * gets called only when /all/ the files are closed.
166 static int ext4_release_file(struct inode
*inode
, struct file
*filp
)
168 if (ext4_test_inode_state(inode
, EXT4_STATE_DA_ALLOC_CLOSE
)) {
169 ext4_alloc_da_blocks(inode
);
170 ext4_clear_inode_state(inode
, EXT4_STATE_DA_ALLOC_CLOSE
);
172 /* if we are the last writer on the inode, drop the block reservation */
173 if ((filp
->f_mode
& FMODE_WRITE
) &&
174 (atomic_read(&inode
->i_writecount
) == 1) &&
175 !EXT4_I(inode
)->i_reserved_data_blocks
) {
176 down_write(&EXT4_I(inode
)->i_data_sem
);
177 ext4_discard_preallocations(inode
, 0);
178 up_write(&EXT4_I(inode
)->i_data_sem
);
180 if (is_dx(inode
) && filp
->private_data
)
181 ext4_htree_free_dir_info(filp
->private_data
);
187 * This tests whether the IO in question is block-aligned or not.
188 * Ext4 utilizes unwritten extents when hole-filling during direct IO, and they
189 * are converted to written only after the IO is complete. Until they are
190 * mapped, these blocks appear as holes, so dio_zero_block() will assume that
191 * it needs to zero out portions of the start and/or end block. If 2 AIO
192 * threads are at work on the same unwritten block, they must be synchronized
193 * or one thread will zero the other's data, causing corruption.
196 ext4_unaligned_io(struct inode
*inode
, struct iov_iter
*from
, loff_t pos
)
198 struct super_block
*sb
= inode
->i_sb
;
199 unsigned long blockmask
= sb
->s_blocksize
- 1;
201 if ((pos
| iov_iter_alignment(from
)) & blockmask
)
208 ext4_extending_io(struct inode
*inode
, loff_t offset
, size_t len
)
210 if (offset
+ len
> i_size_read(inode
) ||
211 offset
+ len
> EXT4_I(inode
)->i_disksize
)
216 /* Is IO overwriting allocated or initialized blocks? */
217 static bool ext4_overwrite_io(struct inode
*inode
,
218 loff_t pos
, loff_t len
, bool *unwritten
)
220 struct ext4_map_blocks map
;
221 unsigned int blkbits
= inode
->i_blkbits
;
224 if (pos
+ len
> i_size_read(inode
))
227 map
.m_lblk
= pos
>> blkbits
;
228 map
.m_len
= EXT4_MAX_BLOCKS(len
, pos
, blkbits
);
231 err
= ext4_map_blocks(NULL
, inode
, &map
, 0);
235 * 'err==len' means that all of the blocks have been preallocated,
236 * regardless of whether they have been initialized or not. We need to
237 * check m_flags to distinguish the unwritten extents.
239 *unwritten
= !(map
.m_flags
& EXT4_MAP_MAPPED
);
243 static ssize_t
ext4_generic_write_checks(struct kiocb
*iocb
,
244 struct iov_iter
*from
)
246 struct inode
*inode
= file_inode(iocb
->ki_filp
);
249 if (unlikely(IS_IMMUTABLE(inode
)))
252 ret
= generic_write_checks(iocb
, from
);
257 * If we have encountered a bitmap-format file, the size limit
258 * is smaller than s_maxbytes, which is for extent-mapped files.
260 if (!(ext4_test_inode_flag(inode
, EXT4_INODE_EXTENTS
))) {
261 struct ext4_sb_info
*sbi
= EXT4_SB(inode
->i_sb
);
263 if (iocb
->ki_pos
>= sbi
->s_bitmap_maxbytes
)
265 iov_iter_truncate(from
, sbi
->s_bitmap_maxbytes
- iocb
->ki_pos
);
268 return iov_iter_count(from
);
271 static ssize_t
ext4_write_checks(struct kiocb
*iocb
, struct iov_iter
*from
)
275 count
= ext4_generic_write_checks(iocb
, from
);
279 ret
= file_modified(iocb
->ki_filp
);
285 static ssize_t
ext4_buffered_write_iter(struct kiocb
*iocb
,
286 struct iov_iter
*from
)
289 struct inode
*inode
= file_inode(iocb
->ki_filp
);
291 if (iocb
->ki_flags
& IOCB_NOWAIT
)
295 ret
= ext4_write_checks(iocb
, from
);
299 ret
= generic_perform_write(iocb
, from
);
303 if (unlikely(ret
<= 0))
305 return generic_write_sync(iocb
, ret
);
308 static ssize_t
ext4_handle_inode_extension(struct inode
*inode
, loff_t offset
,
309 ssize_t written
, size_t count
)
312 bool truncate
= false;
313 u8 blkbits
= inode
->i_blkbits
;
314 ext4_lblk_t written_blk
, end_blk
;
318 * Note that EXT4_I(inode)->i_disksize can get extended up to
319 * inode->i_size while the I/O was running due to writeback of delalloc
320 * blocks. But, the code in ext4_iomap_alloc() is careful to use
321 * zeroed/unwritten extents if this is possible; thus we won't leave
322 * uninitialized blocks in a file even if we didn't succeed in writing
323 * as much as we intended.
325 WARN_ON_ONCE(i_size_read(inode
) < EXT4_I(inode
)->i_disksize
);
326 if (offset
+ count
<= EXT4_I(inode
)->i_disksize
) {
328 * We need to ensure that the inode is removed from the orphan
329 * list if it has been added prematurely, due to writeback of
332 if (!list_empty(&EXT4_I(inode
)->i_orphan
) && inode
->i_nlink
) {
333 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 2);
335 if (IS_ERR(handle
)) {
336 ext4_orphan_del(NULL
, inode
);
337 return PTR_ERR(handle
);
340 ext4_orphan_del(handle
, inode
);
341 ext4_journal_stop(handle
);
350 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 2);
351 if (IS_ERR(handle
)) {
352 written
= PTR_ERR(handle
);
356 if (ext4_update_inode_size(inode
, offset
+ written
)) {
357 ret
= ext4_mark_inode_dirty(handle
, inode
);
360 ext4_journal_stop(handle
);
366 * We may need to truncate allocated but not written blocks beyond EOF.
368 written_blk
= ALIGN(offset
+ written
, 1 << blkbits
);
369 end_blk
= ALIGN(offset
+ count
, 1 << blkbits
);
370 if (written_blk
< end_blk
&& ext4_can_truncate(inode
))
374 * Remove the inode from the orphan list if it has been extended and
375 * everything went OK.
377 if (!truncate
&& inode
->i_nlink
)
378 ext4_orphan_del(handle
, inode
);
379 ext4_journal_stop(handle
);
383 ext4_truncate_failed_write(inode
);
385 * If the truncate operation failed early, then the inode may
386 * still be on the orphan list. In that case, we need to try
387 * remove the inode from the in-memory linked list.
390 ext4_orphan_del(NULL
, inode
);
396 static int ext4_dio_write_end_io(struct kiocb
*iocb
, ssize_t size
,
397 int error
, unsigned int flags
)
399 loff_t pos
= iocb
->ki_pos
;
400 struct inode
*inode
= file_inode(iocb
->ki_filp
);
405 if (size
&& flags
& IOMAP_DIO_UNWRITTEN
) {
406 error
= ext4_convert_unwritten_extents(NULL
, inode
, pos
, size
);
411 * If we are extending the file, we have to update i_size here before
412 * page cache gets invalidated in iomap_dio_rw(). Otherwise racing
413 * buffered reads could zero out too much from page cache pages. Update
414 * of on-disk size will happen later in ext4_dio_write_iter() where
415 * we have enough information to also perform orphan list handling etc.
416 * Note that we perform all extending writes synchronously under
417 * i_rwsem held exclusively so i_size update is safe here in that case.
418 * If the write was not extending, we cannot see pos > i_size here
419 * because operations reducing i_size like truncate wait for all
420 * outstanding DIO before updating i_size.
423 if (pos
> i_size_read(inode
))
424 i_size_write(inode
, pos
);
429 static const struct iomap_dio_ops ext4_dio_write_ops
= {
430 .end_io
= ext4_dio_write_end_io
,
434 * The intention here is to start with shared lock acquired then see if any
435 * condition requires an exclusive inode lock. If yes, then we restart the
436 * whole operation by releasing the shared lock and acquiring exclusive lock.
438 * - For unaligned_io we never take shared lock as it may cause data corruption
439 * when two unaligned IO tries to modify the same block e.g. while zeroing.
441 * - For extending writes case we don't take the shared lock, since it requires
442 * updating inode i_disksize and/or orphan handling with exclusive lock.
444 * - shared locking will only be true mostly with overwrites, including
445 * initialized blocks and unwritten blocks. For overwrite unwritten blocks
446 * we protect splitting extents by i_data_sem in ext4_inode_info, so we can
447 * also release exclusive i_rwsem lock.
449 * - Otherwise we will switch to exclusive i_rwsem lock.
451 static ssize_t
ext4_dio_write_checks(struct kiocb
*iocb
, struct iov_iter
*from
,
452 bool *ilock_shared
, bool *extend
,
453 bool *unwritten
, int *dio_flags
)
455 struct file
*file
= iocb
->ki_filp
;
456 struct inode
*inode
= file_inode(file
);
460 bool overwrite
, unaligned_io
;
463 ret
= ext4_generic_write_checks(iocb
, from
);
467 offset
= iocb
->ki_pos
;
470 unaligned_io
= ext4_unaligned_io(inode
, from
, offset
);
471 *extend
= ext4_extending_io(inode
, offset
, count
);
472 overwrite
= ext4_overwrite_io(inode
, offset
, count
, unwritten
);
475 * Determine whether we need to upgrade to an exclusive lock. This is
476 * required to change security info in file_modified(), for extending
477 * I/O, any form of non-overwrite I/O, and unaligned I/O to unwritten
478 * extents (as partial block zeroing may be required).
481 ((!IS_NOSEC(inode
) || *extend
|| !overwrite
||
482 (unaligned_io
&& *unwritten
)))) {
483 if (iocb
->ki_flags
& IOCB_NOWAIT
) {
487 inode_unlock_shared(inode
);
488 *ilock_shared
= false;
494 * Now that locking is settled, determine dio flags and exclusivity
495 * requirements. Unaligned writes are allowed under shared lock so long
496 * as they are pure overwrites. Set the iomap overwrite only flag as an
497 * added precaution in this case. Even though this is unnecessary, we
498 * can detect and warn on unexpected -EAGAIN if an unsafe unaligned
499 * write is ever submitted.
501 * Otherwise, concurrent unaligned writes risk data corruption due to
502 * partial block zeroing in the dio layer, and so the I/O must occur
503 * exclusively. The inode lock is already held exclusive if the write is
504 * non-overwrite or extending, so drain all outstanding dio and set the
505 * force wait dio flag.
507 if (*ilock_shared
&& unaligned_io
) {
508 *dio_flags
= IOMAP_DIO_OVERWRITE_ONLY
;
509 } else if (!*ilock_shared
&& (unaligned_io
|| *extend
)) {
510 if (iocb
->ki_flags
& IOCB_NOWAIT
) {
514 if (unaligned_io
&& (!overwrite
|| *unwritten
))
515 inode_dio_wait(inode
);
516 *dio_flags
= IOMAP_DIO_FORCE_WAIT
;
519 ret
= file_modified(file
);
526 inode_unlock_shared(inode
);
532 static ssize_t
ext4_dio_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
536 struct inode
*inode
= file_inode(iocb
->ki_filp
);
537 loff_t offset
= iocb
->ki_pos
;
538 size_t count
= iov_iter_count(from
);
539 const struct iomap_ops
*iomap_ops
= &ext4_iomap_ops
;
540 bool extend
= false, unwritten
= false;
541 bool ilock_shared
= true;
545 * Quick check here without any i_rwsem lock to see if it is extending
546 * IO. A more reliable check is done in ext4_dio_write_checks() with
547 * proper locking in place.
549 if (offset
+ count
> i_size_read(inode
))
550 ilock_shared
= false;
552 if (iocb
->ki_flags
& IOCB_NOWAIT
) {
554 if (!inode_trylock_shared(inode
))
557 if (!inode_trylock(inode
))
562 inode_lock_shared(inode
);
567 /* Fallback to buffered I/O if the inode does not support direct I/O. */
568 if (!ext4_should_use_dio(iocb
, from
)) {
570 inode_unlock_shared(inode
);
573 return ext4_buffered_write_iter(iocb
, from
);
576 ret
= ext4_dio_write_checks(iocb
, from
, &ilock_shared
, &extend
,
577 &unwritten
, &dio_flags
);
582 * Make sure inline data cannot be created anymore since we are going
583 * to allocate blocks for DIO. We know the inode does not have any
584 * inline data now because ext4_dio_supported() checked for that.
586 ext4_clear_inode_state(inode
, EXT4_STATE_MAY_INLINE_DATA
);
588 offset
= iocb
->ki_pos
;
592 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 2);
593 if (IS_ERR(handle
)) {
594 ret
= PTR_ERR(handle
);
598 ret
= ext4_orphan_add(handle
, inode
);
600 ext4_journal_stop(handle
);
604 ext4_journal_stop(handle
);
607 if (ilock_shared
&& !unwritten
)
608 iomap_ops
= &ext4_iomap_overwrite_ops
;
609 ret
= iomap_dio_rw(iocb
, from
, iomap_ops
, &ext4_dio_write_ops
,
611 WARN_ON_ONCE(ret
== -EAGAIN
&& !(iocb
->ki_flags
& IOCB_NOWAIT
));
616 ret
= ext4_handle_inode_extension(inode
, offset
, ret
, count
);
620 inode_unlock_shared(inode
);
624 if (ret
>= 0 && iov_iter_count(from
)) {
628 offset
= iocb
->ki_pos
;
629 err
= ext4_buffered_write_iter(iocb
, from
);
634 * We need to ensure that the pages within the page cache for
635 * the range covered by this I/O are written to disk and
636 * invalidated. This is in attempt to preserve the expected
637 * direct I/O semantics in the case we fallback to buffered I/O
638 * to complete off the I/O request.
641 endbyte
= offset
+ err
- 1;
642 err
= filemap_write_and_wait_range(iocb
->ki_filp
->f_mapping
,
645 invalidate_mapping_pages(iocb
->ki_filp
->f_mapping
,
646 offset
>> PAGE_SHIFT
,
647 endbyte
>> PAGE_SHIFT
);
655 ext4_dax_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
662 struct inode
*inode
= file_inode(iocb
->ki_filp
);
664 if (iocb
->ki_flags
& IOCB_NOWAIT
) {
665 if (!inode_trylock(inode
))
671 ret
= ext4_write_checks(iocb
, from
);
675 offset
= iocb
->ki_pos
;
676 count
= iov_iter_count(from
);
678 if (offset
+ count
> EXT4_I(inode
)->i_disksize
) {
679 handle
= ext4_journal_start(inode
, EXT4_HT_INODE
, 2);
680 if (IS_ERR(handle
)) {
681 ret
= PTR_ERR(handle
);
685 ret
= ext4_orphan_add(handle
, inode
);
687 ext4_journal_stop(handle
);
692 ext4_journal_stop(handle
);
695 ret
= dax_iomap_rw(iocb
, from
, &ext4_iomap_ops
);
698 ret
= ext4_handle_inode_extension(inode
, offset
, ret
, count
);
702 ret
= generic_write_sync(iocb
, ret
);
708 ext4_file_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
710 struct inode
*inode
= file_inode(iocb
->ki_filp
);
712 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode
->i_sb
))))
717 return ext4_dax_write_iter(iocb
, from
);
719 if (iocb
->ki_flags
& IOCB_DIRECT
)
720 return ext4_dio_write_iter(iocb
, from
);
722 return ext4_buffered_write_iter(iocb
, from
);
726 static vm_fault_t
ext4_dax_huge_fault(struct vm_fault
*vmf
,
727 enum page_entry_size pe_size
)
732 handle_t
*handle
= NULL
;
733 struct inode
*inode
= file_inode(vmf
->vma
->vm_file
);
734 struct super_block
*sb
= inode
->i_sb
;
737 * We have to distinguish real writes from writes which will result in a
738 * COW page; COW writes should *not* poke the journal (the file will not
739 * be changed). Doing so would cause unintended failures when mounted
742 * We check for VM_SHARED rather than vmf->cow_page since the latter is
743 * unset for pe_size != PE_SIZE_PTE (i.e. only in do_cow_fault); for
744 * other sizes, dax_iomap_fault will handle splitting / fallback so that
745 * we eventually come back with a COW page.
747 bool write
= (vmf
->flags
& FAULT_FLAG_WRITE
) &&
748 (vmf
->vma
->vm_flags
& VM_SHARED
);
749 struct address_space
*mapping
= vmf
->vma
->vm_file
->f_mapping
;
753 sb_start_pagefault(sb
);
754 file_update_time(vmf
->vma
->vm_file
);
755 filemap_invalidate_lock_shared(mapping
);
757 handle
= ext4_journal_start_sb(sb
, EXT4_HT_WRITE_PAGE
,
758 EXT4_DATA_TRANS_BLOCKS(sb
));
759 if (IS_ERR(handle
)) {
760 filemap_invalidate_unlock_shared(mapping
);
761 sb_end_pagefault(sb
);
762 return VM_FAULT_SIGBUS
;
765 filemap_invalidate_lock_shared(mapping
);
767 result
= dax_iomap_fault(vmf
, pe_size
, &pfn
, &error
, &ext4_iomap_ops
);
769 ext4_journal_stop(handle
);
771 if ((result
& VM_FAULT_ERROR
) && error
== -ENOSPC
&&
772 ext4_should_retry_alloc(sb
, &retries
))
774 /* Handling synchronous page fault? */
775 if (result
& VM_FAULT_NEEDDSYNC
)
776 result
= dax_finish_sync_fault(vmf
, pe_size
, pfn
);
777 filemap_invalidate_unlock_shared(mapping
);
778 sb_end_pagefault(sb
);
780 filemap_invalidate_unlock_shared(mapping
);
786 static vm_fault_t
ext4_dax_fault(struct vm_fault
*vmf
)
788 return ext4_dax_huge_fault(vmf
, PE_SIZE_PTE
);
791 static const struct vm_operations_struct ext4_dax_vm_ops
= {
792 .fault
= ext4_dax_fault
,
793 .huge_fault
= ext4_dax_huge_fault
,
794 .page_mkwrite
= ext4_dax_fault
,
795 .pfn_mkwrite
= ext4_dax_fault
,
798 #define ext4_dax_vm_ops ext4_file_vm_ops
801 static const struct vm_operations_struct ext4_file_vm_ops
= {
802 .fault
= filemap_fault
,
803 .map_pages
= filemap_map_pages
,
804 .page_mkwrite
= ext4_page_mkwrite
,
807 static int ext4_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
809 struct inode
*inode
= file
->f_mapping
->host
;
810 struct ext4_sb_info
*sbi
= EXT4_SB(inode
->i_sb
);
811 struct dax_device
*dax_dev
= sbi
->s_daxdev
;
813 if (unlikely(ext4_forced_shutdown(sbi
)))
817 * We don't support synchronous mappings for non-DAX files and
818 * for DAX files if underneath dax_device is not synchronous.
820 if (!daxdev_mapping_supported(vma
, dax_dev
))
824 if (IS_DAX(file_inode(file
))) {
825 vma
->vm_ops
= &ext4_dax_vm_ops
;
826 vm_flags_set(vma
, VM_HUGEPAGE
);
828 vma
->vm_ops
= &ext4_file_vm_ops
;
833 static int ext4_sample_last_mounted(struct super_block
*sb
,
834 struct vfsmount
*mnt
)
836 struct ext4_sb_info
*sbi
= EXT4_SB(sb
);
842 if (likely(ext4_test_mount_flag(sb
, EXT4_MF_MNTDIR_SAMPLED
)))
845 if (sb_rdonly(sb
) || !sb_start_intwrite_trylock(sb
))
848 ext4_set_mount_flag(sb
, EXT4_MF_MNTDIR_SAMPLED
);
850 * Sample where the filesystem has been mounted and
851 * store it in the superblock for sysadmin convenience
852 * when trying to sort through large numbers of block
853 * devices or filesystem images.
855 memset(buf
, 0, sizeof(buf
));
857 path
.dentry
= mnt
->mnt_root
;
858 cp
= d_path(&path
, buf
, sizeof(buf
));
863 handle
= ext4_journal_start_sb(sb
, EXT4_HT_MISC
, 1);
864 err
= PTR_ERR(handle
);
867 BUFFER_TRACE(sbi
->s_sbh
, "get_write_access");
868 err
= ext4_journal_get_write_access(handle
, sb
, sbi
->s_sbh
,
872 lock_buffer(sbi
->s_sbh
);
873 strncpy(sbi
->s_es
->s_last_mounted
, cp
,
874 sizeof(sbi
->s_es
->s_last_mounted
));
875 ext4_superblock_csum_set(sb
);
876 unlock_buffer(sbi
->s_sbh
);
877 ext4_handle_dirty_metadata(handle
, NULL
, sbi
->s_sbh
);
879 ext4_journal_stop(handle
);
885 static int ext4_file_open(struct inode
*inode
, struct file
*filp
)
889 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode
->i_sb
))))
892 ret
= ext4_sample_last_mounted(inode
->i_sb
, filp
->f_path
.mnt
);
896 ret
= fscrypt_file_open(inode
, filp
);
900 ret
= fsverity_file_open(inode
, filp
);
905 * Set up the jbd2_inode if we are opening the inode for
906 * writing and the journal is present
908 if (filp
->f_mode
& FMODE_WRITE
) {
909 ret
= ext4_inode_attach_jinode(inode
);
914 filp
->f_mode
|= FMODE_NOWAIT
| FMODE_BUF_RASYNC
|
915 FMODE_DIO_PARALLEL_WRITE
;
916 return dquot_file_open(inode
, filp
);
920 * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
921 * by calling generic_file_llseek_size() with the appropriate maxbytes
924 loff_t
ext4_llseek(struct file
*file
, loff_t offset
, int whence
)
926 struct inode
*inode
= file
->f_mapping
->host
;
929 if (!(ext4_test_inode_flag(inode
, EXT4_INODE_EXTENTS
)))
930 maxbytes
= EXT4_SB(inode
->i_sb
)->s_bitmap_maxbytes
;
932 maxbytes
= inode
->i_sb
->s_maxbytes
;
936 return generic_file_llseek_size(file
, offset
, whence
,
937 maxbytes
, i_size_read(inode
));
939 inode_lock_shared(inode
);
940 offset
= iomap_seek_hole(inode
, offset
,
941 &ext4_iomap_report_ops
);
942 inode_unlock_shared(inode
);
945 inode_lock_shared(inode
);
946 offset
= iomap_seek_data(inode
, offset
,
947 &ext4_iomap_report_ops
);
948 inode_unlock_shared(inode
);
954 return vfs_setpos(file
, offset
, maxbytes
);
957 const struct file_operations ext4_file_operations
= {
958 .llseek
= ext4_llseek
,
959 .read_iter
= ext4_file_read_iter
,
960 .write_iter
= ext4_file_write_iter
,
961 .iopoll
= iocb_bio_iopoll
,
962 .unlocked_ioctl
= ext4_ioctl
,
964 .compat_ioctl
= ext4_compat_ioctl
,
966 .mmap
= ext4_file_mmap
,
967 .mmap_supported_flags
= MAP_SYNC
,
968 .open
= ext4_file_open
,
969 .release
= ext4_release_file
,
970 .fsync
= ext4_sync_file
,
971 .get_unmapped_area
= thp_get_unmapped_area
,
972 .splice_read
= ext4_file_splice_read
,
973 .splice_write
= iter_file_splice_write
,
974 .fallocate
= ext4_fallocate
,
977 const struct inode_operations ext4_file_inode_operations
= {
978 .setattr
= ext4_setattr
,
979 .getattr
= ext4_file_getattr
,
980 .listxattr
= ext4_listxattr
,
981 .get_inode_acl
= ext4_get_acl
,
982 .set_acl
= ext4_set_acl
,
983 .fiemap
= ext4_fiemap
,
984 .fileattr_get
= ext4_fileattr_get
,
985 .fileattr_set
= ext4_fileattr_set
,