Lines Matching refs:inode
39 static bool ext4_dio_supported(struct inode *inode)
41 if (IS_ENABLED(CONFIG_FS_ENCRYPTION) && IS_ENCRYPTED(inode))
43 if (fsverity_active(inode))
45 if (ext4_should_journal_data(inode))
47 if (ext4_has_inline_data(inode))
55 struct inode *inode = file_inode(iocb->ki_filp);
58 if (!inode_trylock_shared(inode))
61 inode_lock_shared(inode);
64 if (!ext4_dio_supported(inode)) {
65 inode_unlock_shared(inode);
68 * the inode is not supported by direct I/O. The IOCB_DIRECT
79 inode_unlock_shared(inode);
88 struct inode *inode = file_inode(iocb->ki_filp);
92 if (!inode_trylock_shared(inode))
95 inode_lock_shared(inode);
98 * Recheck under inode lock - at this point we are sure it cannot
101 if (!IS_DAX(inode)) {
102 inode_unlock_shared(inode);
107 inode_unlock_shared(inode);
116 struct inode *inode = file_inode(iocb->ki_filp);
118 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
125 if (IS_DAX(inode))
135 * Called when an inode is released. Note that this is different
139 static int ext4_release_file(struct inode *inode, struct file *filp)
141 if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) {
142 ext4_alloc_da_blocks(inode);
143 ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
145 /* if we are the last writer on the inode, drop the block reservation */
147 (atomic_read(&inode->i_writecount) == 1) &&
148 !EXT4_I(inode)->i_reserved_data_blocks) {
149 down_write(&EXT4_I(inode)->i_data_sem);
150 ext4_discard_preallocations(inode, 0);
151 up_write(&EXT4_I(inode)->i_data_sem);
153 if (is_dx(inode) && filp->private_data)
169 ext4_unaligned_io(struct inode *inode, struct iov_iter *from, loff_t pos)
171 struct super_block *sb = inode->i_sb;
181 ext4_extending_io(struct inode *inode, loff_t offset, size_t len)
183 if (offset + len > i_size_read(inode) ||
184 offset + len > EXT4_I(inode)->i_disksize)
190 static bool ext4_overwrite_io(struct inode *inode, loff_t pos, loff_t len)
193 unsigned int blkbits = inode->i_blkbits;
196 if (pos + len > i_size_read(inode))
203 err = ext4_map_blocks(NULL, inode, &map, 0);
215 struct inode *inode = file_inode(iocb->ki_filp);
218 if (unlikely(IS_IMMUTABLE(inode)))
229 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
230 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
258 struct inode *inode = file_inode(iocb->ki_filp);
263 inode_lock(inode);
268 current->backing_dev_info = inode_to_bdi(inode);
273 inode_unlock(inode);
282 static ssize_t ext4_handle_inode_extension(struct inode *inode, loff_t offset,
287 u8 blkbits = inode->i_blkbits;
292 * Note that EXT4_I(inode)->i_disksize can get extended up to
293 * inode->i_size while the I/O was running due to writeback of delalloc
299 WARN_ON_ONCE(i_size_read(inode) < EXT4_I(inode)->i_disksize);
300 if (offset + count <= EXT4_I(inode)->i_disksize) {
302 * We need to ensure that the inode is removed from the orphan
306 if (!list_empty(&EXT4_I(inode)->i_orphan) && inode->i_nlink) {
307 handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
310 ext4_orphan_del(NULL, inode);
314 ext4_orphan_del(handle, inode);
324 handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
330 if (ext4_update_inode_size(inode, offset + written)) {
331 ret = ext4_mark_inode_dirty(handle, inode);
344 if (written_blk < end_blk && ext4_can_truncate(inode))
348 * Remove the inode from the orphan list if it has been extended and
351 if (!truncate && inode->i_nlink)
352 ext4_orphan_del(handle, inode);
357 ext4_truncate_failed_write(inode);
359 * If the truncate operation failed early, then the inode may
361 * remove the inode from the in-memory linked list.
363 if (inode->i_nlink)
364 ext4_orphan_del(NULL, inode);
374 struct inode *inode = file_inode(iocb->ki_filp);
380 error = ext4_convert_unwritten_extents(NULL, inode, pos, size);
397 if (pos > i_size_read(inode))
398 i_size_write(inode, pos);
409 * condition requires an exclusive inode lock. If yes, then we restart the
416 * updating inode i_disksize and/or orphan handling with exclusive lock.
425 struct inode *inode = file_inode(file);
437 if (ext4_extending_io(inode, offset, count))
445 if (*ilock_shared && (!IS_NOSEC(inode) || *extend ||
446 !ext4_overwrite_io(inode, offset, count))) {
451 inode_unlock_shared(inode);
453 inode_lock(inode);
464 inode_unlock_shared(inode);
466 inode_unlock(inode);
474 struct inode *inode = file_inode(iocb->ki_filp);
482 * We initially start with shared inode lock unless it is
485 if (ext4_unaligned_io(inode, from, offset)) {
494 if (offset + count > i_size_read(inode))
499 if (!inode_trylock_shared(inode))
502 if (!inode_trylock(inode))
507 inode_lock_shared(inode);
509 inode_lock(inode);
512 /* Fallback to buffered I/O if the inode does not support direct I/O. */
513 if (!ext4_dio_supported(inode)) {
515 inode_unlock_shared(inode);
517 inode_unlock(inode);
532 * to allocate blocks for DIO. We know the inode does not have any
535 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
551 inode_dio_wait(inode);
554 handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
560 ret = ext4_orphan_add(handle, inode);
577 ret = ext4_handle_inode_extension(inode, offset, ret, count);
581 inode_unlock_shared(inode);
583 inode_unlock(inode);
623 struct inode *inode = file_inode(iocb->ki_filp);
626 if (!inode_trylock(inode))
629 inode_lock(inode);
639 if (offset + count > EXT4_I(inode)->i_disksize) {
640 handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
646 ret = ext4_orphan_add(handle, inode);
659 ret = ext4_handle_inode_extension(inode, offset, ret, count);
661 inode_unlock(inode);
671 struct inode *inode = file_inode(iocb->ki_filp);
673 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
677 if (IS_DAX(inode))
694 struct inode *inode = file_inode(vmf->vma->vm_file);
695 struct super_block *sb = inode->i_sb;
715 down_read(&EXT4_I(inode)->i_mmap_sem);
720 up_read(&EXT4_I(inode)->i_mmap_sem);
725 down_read(&EXT4_I(inode)->i_mmap_sem);
737 up_read(&EXT4_I(inode)->i_mmap_sem);
740 up_read(&EXT4_I(inode)->i_mmap_sem);
769 struct inode *inode = file->f_mapping->host;
770 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
844 static int ext4_file_open(struct inode *inode, struct file *filp)
848 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
851 ret = ext4_sample_last_mounted(inode->i_sb, filp->f_path.mnt);
855 ret = fscrypt_file_open(inode, filp);
859 ret = fsverity_file_open(inode, filp);
864 * Set up the jbd2_inode if we are opening the inode for
868 ret = ext4_inode_attach_jinode(inode);
874 return dquot_file_open(inode, filp);
884 struct inode *inode = file->f_mapping->host;
887 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
888 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
890 maxbytes = inode->i_sb->s_maxbytes;
895 maxbytes, i_size_read(inode));
897 inode_lock_shared(inode);
898 offset = iomap_seek_hole(inode, offset,
900 inode_unlock_shared(inode);
903 inode_lock_shared(inode);
904 offset = iomap_seek_data(inode, offset,
906 inode_unlock_shared(inode);