// SPDX-License-Identifier: GPL-2.0/* *  linux/fs/ext4/file.c * * Copyright (C) 1992, 1993, 1994, 1995 * Remy Card (card@masi.ibp.fr) * Laboratoire MASI - Institut Blaise Pascal * Universite Pierre et Marie Curie (Paris VI) * *  from * *  linux/fs/minix/file.c * *  Copyright (C) 1991, 1992  Linus Torvalds * *  ext4 fs regular file handling primitives * *  64-bit file support on 64-bit platforms by Jakub Jelinek *	(jj@sunsite.ms.mff.cuni.cz) */ #include <linux/time.h>#include <linux/fs.h>#include <linux/iomap.h>#include <linux/mount.h>#include <linux/path.h>#include <linux/dax.h>#include <linux/filelock.h>#include <linux/quotaops.h>#include <linux/uio.h>#include <linux/mman.h>#include <linux/backing-dev.h>#include "ext4.h"#include "ext4_jbd2.h"#include "xattr.h"#include "acl.h"#include "truncate.h" /* * Returns %true if the given DIO request should be attempted with DIO, or * %false if it should fall back to buffered I/O. * * DIO isn't well specified; when it's unsupported (either due to the request * being misaligned, or due to the file not supporting DIO at all), filesystems * either fall back to buffered I/O or return EINVAL.  For files that don't use * any special features like encryption or verity, ext4 has traditionally * returned EINVAL for misaligned DIO.  iomap_dio_rw() uses this convention too. * In this case, we should attempt the DIO, *not* fall back to buffered I/O. * * In contrast, in cases where DIO is unsupported due to ext4 features, ext4 * traditionally falls back to buffered I/O. * * This function implements the traditional ext4 behavior in all these cases. */static bool ext4_should_use_dio(struct kiocb *iocb, struct iov_iter *iter){	struct inode *inode = file_inode(iocb->ki_filp);	u32 dio_align = ext4_dio_alignment(inode); 	if (dio_align == 0)		return false; 	if (dio_align == 1)		return true; 	return IS_ALIGNED(iocb->ki_pos | iov_iter_alignment(iter), dio_align);} static ssize_t ext4_dio_read_iter(struct kiocb *iocb, struct iov_iter *to){	ssize_t ret;	struct inode *inode = file_inode(iocb->ki_filp); 	if (iocb->ki_flags & IOCB_NOWAIT) {		if (!inode_trylock_shared(inode))			return -EAGAIN;	} else {		inode_lock_shared(inode);	} 	if (!ext4_should_use_dio(iocb, to)) {		inode_unlock_shared(inode);		/*		 * Fallback to buffered I/O if the operation being performed on		 * the inode is not supported by direct I/O. The IOCB_DIRECT		 * flag needs to be cleared here in order to ensure that the		 * direct I/O path within generic_file_read_iter() is not		 * taken.		 */		iocb->ki_flags &= ~IOCB_DIRECT;		return generic_file_read_iter(iocb, to);	} 	ret = iomap_dio_read_simple(iocb, to, ext4_iomap_begin);	if (ret == -ENOTBLK)		ret = iomap_dio_rw(iocb, to, &ext4_iomap_ops, NULL, 0, NULL, 0);	inode_unlock_shared(inode); 	file_accessed(iocb->ki_filp);	return ret;} #ifdef CONFIG_FS_DAXstatic ssize_t ext4_dax_read_iter(struct kiocb *iocb, struct iov_iter *to){	struct inode *inode = file_inode(iocb->ki_filp);	ssize_t ret; 	if (iocb->ki_flags & IOCB_NOWAIT) {		if (!inode_trylock_shared(inode))			return -EAGAIN;	} else {		inode_lock_shared(inode);	}	/*	 * Recheck under inode lock - at this point we are sure it cannot	 * change anymore	 */	if (!IS_DAX(inode)) {		inode_unlock_shared(inode);		/* Fallback to buffered IO in case we cannot support DAX */		return generic_file_read_iter(iocb, to);	}	ret = dax_iomap_rw(iocb, to, &ext4_iomap_ops);	inode_unlock_shared(inode); 	file_accessed(iocb->ki_filp);	return ret;}#endif static ssize_t ext4_file_read_iter(struct kiocb *iocb, struct iov_iter *to){	struct inode *inode = file_inode(iocb->ki_filp); 	if (unlikely(ext4_forced_shutdown(inode->i_sb)))		return -EIO; 	if (!iov_iter_count(to))		return 0; /* skip atime */ #ifdef CONFIG_FS_DAX	if (IS_DAX(inode))		return ext4_dax_read_iter(iocb, to);#endif	if (iocb->ki_flags & IOCB_DIRECT)		return ext4_dio_read_iter(iocb, to); 	return generic_file_read_iter(iocb, to);} static ssize_t ext4_file_splice_read(struct file *in, loff_t *ppos,				     struct pipe_inode_info *pipe,				     size_t len, unsigned int flags){	struct inode *inode = file_inode(in); 	if (unlikely(ext4_forced_shutdown(inode->i_sb)))		return -EIO;	return filemap_splice_read(in, ppos, pipe, len, flags);} /* * Called when an inode is released. Note that this is different * from ext4_file_open: open gets called at every open, but release * gets called only when /all/ the files are closed. */static int ext4_release_file(struct inode *inode, struct file *filp){	if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) {		ext4_alloc_da_blocks(inode);		ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);	}	/* if we are the last writer on the inode, drop the block reservation */	if ((filp->f_mode & FMODE_WRITE) &&			(atomic_read(&inode->i_writecount) == 1) &&			!EXT4_I(inode)->i_reserved_data_blocks) {		down_write(&EXT4_I(inode)->i_data_sem);		ext4_discard_preallocations(inode);		up_write(&EXT4_I(inode)->i_data_sem);	}	if (is_dx(inode) && filp->private_data)		ext4_htree_free_dir_info(filp->private_data); 	return 0;} /* * This tests whether the IO in question is block-aligned or not. * Ext4 utilizes unwritten extents when hole-filling during direct IO, and they * are converted to written only after the IO is complete.  Until they are * mapped, these blocks appear as holes, so dio_zero_block() will assume that * it needs to zero out portions of the start and/or end block.  If 2 AIO * threads are at work on the same unwritten block, they must be synchronized * or one thread will zero the other's data, causing corruption. */static boolext4_unaligned_io(struct inode *inode, struct iov_iter *from, loff_t pos){	struct super_block *sb = inode->i_sb;	unsigned long blockmask = sb->s_blocksize - 1; 	if ((pos | iov_iter_alignment(from)) & blockmask)		return true; 	return false;} static boolext4_extending_io(struct inode *inode, loff_t offset, size_t len){	if (offset + len > i_size_read(inode) ||	    offset + len > EXT4_I(inode)->i_disksize)		return true;	return false;} /* * Does an unaligned DIO write require partial block zeroing? * * Partial block zeroing is performed only for the head and tail blocks * when they are partially covered by the write and the underlying extent * is a hole or unwritten. Middle blocks (fully covered by the write) * are written as whole blocks without zeroing. * * When zeroing is required, two concurrent unaligned DIO writes to the * same partial block can race and corrupt each other's data, so the * caller must take the exclusive i_rwsem and drain in-flight DIO. When * zeroing is not required, shared lock is safe -- block allocation and * unwritten conversion for middle blocks are protected by i_data_sem * and inode_dio_begin(). */static bool ext4_dio_needs_zeroing(struct inode *inode, loff_t pos, loff_t len){	struct ext4_map_blocks map;	unsigned int blkbits = inode->i_blkbits;	unsigned long blockmask = inode->i_sb->s_blocksize - 1;	bool head_partial, tail_partial;	ext4_lblk_t head_lblk, tail_lblk;	int err; 	if (pos + len > i_size_read(inode))		return true; 	head_partial = (pos & blockmask) != 0;	tail_partial = ((pos + len) & blockmask) != 0;	head_lblk = pos >> blkbits;	tail_lblk = (pos + len - 1) >> blkbits; 	/* Check the head partial block. */	if (head_partial) {		map.m_lblk = head_lblk;		map.m_len = tail_lblk - head_lblk + 1;		err = ext4_map_blocks(NULL, inode, &map, 0);		if (err <= 0 || !(map.m_flags & EXT4_MAP_MAPPED))			return true;		/* If this mapping already covers the tail block, we're done. */		if (!tail_partial || map.m_lblk + err > tail_lblk)			return false;	} 	/* Check the tail partial block. */	if (tail_partial) {		map.m_lblk = tail_lblk;		map.m_len = 1;		err = ext4_map_blocks(NULL, inode, &map, 0);		if (err <= 0 || !(map.m_flags & EXT4_MAP_MAPPED))			return true;	} 	return false;} static ssize_t ext4_generic_write_checks(struct kiocb *iocb,					 struct iov_iter *from){	struct inode *inode = file_inode(iocb->ki_filp);	ssize_t ret; 	if (unlikely(IS_IMMUTABLE(inode)))		return -EPERM; 	ret = generic_write_checks(iocb, from);	if (ret <= 0)		return ret; 	/*	 * If we have encountered a bitmap-format file, the size limit	 * is smaller than s_maxbytes, which is for extent-mapped files.	 */	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 		if (iocb->ki_pos >= sbi->s_bitmap_maxbytes)			return -EFBIG;		iov_iter_truncate(from, sbi->s_bitmap_maxbytes - iocb->ki_pos);	} 	return iov_iter_count(from);} static ssize_t ext4_write_checks(struct kiocb *iocb, struct iov_iter *from){	struct inode *inode = file_inode(iocb->ki_filp);	loff_t old_size = i_size_read(inode);	ssize_t ret, count; 	count = ext4_generic_write_checks(iocb, from);	if (count <= 0)		return count; 	ret = kiocb_modified(iocb);	if (ret)		return ret; 	/*	 * If the position is beyond the EOF, it is necessary to zero out the	 * partial block that beyond the existing EOF, as it may contains	 * stale data written through mmap.	 */	if (iocb->ki_pos > old_size && !ext4_verity_in_progress(inode)) {		if (iocb->ki_flags & IOCB_NOWAIT)			return -EAGAIN; 		ret = ext4_block_zero_eof(inode, old_size, iocb->ki_pos);		if (ret)			return ret;	} 	return count;} static ssize_t ext4_buffered_write_iter(struct kiocb *iocb,					struct iov_iter *from){	ssize_t ret;	struct inode *inode = file_inode(iocb->ki_filp); 	if (iocb->ki_flags & IOCB_NOWAIT)		return -EOPNOTSUPP; 	inode_lock(inode); 	/*	 * Prevent concurrent direct I/O and buffered I/O to the same file	 * range. Wait for in-flight DIO to finish before dirtying pages.	 */	inode_dio_wait(inode); 	ret = ext4_write_checks(iocb, from);	if (ret <= 0)		goto out; 	ret = generic_perform_write(iocb, from); out:	inode_unlock(inode);	if (unlikely(ret <= 0))		return ret;	return generic_write_sync(iocb, ret);} static ssize_t ext4_handle_inode_extension(struct inode *inode, loff_t offset,					   ssize_t written, ssize_t count){	handle_t *handle; 	lockdep_assert_held_write(&inode->i_rwsem);	handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);	if (IS_ERR(handle))		return PTR_ERR(handle); 	if (ext4_update_inode_size(inode, offset + written)) {		int ret = ext4_mark_inode_dirty(handle, inode);		if (unlikely(ret)) {			ext4_journal_stop(handle);			return ret;		}	} 	if ((written == count) && inode->i_nlink)		ext4_orphan_del(handle, inode);	ext4_journal_stop(handle); 	return written;} /* * Clean up the inode after DIO or DAX extending write has completed and the * inode size has been updated using ext4_handle_inode_extension(). */static void ext4_inode_extension_cleanup(struct inode *inode, bool need_trunc){	lockdep_assert_held_write(&inode->i_rwsem);	if (need_trunc) {		ext4_truncate_failed_write(inode);		/*		 * If the truncate operation failed early, then the inode may		 * still be on the orphan list. In that case, we need to try		 * remove the inode from the in-memory linked list.		 */		if (inode->i_nlink)			ext4_orphan_del(NULL, inode);		return;	}	/*	 * If i_disksize got extended either due to writeback of delalloc	 * blocks or extending truncate while the DIO was running we could fail	 * to cleanup the orphan list in ext4_handle_inode_extension(). Do it	 * now.	 */	if (ext4_inode_orphan_tracked(inode) && inode->i_nlink) {		handle_t *handle = ext4_journal_start(inode, EXT4_HT_INODE, 2); 		if (IS_ERR(handle)) {			/*			 * The write has successfully completed. Not much to			 * do with the error here so just cleanup the orphan			 * list and hope for the best.			 */			ext4_orphan_del(NULL, inode);			return;		}		ext4_orphan_del(handle, inode);		ext4_journal_stop(handle);	}} static int ext4_dio_write_end_io(struct kiocb *iocb, ssize_t size,				 int error, unsigned int flags){	loff_t pos = iocb->ki_pos;	struct inode *inode = file_inode(iocb->ki_filp);  	if (!error && size && (flags & IOMAP_DIO_UNWRITTEN) &&			(iocb->ki_flags & IOCB_ATOMIC))		error = ext4_convert_unwritten_extents_atomic(NULL, inode, pos,							      size);	else if (!error && size && flags & IOMAP_DIO_UNWRITTEN)		error = ext4_convert_unwritten_extents(NULL, inode, pos, size,						       NULL);	if (error)		return error;	/*	 * Note that EXT4_I(inode)->i_disksize can get extended up to	 * inode->i_size while the I/O was running due to writeback of delalloc	 * blocks. But the code in ext4_iomap_alloc() is careful to use	 * zeroed/unwritten extents if this is possible; thus we won't leave	 * uninitialized blocks in a file even if we didn't succeed in writing	 * as much as we intended. Also we can race with truncate or write	 * expanding the file so we have to be a bit careful here.	 */	if (pos + size <= READ_ONCE(EXT4_I(inode)->i_disksize) &&	    pos + size <= i_size_read(inode))		return 0;	error = ext4_handle_inode_extension(inode, pos, size, size);	return error < 0 ? error : 0;} static const struct iomap_dio_ops ext4_dio_write_ops = {	.end_io = ext4_dio_write_end_io,}; /* * The intention here is to start with shared lock acquired then see if any * condition requires an exclusive inode lock. If yes, then we restart the * whole operation by releasing the shared lock and acquiring exclusive lock. * * The decision is layered, evaluated in this order: * * 1. If kiocb_modified() needs to update security info (!IS_NOSEC), upgrade *    to the exclusive lock -- the security update itself requires it, *    regardless of whether the write extends the file or is aligned. * * 2. If the write extends i_size or i_disksize, upgrade to the exclusive *    lock to safely update i_disksize and the orphan list, regardless of *    alignment. * * 3. Otherwise, for aligned non-extending writes, shared lock is always *    sufficient regardless of extent state (written, unwritten, or hole). *    truncate/punch_hole cannot run while we hold the shared i_rwsem *    (they need it exclusively); after we release it, inode_dio_begin() *    keeps their inode_dio_wait() blocked until in-flight bios complete. *    i_data_sem serializes concurrent extent tree modifications. * * 4. Otherwise, the write is unaligned and non-extending. Shared lock is *    safe unless the DIO layer needs to perform partial block zeroing -- *    i.e. the head or tail partial block sits on a hole or unwritten *    extent. In that case upgrade to the exclusive lock and drain *    in-flight DIO to avoid races with concurrent partial block zeroing. */static ssize_t ext4_dio_write_checks(struct kiocb *iocb, struct iov_iter *from,				     bool *ilock_shared, bool *extend,				     int *dio_flags){	struct file *file = iocb->ki_filp;	struct inode *inode = file_inode(file);	loff_t offset;	size_t count;

Lines 1–500 of 1068. Load more