-
Notifications
You must be signed in to change notification settings - Fork 1.7k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Adding O_DIRECT support to ZFS to bypass the ARC for writes/reads.
O_DIRECT support in ZFS will always ensure there is coherency between
buffered and O_DIRECT IO requests. This ensures that all IO requests,
whether buffered or direct, will see the same file contents at all
times. Just as in other FS's , O_DIRECT does not imply O_SYNC. While
data is written directly to VDEV disks, metadata will not be synced
until the associated TXG is synced.
For both O_DIRECT read and write request the offset and requeset sizes,
at a minimum, must be PAGE_SIZE aligned. In the event they are not,
then EINVAL is returned unless the direct property is set to always (see
below).
For O_DIRECT writes:
The request also must be block aligned (recordsize) or the write
request will take the normal (buffered) write path. In the event that
request is block aligned and a cached copy of the buffer in the ARC,
then it will be discarded from the ARC forcing all further reads to
retrieve the data from disk.
For O_DIRECT reads:
The only alignment restrictions are PAGE_SIZE alignment. In the event
that the requested data is in buffered (in the ARC) it will just be
copied from the ARC into the user buffer.
For both O_DIRECT writes and reads the O_DIRECT flag will be ignored in
the event that file contents are mmap'ed. In this case, all requests
that are at least PAGE_SIZE aligned will just fall back to the buffered
paths. If the request however is not PAGE_SIZE aligned, EINVAL will
be returned as always regardless if the file's contents are mmap'ed.
Since O_DIRECT writes go through the normal ZIO pipeline, the
following operations are supported just as with normal buffered writes:
Checksum
Compression
Dedup
Encryption
Erasure Coding
There is one caveat for the data integrity of O_DIRECT writes that is
distinct for each of the OS's supported by ZFS.
FreeBSD - FreeBSD is able to place user pages under write protection so
any data in the user buffers and written directly down to the
VDEV disks is guaranteed to not change. There is no concern
with data integrity and O_DIRECT writes.
Linux - Linux is not able to place anonymous user pages under write
protection. Because of this, if the user decides to manipulate
the page contents while the write operation is occurring, data
integrity can not be guaranteed. However, there is a module
parameter `zfs_vdev_direct_write_verify_pct` that contols the
percentage of O_DIRECT writes that can occur to a top-level
VDEV before a checksum verify is run before the contents of the
user buffers are committed to disk. In the event of a checksum
verification failure the write will be redirected through the
ARC. The deafault value for `zfs_vdev_direct_write_verify_pct`
is 2 percent of Direct I/O writes to a top-level VDEV. The
number of O_DIRECT write checksum verification errors can be
observed by doing `zpool status -d`, which will list all
verification errors that have occurred on a top-level VDEV.
Along with `zpool status`, a ZED event will be issues as
`dio_verify` when a checksum verification error occurs.
A new dataset property `direct` has been added with the following 3
allowable values:
disabled - Accepts O_DIRECT flag, but silently ignores it and treats
the request as a buffered IO request.
standard - Follows the alignment restrictions outlined above for
write/read IO requests when the O_DIRECT flag is used.
always - Treats every write/read IO request as though it passed
O_DIRECT and will do O_DIRECT if the alignment restrictions
are met otherwise will redirect through the ARC. This
property will not allow a request to fail.
Signed-off-by: Brian Atkinson <[email protected]>
Co-authored-by: Mark Maybee <[email protected]>
Co-authored-by: Matt Macy <[email protected]>
Co-authored-by: Brian Behlendorf <[email protected]>- Loading branch information
4 people
committed
Apr 22, 2024
1 parent
f4f1561
commit e4f9167
Showing
110 changed files
with
9,712 additions
and
7,316 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
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,179 @@ | ||
| dnl # | ||
| dnl # get_user_pages_unlocked() function was not available till 4.0. | ||
| dnl # In earlier kernels (< 4.0) get_user_pages() is available(). | ||
| dnl # | ||
| dnl # 4.0 API change, | ||
| dnl # long get_user_pages_unlocked(struct task_struct *tsk, | ||
| dnl # struct mm_struct *mm, unsigned long start, unsigned long nr_pages, | ||
| dnl # int write, int force, struct page **pages) | ||
| dnl # | ||
| dnl # 4.8 API change, | ||
| dnl # long get_user_pages_unlocked(unsigned long start, | ||
| dnl # unsigned long nr_pages, int write, int force, struct page **page) | ||
| dnl # | ||
| dnl # 4.9 API change, | ||
| dnl # long get_user_pages_unlocked(usigned long start, int nr_pages, | ||
| dnl # struct page **pages, unsigned int gup_flags) | ||
| dnl # | ||
|
|
||
| dnl# | ||
| dnl# Check available get_user_pages/_unlocked interfaces. | ||
| dnl# | ||
| AC_DEFUN([ZFS_AC_KERNEL_SRC_GET_USER_PAGES], [ | ||
| ZFS_LINUX_TEST_SRC([get_user_pages_unlocked_gup_flags], [ | ||
| #include <linux/mm.h> | ||
| ], [ | ||
| unsigned long start = 0; | ||
| unsigned long nr_pages = 1; | ||
| unsigned int gup_flags = 0; | ||
| struct page **pages = NULL; | ||
| long ret __attribute__ ((unused)); | ||
| ret = get_user_pages_unlocked(start, nr_pages, pages, | ||
| gup_flags); | ||
| ]) | ||
| ZFS_LINUX_TEST_SRC([get_user_pages_unlocked_write_flag], [ | ||
| #include <linux/mm.h> | ||
| ], [ | ||
| unsigned long start = 0; | ||
| unsigned long nr_pages = 1; | ||
| int write = 0; | ||
| int force = 0; | ||
| long ret __attribute__ ((unused)); | ||
| struct page **pages = NULL; | ||
| ret = get_user_pages_unlocked(start, nr_pages, write, force, | ||
| pages); | ||
| ]) | ||
| ZFS_LINUX_TEST_SRC([get_user_pages_unlocked_task_struct], [ | ||
| #include <linux/mm.h> | ||
| ], [ | ||
| struct task_struct *tsk = NULL; | ||
| struct mm_struct *mm = NULL; | ||
| unsigned long start = 0; | ||
| unsigned long nr_pages = 1; | ||
| int write = 0; | ||
| int force = 0; | ||
| struct page **pages = NULL; | ||
| long ret __attribute__ ((unused)); | ||
| ret = get_user_pages_unlocked(tsk, mm, start, nr_pages, write, | ||
| force, pages); | ||
| ]) | ||
| ZFS_LINUX_TEST_SRC([get_user_pages_unlocked_task_struct_gup_flags], [ | ||
| #include <linux/mm.h> | ||
| ], [ | ||
| struct task_struct *tsk = NULL; | ||
| struct mm_struct *mm = NULL; | ||
| unsigned long start = 0; | ||
| unsigned long nr_pages = 1; | ||
| struct page **pages = NULL; | ||
| unsigned int gup_flags = 0; | ||
| long ret __attribute__ ((unused)); | ||
| ret = get_user_pages_unlocked(tsk, mm, start, nr_pages, | ||
| pages, gup_flags); | ||
| ]) | ||
| ZFS_LINUX_TEST_SRC([get_user_pages_task_struct], [ | ||
| #include <linux/mm.h> | ||
| ], [ | ||
| struct task_struct *tsk = NULL; | ||
| struct mm_struct *mm = NULL; | ||
| struct vm_area_struct **vmas = NULL; | ||
| unsigned long start = 0; | ||
| unsigned long nr_pages = 1; | ||
| int write = 0; | ||
| int force = 0; | ||
| struct page **pages = NULL; | ||
| int ret __attribute__ ((unused)); | ||
| ret = get_user_pages(tsk, mm, start, nr_pages, write, | ||
| force, pages, vmas); | ||
| ]) | ||
| ]) | ||
|
|
||
| dnl # | ||
| dnl # Supported get_user_pages/_unlocked interfaces checked newest to oldest. | ||
| dnl # We first check for get_user_pages_unlocked as that is available in | ||
| dnl # newer kernels. | ||
| dnl # | ||
| AC_DEFUN([ZFS_AC_KERNEL_GET_USER_PAGES], [ | ||
| dnl # | ||
| dnl # Current API (as of 4.9) of get_user_pages_unlocked | ||
| dnl # | ||
| AC_MSG_CHECKING([whether get_user_pages_unlocked() takes gup flags]) | ||
| ZFS_LINUX_TEST_RESULT([get_user_pages_unlocked_gup_flags], [ | ||
| AC_MSG_RESULT(yes) | ||
| AC_DEFINE(HAVE_GET_USER_PAGES_UNLOCKED_GUP_FLAGS, 1, | ||
| [get_user_pages_unlocked() takes gup flags]) | ||
| ], [ | ||
| AC_MSG_RESULT(no) | ||
| dnl # | ||
| dnl # 4.8 API change, get_user_pages_unlocked | ||
| dnl # | ||
| AC_MSG_CHECKING( | ||
| [whether get_user_pages_unlocked() takes write flag]) | ||
| ZFS_LINUX_TEST_RESULT([get_user_pages_unlocked_write_flag], [ | ||
| AC_MSG_RESULT(yes) | ||
| AC_DEFINE(HAVE_GET_USER_PAGES_UNLOCKED_WRITE_FLAG, 1, | ||
| [get_user_pages_unlocked() takes write flag]) | ||
| ], [ | ||
| AC_MSG_RESULT(no) | ||
| dnl # | ||
| dnl # 4.0-4.3, 4.5-4.7 API, get_user_pages_unlocked | ||
| dnl # | ||
| AC_MSG_CHECKING( | ||
| [whether get_user_pages_unlocked() takes task_struct]) | ||
| ZFS_LINUX_TEST_RESULT( | ||
| [get_user_pages_unlocked_task_struct], [ | ||
| AC_MSG_RESULT(yes) | ||
| AC_DEFINE( | ||
| HAVE_GET_USER_PAGES_UNLOCKED_TASK_STRUCT, 1, | ||
| [get_user_pages_unlocked() takes task_struct]) | ||
| ], [ | ||
| AC_MSG_RESULT(no) | ||
| dnl # | ||
| dnl # 4.4 API, get_user_pages_unlocked | ||
| dnl # | ||
| AC_MSG_CHECKING( | ||
| [whether get_user_pages_unlocked() takes task_struct, gup_flags]) | ||
| ZFS_LINUX_TEST_RESULT( | ||
| [get_user_pages_unlocked_task_struct_gup_flags], [ | ||
| AC_MSG_RESULT(yes) | ||
| AC_DEFINE( | ||
| HAVE_GET_USER_PAGES_UNLOCKED_TASK_STRUCT_GUP_FLAGS, 1, | ||
| [get_user_pages_unlocked() takes task_struct, gup_flags]) | ||
| ], [ | ||
| AC_MSG_RESULT(no) | ||
| dnl # | ||
| dnl # get_user_pages | ||
| dnl # | ||
| AC_MSG_CHECKING( | ||
| [whether get_user_pages() takes struct task_struct]) | ||
| ZFS_LINUX_TEST_RESULT( | ||
| [get_user_pages_task_struct], [ | ||
| AC_MSG_RESULT(yes) | ||
| AC_DEFINE( | ||
| HAVE_GET_USER_PAGES_TASK_STRUCT, 1, | ||
| [get_user_pages() takes task_struct]) | ||
| ], [ | ||
| dnl # | ||
| dnl # If we cannot map the user's | ||
| dnl # pages in then we cannot do | ||
| dnl # Direct I/O | ||
| dnl # | ||
| ZFS_LINUX_TEST_ERROR([Direct I/O]) | ||
| ]) | ||
| ]) | ||
| ]) | ||
| ]) | ||
| ]) | ||
| ]) |
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
Oops, something went wrong.