forked from microsoft/WSL2-Linux-Kernel
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
NFS: Do not serialise O_DIRECT reads and writes
Allow dio requests to be scheduled in parallel, but ensuring that they do not conflict with buffered I/O. Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com>
- Loading branch information
Showing
6 changed files
with
174 additions
and
37 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,147 @@ | ||
| /* | ||
| * Copyright (c) 2016 Trond Myklebust | ||
| * | ||
| * I/O and data path helper functionality. | ||
| */ | ||
|
|
||
| #include <linux/types.h> | ||
| #include <linux/kernel.h> | ||
| #include <linux/bitops.h> | ||
| #include <linux/rwsem.h> | ||
| #include <linux/fs.h> | ||
| #include <linux/nfs_fs.h> | ||
|
|
||
| #include "internal.h" | ||
|
|
||
| /* Call with exclusively locked inode->i_rwsem */ | ||
| static void nfs_block_o_direct(struct nfs_inode *nfsi, struct inode *inode) | ||
| { | ||
| if (test_bit(NFS_INO_ODIRECT, &nfsi->flags)) { | ||
| clear_bit(NFS_INO_ODIRECT, &nfsi->flags); | ||
| inode_dio_wait(inode); | ||
| } | ||
| } | ||
|
|
||
| /** | ||
| * nfs_start_io_read - declare the file is being used for buffered reads | ||
| * @inode - file inode | ||
| * | ||
| * Declare that a buffered read operation is about to start, and ensure | ||
| * that we block all direct I/O. | ||
| * On exit, the function ensures that the NFS_INO_ODIRECT flag is unset, | ||
| * and holds a shared lock on inode->i_rwsem to ensure that the flag | ||
| * cannot be changed. | ||
| * In practice, this means that buffered read operations are allowed to | ||
| * execute in parallel, thanks to the shared lock, whereas direct I/O | ||
| * operations need to wait to grab an exclusive lock in order to set | ||
| * NFS_INO_ODIRECT. | ||
| * Note that buffered writes and truncates both take a write lock on | ||
| * inode->i_rwsem, meaning that those are serialised w.r.t. the reads. | ||
| */ | ||
| void | ||
| nfs_start_io_read(struct inode *inode) | ||
| { | ||
| struct nfs_inode *nfsi = NFS_I(inode); | ||
| /* Be an optimist! */ | ||
| down_read(&inode->i_rwsem); | ||
| if (test_bit(NFS_INO_ODIRECT, &nfsi->flags) == 0) | ||
| return; | ||
| up_read(&inode->i_rwsem); | ||
| /* Slow path.... */ | ||
| down_write(&inode->i_rwsem); | ||
| nfs_block_o_direct(nfsi, inode); | ||
| downgrade_write(&inode->i_rwsem); | ||
| } | ||
|
|
||
| /** | ||
| * nfs_end_io_read - declare that the buffered read operation is done | ||
| * @inode - file inode | ||
| * | ||
| * Declare that a buffered read operation is done, and release the shared | ||
| * lock on inode->i_rwsem. | ||
| */ | ||
| void | ||
| nfs_end_io_read(struct inode *inode) | ||
| { | ||
| up_read(&inode->i_rwsem); | ||
| } | ||
|
|
||
| /** | ||
| * nfs_start_io_write - declare the file is being used for buffered writes | ||
| * @inode - file inode | ||
| * | ||
| * Declare that a buffered read operation is about to start, and ensure | ||
| * that we block all direct I/O. | ||
| */ | ||
| void | ||
| nfs_start_io_write(struct inode *inode) | ||
| { | ||
| down_write(&inode->i_rwsem); | ||
| nfs_block_o_direct(NFS_I(inode), inode); | ||
| } | ||
|
|
||
| /** | ||
| * nfs_end_io_write - declare that the buffered write operation is done | ||
| * @inode - file inode | ||
| * | ||
| * Declare that a buffered write operation is done, and release the | ||
| * lock on inode->i_rwsem. | ||
| */ | ||
| void | ||
| nfs_end_io_write(struct inode *inode) | ||
| { | ||
| up_write(&inode->i_rwsem); | ||
| } | ||
|
|
||
| /* Call with exclusively locked inode->i_rwsem */ | ||
| static void nfs_block_buffered(struct nfs_inode *nfsi, struct inode *inode) | ||
| { | ||
| if (!test_bit(NFS_INO_ODIRECT, &nfsi->flags)) { | ||
| set_bit(NFS_INO_ODIRECT, &nfsi->flags); | ||
| nfs_wb_all(inode); | ||
| } | ||
| } | ||
|
|
||
| /** | ||
| * nfs_end_io_direct - declare the file is being used for direct i/o | ||
| * @inode - file inode | ||
| * | ||
| * Declare that a direct I/O operation is about to start, and ensure | ||
| * that we block all buffered I/O. | ||
| * On exit, the function ensures that the NFS_INO_ODIRECT flag is set, | ||
| * and holds a shared lock on inode->i_rwsem to ensure that the flag | ||
| * cannot be changed. | ||
| * In practice, this means that direct I/O operations are allowed to | ||
| * execute in parallel, thanks to the shared lock, whereas buffered I/O | ||
| * operations need to wait to grab an exclusive lock in order to clear | ||
| * NFS_INO_ODIRECT. | ||
| * Note that buffered writes and truncates both take a write lock on | ||
| * inode->i_rwsem, meaning that those are serialised w.r.t. O_DIRECT. | ||
| */ | ||
| void | ||
| nfs_start_io_direct(struct inode *inode) | ||
| { | ||
| struct nfs_inode *nfsi = NFS_I(inode); | ||
| /* Be an optimist! */ | ||
| down_read(&inode->i_rwsem); | ||
| if (test_bit(NFS_INO_ODIRECT, &nfsi->flags) != 0) | ||
| return; | ||
| up_read(&inode->i_rwsem); | ||
| /* Slow path.... */ | ||
| down_write(&inode->i_rwsem); | ||
| nfs_block_buffered(nfsi, inode); | ||
| downgrade_write(&inode->i_rwsem); | ||
| } | ||
|
|
||
| /** | ||
| * nfs_end_io_direct - declare that the direct i/o operation is done | ||
| * @inode - file inode | ||
| * | ||
| * Declare that a direct I/O operation is done, and release the shared | ||
| * lock on inode->i_rwsem. | ||
| */ | ||
| void | ||
| nfs_end_io_direct(struct inode *inode) | ||
| { | ||
| up_read(&inode->i_rwsem); | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters