| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-Id: <20191009063950.604C042047@d06av24.portsmouth.uk.ibm.com>
Date: Wed, 9 Oct 2019 12:09:49 +0530
From: Ritesh Harjani <riteshh@...ux.ibm.com>
To: Matthew Bobrowski <mbobrowski@...browski.org>, tytso@....edu,
jack@...e.cz, adilger.kernel@...ger.ca
Cc: linux-ext4@...r.kernel.org, linux-fsdevel@...r.kernel.org,
hch@...radead.org, david@...morbit.com, darrick.wong@...cle.com
Subject: Re: [PATCH v4 4/8] ext4: introduce direct I/O read path using iomap
infrastructure
On 10/3/19 5:04 PM, Matthew Bobrowski wrote:
> This patch introduces a new direct I/O read path that makes use of the
> iomap infrastructure.
>
> The new function ext4_dio_read_iter() is responsible for calling into
> the iomap infrastructure via iomap_dio_rw(). If the read operation
> being performed on the inode does not pass the preliminary checks
> performed within ext4_dio_supported(), then we simply fallback to
> buffered I/O in order to fulfil the request.
>
> Existing direct I/O read buffer_head code has been removed as it's now
> redundant.
>
> Signed-off-by: Matthew Bobrowski <mbobrowski@...browski.org>
> ---
> fs/ext4/file.c | 58 +++++++++++++++++++++++++++++++++++++++++++++----
> fs/ext4/inode.c | 32 +--------------------------
> 2 files changed, 55 insertions(+), 35 deletions(-)
>
> diff --git a/fs/ext4/file.c b/fs/ext4/file.c
> index ab75aee3e687..69ac042fb74b 100644
> --- a/fs/ext4/file.c
> +++ b/fs/ext4/file.c
> @@ -34,6 +34,53 @@
> #include "xattr.h"
> #include "acl.h"
>
> +static bool ext4_dio_supported(struct inode *inode)
> +{
> + if (IS_ENABLED(CONFIG_FS_ENCRYPTION) && IS_ENCRYPTED(inode))
> + return false;
> + if (fsverity_active(inode))
> + return false;
> + if (ext4_should_journal_data(inode))
> + return false;
> + if (ext4_has_inline_data(inode))
> + return false;
> + return true;
> +}
> +
> +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);
> +
> + /*
> + * Get exclusion from truncate and other inode operations.
> + */
> + if (!inode_trylock_shared(inode)) {
> + if (iocb->ki_flags & IOCB_NOWAIT)
> + return -EAGAIN;
> + inode_lock_shared(inode);
> + }
Same comments here.
Let's follow as per the discussion here
https://patchwork.kernel.org/patch/11141577/
> +
> + if (!ext4_dio_supported(inode)) {
> + 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 withiin
> + * generic_file_read_iter() is not taken.
> + */
> + iocb->ki_flags &= ~IOCB_DIRECT;
> + return generic_file_read_iter(iocb, to);
> + }
> +
> + ret = iomap_dio_rw(iocb, to, &ext4_iomap_ops, NULL);
> + inode_unlock_shared(inode);
> +
> + file_accessed(iocb->ki_filp);
> + return ret;
> +}
> +
> #ifdef CONFIG_FS_DAX
> static ssize_t ext4_dax_read_iter(struct kiocb *iocb, struct iov_iter *to)
> {
> @@ -64,16 +111,19 @@ static ssize_t ext4_dax_read_iter(struct kiocb *iocb, struct iov_iter *to)
>
> static ssize_t ext4_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
> {
> - if (unlikely(ext4_forced_shutdown(EXT4_SB(file_inode(iocb->ki_filp)->i_sb))))
> + struct inode *inode = file_inode(iocb->ki_filp);
> +
> + if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
> return -EIO;
>
> if (!iov_iter_count(to))
> return 0; /* skip atime */
>
> -#ifdef CONFIG_FS_DAX
> - if (IS_DAX(file_inode(iocb->ki_filp)))
> + 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);
> }
>
> diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
> index 1dace576b8bd..159ffb92f82d 100644
> --- a/fs/ext4/inode.c
> +++ b/fs/ext4/inode.c
> @@ -863,9 +863,6 @@ int ext4_dio_get_block(struct inode *inode, sector_t iblock,
> {
> /* We don't expect handle for direct IO */
> WARN_ON_ONCE(ext4_journal_current_handle());
> -
> - if (!create)
> - return _ext4_get_block(inode, iblock, bh, 0);
> return ext4_get_block_trans(inode, iblock, bh, EXT4_GET_BLOCKS_CREATE);
> }
>
> @@ -3855,30 +3852,6 @@ static ssize_t ext4_direct_IO_write(struct kiocb *iocb, struct iov_iter *iter)
> return ret;
> }
>
> -static ssize_t ext4_direct_IO_read(struct kiocb *iocb, struct iov_iter *iter)
> -{
> - struct address_space *mapping = iocb->ki_filp->f_mapping;
> - struct inode *inode = mapping->host;
> - size_t count = iov_iter_count(iter);
> - ssize_t ret;
> -
> - /*
> - * Shared inode_lock is enough for us - it protects against concurrent
> - * writes & truncates and since we take care of writing back page cache,
> - * we are protected against page writeback as well.
> - */
> - inode_lock_shared(inode);
> - ret = filemap_write_and_wait_range(mapping, iocb->ki_pos,
> - iocb->ki_pos + count - 1);
> - if (ret)
> - goto out_unlock;
> - ret = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev,
> - iter, ext4_dio_get_block, NULL, NULL, 0);
> -out_unlock:
> - inode_unlock_shared(inode);
> - return ret;
> -}
> -
> static ssize_t ext4_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
> {
> struct file *file = iocb->ki_filp;
> @@ -3905,10 +3878,7 @@ static ssize_t ext4_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
> return 0;
>
> trace_ext4_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
> - if (iov_iter_rw(iter) == READ)
> - ret = ext4_direct_IO_read(iocb, iter);
> - else
> - ret = ext4_direct_IO_write(iocb, iter);
> + ret = ext4_direct_IO_write(iocb, iter);
> trace_ext4_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), ret);
> return ret;
> }
>
Powered by blists - more mailing lists