]>
git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - fs/nfs/io.c
1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2016 Trond Myklebust
5 * I/O and data path helper functionality.
8 #include <linux/types.h>
9 #include <linux/kernel.h>
10 #include <linux/bitops.h>
11 #include <linux/rwsem.h>
13 #include <linux/nfs_fs.h>
17 /* Call with exclusively locked inode->i_rwsem */
18 static void nfs_block_o_direct(struct nfs_inode
*nfsi
, struct inode
*inode
)
20 if (test_bit(NFS_INO_ODIRECT
, &nfsi
->flags
)) {
21 clear_bit(NFS_INO_ODIRECT
, &nfsi
->flags
);
22 inode_dio_wait(inode
);
27 * nfs_start_io_read - declare the file is being used for buffered reads
30 * Declare that a buffered read operation is about to start, and ensure
31 * that we block all direct I/O.
32 * On exit, the function ensures that the NFS_INO_ODIRECT flag is unset,
33 * and holds a shared lock on inode->i_rwsem to ensure that the flag
35 * In practice, this means that buffered read operations are allowed to
36 * execute in parallel, thanks to the shared lock, whereas direct I/O
37 * operations need to wait to grab an exclusive lock in order to set
39 * Note that buffered writes and truncates both take a write lock on
40 * inode->i_rwsem, meaning that those are serialised w.r.t. the reads.
43 nfs_start_io_read(struct inode
*inode
)
45 struct nfs_inode
*nfsi
= NFS_I(inode
);
47 down_read(&inode
->i_rwsem
);
48 if (test_bit(NFS_INO_ODIRECT
, &nfsi
->flags
) == 0)
50 up_read(&inode
->i_rwsem
);
52 down_write(&inode
->i_rwsem
);
53 nfs_block_o_direct(nfsi
, inode
);
54 downgrade_write(&inode
->i_rwsem
);
58 * nfs_end_io_read - declare that the buffered read operation is done
61 * Declare that a buffered read operation is done, and release the shared
62 * lock on inode->i_rwsem.
65 nfs_end_io_read(struct inode
*inode
)
67 up_read(&inode
->i_rwsem
);
71 * nfs_start_io_write - declare the file is being used for buffered writes
74 * Declare that a buffered read operation is about to start, and ensure
75 * that we block all direct I/O.
78 nfs_start_io_write(struct inode
*inode
)
80 down_write(&inode
->i_rwsem
);
81 nfs_block_o_direct(NFS_I(inode
), inode
);
85 * nfs_end_io_write - declare that the buffered write operation is done
88 * Declare that a buffered write operation is done, and release the
89 * lock on inode->i_rwsem.
92 nfs_end_io_write(struct inode
*inode
)
94 up_write(&inode
->i_rwsem
);
97 /* Call with exclusively locked inode->i_rwsem */
98 static void nfs_block_buffered(struct nfs_inode
*nfsi
, struct inode
*inode
)
100 if (!test_bit(NFS_INO_ODIRECT
, &nfsi
->flags
)) {
101 set_bit(NFS_INO_ODIRECT
, &nfsi
->flags
);
102 nfs_sync_mapping(inode
->i_mapping
);
107 * nfs_end_io_direct - declare the file is being used for direct i/o
110 * Declare that a direct I/O operation is about to start, and ensure
111 * that we block all buffered I/O.
112 * On exit, the function ensures that the NFS_INO_ODIRECT flag is set,
113 * and holds a shared lock on inode->i_rwsem to ensure that the flag
115 * In practice, this means that direct I/O operations are allowed to
116 * execute in parallel, thanks to the shared lock, whereas buffered I/O
117 * operations need to wait to grab an exclusive lock in order to clear
119 * Note that buffered writes and truncates both take a write lock on
120 * inode->i_rwsem, meaning that those are serialised w.r.t. O_DIRECT.
123 nfs_start_io_direct(struct inode
*inode
)
125 struct nfs_inode
*nfsi
= NFS_I(inode
);
126 /* Be an optimist! */
127 down_read(&inode
->i_rwsem
);
128 if (test_bit(NFS_INO_ODIRECT
, &nfsi
->flags
) != 0)
130 up_read(&inode
->i_rwsem
);
132 down_write(&inode
->i_rwsem
);
133 nfs_block_buffered(nfsi
, inode
);
134 downgrade_write(&inode
->i_rwsem
);
138 * nfs_end_io_direct - declare that the direct i/o operation is done
141 * Declare that a direct I/O operation is done, and release the shared
142 * lock on inode->i_rwsem.
145 nfs_end_io_direct(struct inode
*inode
)
147 up_read(&inode
->i_rwsem
);