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 request 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
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` that controls the
if a O_DIRECT writes that can occur to a top-level VDEV before
a checksum verify is run before the contents of the I/O buffer
are committed to disk. In the event of a checksum verification
failure the write will return EIO. 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.
ZVOLs and dedup is not currently supported with Direct I/O.
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.
There is also a module parameter zfs_dio_enabled that can be used to
force all reads and writes through the ARC. By setting this module
parameter to 0, it mimics as if the direct dataset property is set to
disabled.
Reviewed-by: Brian Behlendorf <behlendorf@llnl.gov>
Reviewed-by: Alexander Motin <mav@FreeBSD.org>
Reviewed-by: Tony Hutter <hutter2@llnl.gov>
Signed-off-by: Brian Atkinson <batkinson@lanl.gov>
Co-authored-by: Mark Maybee <mark.maybee@delphix.com>
Co-authored-by: Matt Macy <mmacy@FreeBSD.org>
Co-authored-by: Brian Behlendorf <behlendorf@llnl.gov>
Closes #10018
return (gettext("\tstatus [--power] [-j [--json-int, "
"--json-flat-vdevs, ...\n"
"\t --json-pool-key-guid]] [-c [script1,script2,...]] "
- "[-DegiLpPstvx] ...\n"
+ "[-dDegiLpPstvx] ...\n"
"\t [-T d|u] [pool] [interval [count]]\n"));
case HELP_UPGRADE:
return (gettext("\tupgrade\n"
boolean_t cb_print_unhealthy;
boolean_t cb_print_status;
boolean_t cb_print_slow_ios;
+ boolean_t cb_print_dio_verify;
boolean_t cb_print_vdev_init;
boolean_t cb_print_vdev_trim;
vdev_cmd_data_list_t *vcdl;
uint_t c, i, vsc, children;
pool_scan_stat_t *ps = NULL;
vdev_stat_t *vs;
- char rbuf[6], wbuf[6], cbuf[6];
+ char rbuf[6], wbuf[6], cbuf[6], dbuf[6];
char *vname;
uint64_t notpresent;
spare_cbdata_t spare_cb;
printf(" %5s", "-");
}
}
+ if (VDEV_STAT_VALID(vs_dio_verify_errors, vsc) &&
+ cb->cb_print_dio_verify) {
+ zfs_nicenum(vs->vs_dio_verify_errors, dbuf,
+ sizeof (dbuf));
+
+ if (cb->cb_literal)
+ printf(" %5llu",
+ (u_longlong_t)vs->vs_dio_verify_errors);
+ else
+ printf(" %5s", dbuf);
+ }
}
if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT,
printf_color(ANSI_BOLD, " %5s", gettext("POWER"));
}
+ if (cbp->cb_print_dio_verify) {
+ printf_color(ANSI_BOLD, " %5s", gettext("DIO"));
+ }
+
if (cbp->vcdl != NULL)
print_cmd_columns(cbp->vcdl, 0);
}
/*
- * zpool status [-c [script1,script2,...]] [-DegiLpPstvx] [--power] [-T d|u] ...
- * [pool] [interval [count]]
+ * zpool status [-c [script1,script2,...]] [-dDegiLpPstvx] [--power] ...
+ * [-T d|u] [pool] [interval [count]]
*
* -c CMD For each vdev, run command CMD
+ * -d Display Direct I/O write verify errors
* -D Display dedup status (undocumented)
* -e Display only unhealthy vdevs
* -g Display guid for individual vdev name.
};
/* check options */
- while ((c = getopt_long(argc, argv, "c:jDegiLpPstT:vx", long_options,
+ while ((c = getopt_long(argc, argv, "c:jdDegiLpPstT:vx", long_options,
NULL)) != -1) {
switch (c) {
case 'c':
}
cmd = optarg;
break;
+ case 'd':
+ cb.cb_print_dio_verify = B_TRUE;
+ break;
case 'D':
if (++cb.cb_dedup_stats > 2)
cb.cb_dedup_stats = 2;
if (ztest_random(4) != 0) {
int prefetch = ztest_random(2) ?
DMU_READ_PREFETCH : DMU_READ_NO_PREFETCH;
+
+ /*
+ * We will randomly set when to do O_DIRECT on a read.
+ */
+ if (ztest_random(4) == 0)
+ prefetch |= DMU_DIRECTIO;
+
ztest_block_tag_t rbt;
VERIFY(dmu_read(os, lr->lr_foid, offset,
enum ztest_io_type io_type;
uint64_t blocksize;
void *data;
+ uint32_t dmu_read_flags = DMU_READ_NO_PREFETCH;
+
+ /*
+ * We will randomly set when to do O_DIRECT on a read.
+ */
+ if (ztest_random(4) == 0)
+ dmu_read_flags |= DMU_DIRECTIO;
VERIFY0(dmu_object_info(zd->zd_os, object, &doi));
blocksize = doi.doi_data_block_size;
(void) pthread_rwlock_unlock(&ztest_name_lock);
VERIFY0(dmu_read(zd->zd_os, object, offset, blocksize, data,
- DMU_READ_NO_PREFETCH));
+ dmu_read_flags));
(void) ztest_write(zd, object, offset, blocksize, data);
break;
uint64_t stride = 123456789ULL;
uint64_t width = 40;
int free_percent = 5;
+ uint32_t dmu_read_flags = DMU_READ_PREFETCH;
+
+ /*
+ * We will randomly set when to do O_DIRECT on a read.
+ */
+ if (ztest_random(4) == 0)
+ dmu_read_flags |= DMU_DIRECTIO;
/*
* This test uses two objects, packobj and bigobj, that are always
* Read the current contents of our objects.
*/
error = dmu_read(os, packobj, packoff, packsize, packbuf,
- DMU_READ_PREFETCH);
+ dmu_read_flags);
ASSERT0(error);
error = dmu_read(os, bigobj, bigoff, bigsize, bigbuf,
- DMU_READ_PREFETCH);
+ dmu_read_flags);
ASSERT0(error);
/*
void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL);
VERIFY0(dmu_read(os, packobj, packoff,
- packsize, packcheck, DMU_READ_PREFETCH));
+ packsize, packcheck, dmu_read_flags));
VERIFY0(dmu_read(os, bigobj, bigoff,
- bigsize, bigcheck, DMU_READ_PREFETCH));
+ bigsize, bigcheck, dmu_read_flags));
ASSERT0(memcmp(packbuf, packcheck, packsize));
ASSERT0(memcmp(bigbuf, bigcheck, bigsize));
dmu_buf_t *bonus_db;
arc_buf_t **bigbuf_arcbufs;
dmu_object_info_t doi;
+ uint32_t dmu_read_flags = DMU_READ_PREFETCH;
+
+ /*
+ * We will randomly set when to do O_DIRECT on a read.
+ */
+ if (ztest_random(4) == 0)
+ dmu_read_flags |= DMU_DIRECTIO;
size = sizeof (ztest_od_t) * OD_ARRAY_SIZE;
od = umem_alloc(size, UMEM_NOFAIL);
*/
if (i != 0 || ztest_random(2) != 0) {
error = dmu_read(os, packobj, packoff,
- packsize, packbuf, DMU_READ_PREFETCH);
+ packsize, packbuf, dmu_read_flags);
ASSERT0(error);
error = dmu_read(os, bigobj, bigoff, bigsize,
- bigbuf, DMU_READ_PREFETCH);
+ bigbuf, dmu_read_flags);
ASSERT0(error);
}
compare_and_update_pbbufs(s, packbuf, bigbuf, bigsize,
void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL);
VERIFY0(dmu_read(os, packobj, packoff,
- packsize, packcheck, DMU_READ_PREFETCH));
+ packsize, packcheck, dmu_read_flags));
VERIFY0(dmu_read(os, bigobj, bigoff,
- bigsize, bigcheck, DMU_READ_PREFETCH));
+ bigsize, bigcheck, dmu_read_flags));
ASSERT0(memcmp(packbuf, packcheck, packsize));
ASSERT0(memcmp(bigbuf, bigcheck, bigsize));
--- /dev/null
+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])
+ ])
+ ])
+ ])
+ ])
+ ])
+])
dnl #
-dnl # Check for direct IO interfaces.
+dnl # Check for Direct I/O interfaces.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_VFS_DIRECT_IO], [
ZFS_LINUX_TEST_SRC([direct_io_iter], [
AC_DEFINE(HAVE_VFS_DIRECT_IO_IOVEC, 1,
[aops->direct_IO() uses iovec])
],[
- ZFS_LINUX_TEST_ERROR([direct IO])
+ ZFS_LINUX_TEST_ERROR([Direct I/O])
AC_MSG_RESULT([no])
])
])
bytes = copy_from_iter((void *)&buf, size, &iter);
])
+ ZFS_LINUX_TEST_SRC([iov_iter_get_pages2], [
+ #include <linux/uio.h>
+ ], [
+ struct iov_iter iter = { 0 };
+ struct page **pages = NULL;
+ size_t maxsize = 4096;
+ unsigned maxpages = 1;
+ size_t start;
+ size_t ret __attribute__ ((unused));
+
+ ret = iov_iter_get_pages2(&iter, pages, maxsize, maxpages,
+ &start);
+ ])
+
+ ZFS_LINUX_TEST_SRC([iov_iter_get_pages], [
+ #include <linux/uio.h>
+ ], [
+ struct iov_iter iter = { 0 };
+ struct page **pages = NULL;
+ size_t maxsize = 4096;
+ unsigned maxpages = 1;
+ size_t start;
+ size_t ret __attribute__ ((unused));
+
+ ret = iov_iter_get_pages(&iter, pages, maxsize, maxpages,
+ &start);
+ ])
+
ZFS_LINUX_TEST_SRC([iov_iter_type], [
#include <linux/fs.h>
#include <linux/uio.h>
enable_vfs_iov_iter="no"
])
+ dnl #
+ dnl # Kernel 6.0 changed iov_iter_get_pages() to iov_iter_page_pages2().
+ dnl #
+ AC_MSG_CHECKING([whether iov_iter_get_pages2() is available])
+ ZFS_LINUX_TEST_RESULT([iov_iter_get_pages2], [
+ AC_MSG_RESULT(yes)
+ AC_DEFINE(HAVE_IOV_ITER_GET_PAGES2, 1,
+ [iov_iter_get_pages2() is available])
+ ], [
+ AC_MSG_RESULT(no)
+ AC_MSG_CHECKING([whether iov_iter_get_pages() is available])
+ ZFS_LINUX_TEST_RESULT([iov_iter_get_pages], [
+ AC_MSG_RESULT(yes)
+ AC_DEFINE(HAVE_IOV_ITER_GET_PAGES, 1,
+ [iov_iter_get_pages() is available])
+ ], [
+ AC_MSG_RESULT(no)
+ enable_vfs_iov_iter="no"
+ ])
+ ])
+
dnl #
dnl # This checks for iov_iter_type() in linux/uio.h. It is not
dnl # required, however, and the module will compiled without it
ZFS_AC_KERNEL_SRC_SHOW_OPTIONS
ZFS_AC_KERNEL_SRC_FILE_INODE
ZFS_AC_KERNEL_SRC_FILE_DENTRY
+ ZFS_AC_KERNEL_SRC_FILEMAP
ZFS_AC_KERNEL_SRC_FSYNC
ZFS_AC_KERNEL_SRC_AIO_FSYNC
ZFS_AC_KERNEL_SRC_EVICT_INODE
ZFS_AC_KERNEL_SRC_VFS_GETATTR
ZFS_AC_KERNEL_SRC_VFS_FSYNC_2ARGS
ZFS_AC_KERNEL_SRC_VFS_ITERATE
+ ZFS_AC_KERNEL_SRC_GET_USER_PAGES
ZFS_AC_KERNEL_SRC_VFS_DIRECT_IO
ZFS_AC_KERNEL_SRC_VFS_READPAGES
ZFS_AC_KERNEL_SRC_VFS_SET_PAGE_DIRTY_NOBUFFERS
ZFS_AC_KERNEL_SHOW_OPTIONS
ZFS_AC_KERNEL_FILE_INODE
ZFS_AC_KERNEL_FILE_DENTRY
+ ZFS_AC_KERNEL_FILEMAP
ZFS_AC_KERNEL_FSYNC
ZFS_AC_KERNEL_AIO_FSYNC
ZFS_AC_KERNEL_EVICT_INODE
ZFS_AC_KERNEL_VFS_GETATTR
ZFS_AC_KERNEL_VFS_FSYNC_2ARGS
ZFS_AC_KERNEL_VFS_ITERATE
+ ZFS_AC_KERNEL_GET_USER_PAGES
ZFS_AC_KERNEL_VFS_DIRECT_IO
ZFS_AC_KERNEL_VFS_READPAGES
ZFS_AC_KERNEL_VFS_SET_PAGE_DIRTY_NOBUFFERS
#define mutex_exit(lock) sx_xunlock(lock)
#define mutex_owned(lock) sx_xlocked(lock)
#define mutex_owner(lock) sx_xholder(lock)
+
#endif /* _OPENSOLARIS_SYS_MUTEX_H_ */
#include <sys/types.h>
#include_next <sys/param.h>
#define PAGESIZE PAGE_SIZE
+#define PAGESHIFT PAGE_SHIFT
#define ptob(x) ((uint64_t)(x) << PAGE_SHIFT)
#ifdef _KERNEL
#include <sys/systm.h>
#include_next <sys/uio.h>
#include <sys/_uio.h>
#include <sys/debug.h>
+#include <sys/sysmacros.h>
+
+/*
+ * uio_extflg: extended flags
+ */
+#define UIO_DIRECT 0x0001 /* Direct I/O requset */
typedef struct iovec iovec_t;
typedef enum uio_seg zfs_uio_seg_t;
typedef enum uio_rw zfs_uio_rw_t;
+/*
+ * This structure is used when doing Direct I/O.
+ */
+typedef struct {
+ vm_page_t *pages;
+ int npages;
+} zfs_uio_dio_t;
+
typedef struct zfs_uio {
struct uio *uio;
+ offset_t uio_soffset;
+ uint16_t uio_extflg;
+ zfs_uio_dio_t uio_dio;
} zfs_uio_t;
#define GET_UIO_STRUCT(u) (u)->uio
#define zfs_uio_iovbase(u, idx) GET_UIO_STRUCT(u)->uio_iov[(idx)].iov_base
#define zfs_uio_td(u) GET_UIO_STRUCT(u)->uio_td
#define zfs_uio_rw(u) GET_UIO_STRUCT(u)->uio_rw
+#define zfs_uio_soffset(u) (u)->uio_soffset
#define zfs_uio_fault_disable(u, set)
#define zfs_uio_prefaultpages(size, u) (0)
zfs_uio_offset(uio) = off;
}
+static inline void
+zfs_uio_setsoffset(zfs_uio_t *uio, offset_t off)
+{
+ ASSERT3U(zfs_uio_offset(uio), ==, off);
+ zfs_uio_soffset(uio) = off;
+}
+
static inline void
zfs_uio_advance(zfs_uio_t *uio, ssize_t size)
{
static __inline void
zfs_uio_init(zfs_uio_t *uio, struct uio *uio_s)
{
- GET_UIO_STRUCT(uio) = uio_s;
+ memset(uio, 0, sizeof (zfs_uio_t));
+ if (uio_s != NULL) {
+ GET_UIO_STRUCT(uio) = uio_s;
+ zfs_uio_soffset(uio) = uio_s->uio_offset;
+ }
}
int zfs_uio_fault_move(void *p, size_t n, zfs_uio_rw_t dir, zfs_uio_t *uio);
#ifndef _ABD_OS_H
#define _ABD_OS_H
+#include <sys/vm.h>
+#include <vm/vm_page.h>
+
#ifdef __cplusplus
extern "C" {
#endif
+struct abd;
+
struct abd_scatter {
uint_t abd_offset;
void *abd_chunks[1]; /* actually variable-length */
struct abd_linear {
void *abd_buf;
+#if defined(_KERNEL)
+ struct sf_buf *sf; /* for LINEAR_PAGE FreeBSD */
+#endif
};
+__attribute__((malloc))
+struct abd *abd_alloc_from_pages(vm_page_t *, unsigned long, uint64_t);
+
#ifdef __cplusplus
}
#endif
#define zfs_kmap_local(page) kmap_atomic(page)
#define zfs_kunmap_local(addr) kunmap_atomic(addr)
#endif
+#define zfs_kmap(page) kmap(page)
+#define zfs_kunmap(page) kunmap(page)
/* 5.0 API change - no more 'type' argument for access_ok() */
#ifdef HAVE_ACCESS_OK_TYPE
#define zfs_access_ok(type, addr, size) access_ok(addr, size)
#endif
+/*
+ * read returning FOLL_WRITE is due to the fact that we are stating
+ * that the kernel will have write access to the user pages. So, when
+ * a Direct I/O read request is issued, the kernel must write to the user
+ * pages.
+ *
+ * get_user_pages_unlocked was not available to 4.0, so we also check
+ * for get_user_pages on older kernels.
+ */
+/* 4.9 API change - for and read flag is passed as gup flags */
+#if defined(HAVE_GET_USER_PAGES_UNLOCKED_GUP_FLAGS)
+#define zfs_get_user_pages(addr, numpages, read, pages) \
+ get_user_pages_unlocked(addr, numpages, pages, read ? FOLL_WRITE : 0)
+
+/* 4.8 API change - no longer takes struct task_struct as arguement */
+#elif defined(HAVE_GET_USER_PAGES_UNLOCKED_WRITE_FLAG)
+#define zfs_get_user_pages(addr, numpages, read, pages) \
+ get_user_pages_unlocked(addr, numpages, read, 0, pages)
+
+/* 4.0-4.3, 4.5-4.7 API */
+#elif defined(HAVE_GET_USER_PAGES_UNLOCKED_TASK_STRUCT)
+#define zfs_get_user_pages(addr, numpages, read, pages) \
+ get_user_pages_unlocked(current, current->mm, addr, numpages, read, 0, \
+ pages)
+
+/* 4.4 API */
+#elif defined(HAVE_GET_USER_PAGES_UNLOCKED_TASK_STRUCT_GUP_FLAGS)
+#define zfs_get_user_pages(addr, numpages, read, pages) \
+ get_user_pages_unlocked(current, current->mm, addr, numpages, pages, \
+ read ? FOLL_WRITE : 0)
+
+/* Using get_user_pages if kernel is < 4.0 */
+#elif defined(HAVE_GET_USER_PAGES_TASK_STRUCT)
+#define zfs_get_user_pages(addr, numpages, read, pages) \
+ get_user_pages(current, current->mm, addr, numpages, read, 0, pages, \
+ NULL)
+#else
+/*
+ * This case is unreachable. We must be able to use either
+ * get_user_pages_unlocked() or get_user_pages() to map user pages into
+ * the kernel.
+ */
+#error "Unknown Direct I/O interface"
+#endif
+
#endif /* _ZFS_KMAP_H */
#include <linux/bio.h>
#include <asm/uaccess.h>
#include <sys/types.h>
+#include <sys/string.h>
+
+/*
+ * uio_extflg: extended flags
+ */
+#define UIO_DIRECT 0x0001 /* Direct I/O request */
#if defined(HAVE_VFS_IOV_ITER) && defined(HAVE_FAULT_IN_IOV_ITER_READABLE)
#define iov_iter_fault_in_readable(a, b) fault_in_iov_iter_readable(a, b)
#endif
} zfs_uio_seg_t;
+/*
+ * This structures is used when doing Direct I/O.
+ */
+typedef struct {
+ struct page **pages; /* Mapped pages */
+ long npages; /* Number of mapped pages */
+} zfs_uio_dio_t;
+
typedef struct zfs_uio {
union {
const struct iovec *uio_iov;
struct iov_iter *uio_iter;
#endif
};
- int uio_iovcnt;
- offset_t uio_loffset;
- zfs_uio_seg_t uio_segflg;
+ int uio_iovcnt; /* Number of iovecs */
+ offset_t uio_soffset; /* Starting logical offset */
+ offset_t uio_loffset; /* Current logical offset */
+ zfs_uio_seg_t uio_segflg; /* Segment type */
boolean_t uio_fault_disable;
- uint16_t uio_fmode;
- uint16_t uio_extflg;
- ssize_t uio_resid;
-
- size_t uio_skip;
+ uint16_t uio_fmode; /* Access mode (unused) */
+ uint16_t uio_extflg; /* Extra flags (UIO_DIRECT) */
+ ssize_t uio_resid; /* Residual unprocessed bytes */
+ size_t uio_skip; /* Skipped bytes in current iovec */
+ zfs_uio_dio_t uio_dio; /* Direct I/O user pages */
struct request *rq;
} zfs_uio_t;
#define zfs_uio_iovlen(u, idx) (u)->uio_iov[(idx)].iov_len
#define zfs_uio_iovbase(u, idx) (u)->uio_iov[(idx)].iov_base
#define zfs_uio_fault_disable(u, set) (u)->uio_fault_disable = set
+#define zfs_uio_soffset(u) (u)->uio_soffset
#define zfs_uio_rlimit_fsize(z, u) (0)
#define zfs_uio_fault_move(p, n, rw, u) zfs_uiomove((p), (n), (rw), (u))
uio->uio_loffset = off;
}
+static inline void
+zfs_uio_setsoffset(zfs_uio_t *uio, offset_t off)
+{
+ ASSERT3U(zfs_uio_offset(uio), ==, off);
+ zfs_uio_soffset(uio) = off;
+}
+
static inline void
zfs_uio_advance(zfs_uio_t *uio, ssize_t size)
{
uio->uio_extflg = 0;
uio->uio_resid = resid;
uio->uio_skip = skip;
+ uio->uio_soffset = uio->uio_loffset;
+ memset(&uio->uio_dio, 0, sizeof (zfs_uio_dio_t));
}
static inline void
}
uio->rq = rq;
+ uio->uio_soffset = uio->uio_loffset;
+ memset(&uio->uio_dio, 0, sizeof (zfs_uio_dio_t));
}
#if defined(HAVE_VFS_IOV_ITER)
uio->uio_extflg = 0;
uio->uio_resid = resid;
uio->uio_skip = skip;
+ uio->uio_soffset = uio->uio_loffset;
+ memset(&uio->uio_dio, 0, sizeof (zfs_uio_dio_t));
}
-#endif
+#endif /* HAVE_VFS_IOV_ITER */
#if defined(HAVE_ITER_IOV)
#define zfs_uio_iter_iov(iter) iter_iov((iter))
unsigned int abd_bio_map_off(struct bio *, abd_t *, unsigned int, size_t);
unsigned long abd_nr_pages_off(abd_t *, unsigned int, size_t);
+__attribute__((malloc))
+abd_t *abd_alloc_from_pages(struct page **, unsigned long, uint64_t);
+
#ifdef __cplusplus
}
#endif
extern void zfs_inode_destroy(struct inode *);
extern void zfs_mark_inode_dirty(struct inode *);
extern boolean_t zfs_relatime_need_update(const struct inode *);
-
-#if defined(HAVE_UIO_RW)
-extern caddr_t zfs_map_page(page_t *, enum seg_rw);
-extern void zfs_unmap_page(page_t *, caddr_t);
-#endif /* HAVE_UIO_RW */
-
extern zil_replay_func_t *const zfs_replay_vector[TX_MAX_TYPE];
#ifdef __cplusplus
#include <linux/exportfs.h>
#include <linux/falloc.h>
#include <linux/parser.h>
-#include <linux/task_io_accounting_ops.h>
#include <linux/vfs_compat.h>
#include <linux/writeback.h>
#include <linux/xattr_compat.h>
ABD_FLAG_GANG = 1 << 6, /* mult ABDs chained together */
ABD_FLAG_GANG_FREE = 1 << 7, /* gang ABD is responsible for mem */
ABD_FLAG_ALLOCD = 1 << 8, /* we allocated the abd_t */
+ ABD_FLAG_FROM_PAGES = 1 << 9, /* does not own pages */
} abd_flags_t;
typedef struct abd {
return (abd->abd_size);
}
+static inline boolean_t
+abd_is_from_pages(abd_t *abd)
+{
+ return ((abd->abd_flags & ABD_FLAG_FROM_PAGES) ? B_TRUE : B_FALSE);
+}
+
/*
* Module lifecycle
* Defined in each specific OS's abd_os.c
/* forward declarations */
struct scatterlist;
struct page;
+#if defined(__FreeBSD__) && defined(_KERNEL)
+struct sf_buf;
+#endif
struct abd_iter {
/* public interface */
size_t iter_pos;
size_t iter_offset; /* offset in current sg/abd_buf, */
/* abd_offset included */
+#if defined(__FreeBSD__) && defined(_KERNEL)
+ struct sf_buf *sf; /* used to map in vm_page_t FreeBSD */
+#else
struct scatterlist *iter_sg; /* current sg */
+#endif
};
extern abd_t *abd_zero_scatter;
abd_t *abd_gang_get_offset(abd_t *, size_t *);
abd_t *abd_alloc_struct(size_t);
void abd_free_struct(abd_t *);
+void abd_init_struct(abd_t *);
/*
* OS specific functions
#define ABDSTAT_BUMP(stat) ABDSTAT_INCR(stat, 1)
#define ABDSTAT_BUMPDOWN(stat) ABDSTAT_INCR(stat, -1)
-#define ABD_SCATTER(abd) (abd->abd_u.abd_scatter)
-#define ABD_LINEAR_BUF(abd) (abd->abd_u.abd_linear.abd_buf)
-#define ABD_GANG(abd) (abd->abd_u.abd_gang)
+#define ABD_SCATTER(abd) ((abd)->abd_u.abd_scatter)
+#define ABD_LINEAR_BUF(abd) ((abd)->abd_u.abd_linear.abd_buf)
+#define ABD_GANG(abd) ((abd)->abd_u.abd_gang)
#ifdef __cplusplus
}
/*
* Private ARC flags. These flags are private ARC only flags that
- * will show up in b_flags in the arc_hdr_buf_t. These flags should
+ * will show up in b_flags in the arc_buf_hdr_t. These flags should
* only be set by ARC code.
*/
ARC_FLAG_IN_HASH_TABLE = 1 << 7, /* buffer is hashed */
ARC_FLAG_COMPRESS_4 = 1 << 28,
ARC_FLAG_COMPRESS_5 = 1 << 29,
ARC_FLAG_COMPRESS_6 = 1 << 30
-
} arc_flags_t;
typedef enum arc_buf_flags {
/*
* The simplified state transition diagram for dbufs looks like:
*
- * +--> READ --+
- * | |
- * | V
- * (alloc)-->UNCACHED CACHED-->EVICTING-->(free)
- * ^ | ^ ^
- * | | | |
- * | +--> FILL --+ |
- * | | |
- * | | |
- * | +------> NOFILL -----+
- * | |
+ * +-------> READ ------+
+ * | |
+ * | V
+ * (alloc)-->UNCACHED CACHED-->EVICTING-->(free)
+ * ^ | ^ ^
+ * | | | |
+ * | +-------> FILL ------+ |
+ * | | | |
+ * | | | |
+ * | +------> NOFILL -----+-----> UNCACHED
+ * | | (Direct I/O)
* +---------------+
*
* DB_SEARCH is an invalid state for a dbuf. It is used by dbuf_free_range
uint8_t dr_copies;
boolean_t dr_nopwrite;
boolean_t dr_brtwrite;
+ boolean_t dr_diowrite;
boolean_t dr_has_raw_params;
/*
uint64_t blkid, uint64_t *hash_out);
int dbuf_read(dmu_buf_impl_t *db, zio_t *zio, uint32_t flags);
-void dmu_buf_will_clone(dmu_buf_t *db, dmu_tx_t *tx);
+void dmu_buf_will_clone_or_dio(dmu_buf_t *db, dmu_tx_t *tx);
void dmu_buf_will_not_fill(dmu_buf_t *db, dmu_tx_t *tx);
void dmu_buf_will_fill(dmu_buf_t *db, dmu_tx_t *tx, boolean_t canfail);
boolean_t dmu_buf_fill_done(dmu_buf_t *db, dmu_tx_t *tx, boolean_t failed);
dbuf_dirty_record_t *dbuf_dirty_lightweight(dnode_t *dn, uint64_t blkid,
dmu_tx_t *tx);
boolean_t dbuf_undirty(dmu_buf_impl_t *db, dmu_tx_t *tx);
+int dmu_buf_get_bp_from_dbuf(dmu_buf_impl_t *db, blkptr_t **bp);
+int dmu_buf_untransform_direct(dmu_buf_impl_t *db, spa_t *spa);
arc_buf_t *dbuf_loan_arcbuf(dmu_buf_impl_t *db);
void dmu_buf_write_embedded(dmu_buf_t *dbuf, void *data,
bp_embedded_type_t etype, enum zio_compress comp,
(dbuf_is_metadata(_db) && \
((_db)->db_objset->os_primary_cache == ZFS_CACHE_METADATA)))
-boolean_t dbuf_is_l2cacheable(dmu_buf_impl_t *db);
+boolean_t dbuf_is_l2cacheable(dmu_buf_impl_t *db, blkptr_t *db_bp);
#ifdef ZFS_DEBUG
#define WP_NOFILL 0x1
#define WP_DMU_SYNC 0x2
#define WP_SPILL 0x4
+#define WP_DIRECT_WR 0x8
void dmu_write_policy(objset_t *os, dnode_t *dn, int level, int wp,
struct zio_prop *zp);
dmu_buf_t ***dbpp, uint32_t flags);
int dmu_buf_hold_noread_by_dnode(dnode_t *dn, uint64_t offset, const void *tag,
dmu_buf_t **dbp);
+
/*
* Add a reference to a dmu buffer that has already been held via
* dmu_buf_hold() in the current context.
#define DMU_READ_PREFETCH 0 /* prefetch */
#define DMU_READ_NO_PREFETCH 1 /* don't prefetch */
#define DMU_READ_NO_DECRYPT 2 /* don't decrypt */
+#define DMU_DIRECTIO 4 /* use Direct I/O */
+
int dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
- void *buf, uint32_t flags);
+ void *buf, uint32_t flags);
int dmu_read_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size, void *buf,
uint32_t flags);
void dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
- const void *buf, dmu_tx_t *tx);
-void dmu_write_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size,
const void *buf, dmu_tx_t *tx);
+int dmu_write_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size,
+ const void *buf, dmu_tx_t *tx);
+int dmu_write_by_dnode_flags(dnode_t *dn, uint64_t offset, uint64_t size,
+ const void *buf, dmu_tx_t *tx, uint32_t flags);
void dmu_prealloc(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
- dmu_tx_t *tx);
+ dmu_tx_t *tx);
#ifdef _KERNEL
int dmu_read_uio(objset_t *os, uint64_t object, zfs_uio_t *uio, uint64_t size);
int dmu_read_uio_dbuf(dmu_buf_t *zdb, zfs_uio_t *uio, uint64_t size);
#include <sys/dnode.h>
#include <sys/zfs_context.h>
#include <sys/zfs_ioctl.h>
+#include <sys/uio.h>
+#include <sys/abd.h>
+#include <sys/arc.h>
+#include <sys/dbuf.h>
#ifdef __cplusplus
extern "C" {
* db_data_pending
* db_dirtied
* db_link
- * db_dirty_node (??)
+ * db_dirty_records
* db_dirtycnt
* db_d.*
* db.*
* dbuf_find: none (db_holds)
* dbuf_hash_insert: none (db_holds)
* dmu_buf_read_array_impl: none (db_state, db_changed)
- * dmu_sync: none (db_dirty_node, db_d)
+ * dmu_sync: none (db_dirty_records, db_d)
* dnode_reallocate: none (db)
+ * dmu_write_direct: none (db_dirty_records, db_d)
+ * dmu_write_direct_done: none (db_dirty_records, db_d)
*
* dn_mtx (leaf)
* protects:
* dnode_new_blkid
*/
-struct objset;
struct dmu_pool;
+struct dmu_buf;
+struct zgd;
typedef struct dmu_sendstatus {
list_node_t dss_link;
uint64_t dss_blocks; /* blocks visited during the sending process */
} dmu_sendstatus_t;
+/*
+ * dmu_sync_{ready/done} args
+ */
+typedef struct {
+ dbuf_dirty_record_t *dsa_dr;
+ void (*dsa_done)(struct zgd *, int);
+ struct zgd *dsa_zgd;
+ dmu_tx_t *dsa_tx;
+} dmu_sync_arg_t;
+
+void dmu_sync_done(zio_t *, arc_buf_t *buf, void *varg);
+void dmu_sync_ready(zio_t *, arc_buf_t *buf, void *varg);
+
void dmu_object_zapify(objset_t *, uint64_t, dmu_object_type_t, dmu_tx_t *);
void dmu_object_free_zapified(objset_t *, uint64_t, dmu_tx_t *);
+int dmu_write_direct(zio_t *, dmu_buf_impl_t *, abd_t *, dmu_tx_t *);
+int dmu_read_abd(dnode_t *, uint64_t, uint64_t, abd_t *, uint32_t flags);
+int dmu_write_abd(dnode_t *, uint64_t, uint64_t, abd_t *, uint32_t, dmu_tx_t *);
+#if defined(_KERNEL)
+int dmu_read_uio_direct(dnode_t *, zfs_uio_t *, uint64_t);
+int dmu_write_uio_direct(dnode_t *, zfs_uio_t *, uint64_t, dmu_tx_t *);
+#endif
+
#ifdef __cplusplus
}
#endif
zfs_cache_type_t os_secondary_cache;
zfs_prefetch_type_t os_prefetch;
zfs_sync_type_t os_sync;
+ zfs_direct_t os_direct;
zfs_redundant_metadata_type_t os_redundant_metadata;
uint64_t os_recordsize;
/*
#define FM_EREPORT_ZFS_DATA "data"
#define FM_EREPORT_ZFS_DELAY "delay"
#define FM_EREPORT_ZFS_DEADMAN "deadman"
+#define FM_EREPORT_ZFS_DIO_VERIFY "dio_verify"
#define FM_EREPORT_ZFS_POOL "zpool"
#define FM_EREPORT_ZFS_DEVICE_UNKNOWN "vdev.unknown"
#define FM_EREPORT_ZFS_DEVICE_OPEN_FAILED "vdev.open_failed"
#define FM_EREPORT_PAYLOAD_ZFS_VDEV_IO_T "vdev_io_t"
#define FM_EREPORT_PAYLOAD_ZFS_VDEV_SLOW_IO_N "vdev_slow_io_n"
#define FM_EREPORT_PAYLOAD_ZFS_VDEV_SLOW_IO_T "vdev_slow_io_t"
+#define FM_EREPORT_PAYLOAD_ZFS_VDEV_DIO_VERIFY_ERRORS "dio_verify_errors"
#define FM_EREPORT_PAYLOAD_ZFS_VDEV_DELAYS "vdev_delays"
#define FM_EREPORT_PAYLOAD_ZFS_PARENT_GUID "parent_guid"
#define FM_EREPORT_PAYLOAD_ZFS_PARENT_TYPE "parent_type"
ZFS_PROP_SNAPSHOTS_CHANGED,
ZFS_PROP_PREFETCH,
ZFS_PROP_VOLTHREADING,
+ ZFS_PROP_DIRECT,
ZFS_NUM_PROPS
} zfs_prop_t;
ZFS_VOLMODE_NONE = 3
} zfs_volmode_t;
+typedef enum {
+ ZFS_DIRECT_DISABLED = 0,
+ ZFS_DIRECT_STANDARD,
+ ZFS_DIRECT_ALWAYS
+} zfs_direct_t;
+
typedef enum zfs_keystatus {
ZFS_KEYSTATUS_NONE = 0,
ZFS_KEYSTATUS_UNAVAILABLE,
/* Number of slow IOs */
#define ZPOOL_CONFIG_VDEV_SLOW_IOS "vdev_slow_ios"
+/* Number of Direct I/O write verify errors */
+#define ZPOOL_CONFIG_VDEV_DIO_VERIFY_ERRORS "vdev_dio_verify_errors"
+
/* vdev enclosure sysfs path */
#define ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH "vdev_enc_sysfs_path"
uint64_t vs_physical_ashift; /* vdev_physical_ashift */
uint64_t vs_noalloc; /* allocations halted? */
uint64_t vs_pspace; /* physical capacity */
+ uint64_t vs_dio_verify_errors; /* DIO write verify errors */
} vdev_stat_t;
#define VDEV_STAT_VALID(field, uint64_t_field_count) \
kstat_named_t simple_trim_bytes_skipped;
kstat_named_t simple_trim_extents_failed;
kstat_named_t simple_trim_bytes_failed;
+ kstat_named_t arc_read_count;
+ kstat_named_t arc_read_bytes;
+ kstat_named_t arc_write_count;
+ kstat_named_t arc_write_bytes;
+ kstat_named_t direct_read_count;
+ kstat_named_t direct_read_bytes;
+ kstat_named_t direct_write_count;
+ kstat_named_t direct_write_bytes;
} spa_iostats_t;
extern void spa_stats_init(spa_t *spa);
uint64_t extents_written, uint64_t bytes_written,
uint64_t extents_skipped, uint64_t bytes_skipped,
uint64_t extents_failed, uint64_t bytes_failed);
+extern void spa_iostats_read_add(spa_t *spa, uint64_t size, uint64_t iops,
+ uint32_t flags);
+extern void spa_iostats_write_add(spa_t *spa, uint64_t size, uint64_t iops,
+ uint32_t flags);
extern void spa_import_progress_add(spa_t *spa);
extern void spa_import_progress_remove(uint64_t spa_guid);
extern int spa_import_progress_set_mmp_check(uint64_t pool_guid,
#define _SYS_UIO_IMPL_H
#include <sys/uio.h>
+#include <sys/sysmacros.h>
extern int zfs_uiomove(void *, size_t, zfs_uio_rw_t, zfs_uio_t *);
extern int zfs_uiocopy(void *, size_t, zfs_uio_rw_t, zfs_uio_t *, size_t *);
extern void zfs_uioskip(zfs_uio_t *, size_t);
+extern void zfs_uio_free_dio_pages(zfs_uio_t *, zfs_uio_rw_t);
+extern int zfs_uio_get_dio_pages_alloc(zfs_uio_t *, zfs_uio_rw_t);
+extern boolean_t zfs_uio_page_aligned(zfs_uio_t *);
+
+static inline boolean_t
+zfs_dio_page_aligned(void *buf)
+{
+ return ((((uintptr_t)(buf) & (PAGESIZE - 1)) == 0) ?
+ B_TRUE : B_FALSE);
+}
+
+static inline boolean_t
+zfs_dio_offset_aligned(uint64_t offset, uint64_t blksz)
+{
+ return (IS_P2ALIGNED(offset, blksz));
+}
+
+static inline boolean_t
+zfs_dio_size_aligned(uint64_t size, uint64_t blksz)
+{
+ return ((size % blksz) == 0);
+}
+
+static inline boolean_t
+zfs_dio_aligned(uint64_t offset, uint64_t size, uint64_t blksz)
+{
+ return (zfs_dio_offset_aligned(offset, blksz) &&
+ zfs_dio_size_aligned(size, blksz));
+}
+
+static inline boolean_t
+zfs_uio_aligned(zfs_uio_t *uio, uint64_t blksz)
+{
+ return (zfs_dio_aligned(zfs_uio_offset(uio), zfs_uio_resid(uio),
+ blksz));
+}
static inline void
zfs_uio_iov_at_index(zfs_uio_t *uio, uint_t idx, void **base, uint64_t *len)
/*
* We rate limit ZIO delay, deadman, and checksum events, since they
* can flood ZED with tons of events when a drive is acting up.
+ *
+ * We also rate limit Direct I/O write verify errors, since a user might
+ * be continually manipulating a buffer that can flood ZED with tons of
+ * events.
*/
zfs_ratelimit_t vdev_delay_rl;
zfs_ratelimit_t vdev_deadman_rl;
+ zfs_ratelimit_t vdev_dio_verify_rl;
zfs_ratelimit_t vdev_checksum_rl;
/*
int param_set_min_auto_ashift(ZFS_MODULE_PARAM_ARGS);
int param_set_max_auto_ashift(ZFS_MODULE_PARAM_ARGS);
+/*
+ * VDEV checksum verification for Direct I/O writes
+ */
+extern uint_t zfs_vdev_direct_write_verify;
+
#ifdef __cplusplus
}
#endif
#ifndef _SYS_ZFS_RACCT_H
#define _SYS_ZFS_RACCT_H
-#include <sys/zfs_context.h>
+#include <sys/types.h>
+#include <sys/spa.h>
/*
* Platform-dependent resource accounting hooks
*/
-void zfs_racct_read(uint64_t size, uint64_t iops);
-void zfs_racct_write(uint64_t size, uint64_t iops);
+void zfs_racct_read(spa_t *spa, uint64_t size, uint64_t iops, uint32_t flags);
+void zfs_racct_write(spa_t *spa, uint64_t size, uint64_t iops, uint32_t flags);
#endif /* _SYS_ZFS_RACCT_H */
const char *dname, znode_t *szp, znode_t *wzp);
extern void zfs_log_write(zilog_t *zilog, dmu_tx_t *tx, int txtype,
znode_t *zp, offset_t off, ssize_t len, boolean_t commit,
- zil_callback_t callback, void *callback_data);
+ boolean_t o_direct, zil_callback_t callback, void *callback_data);
extern void zfs_log_truncate(zilog_t *zilog, dmu_tx_t *tx, int txtype,
znode_t *zp, uint64_t off, uint64_t len);
extern void zfs_log_setattr(zilog_t *zilog, dmu_tx_t *tx, int txtype,
#define ZIO_FLAG_NOPWRITE (1ULL << 28)
#define ZIO_FLAG_REEXECUTED (1ULL << 29)
#define ZIO_FLAG_DELEGATED (1ULL << 30)
+#define ZIO_FLAG_DIO_CHKSUM_ERR (1ULL << 31)
#define ZIO_ALLOCATOR_NONE (-1)
#define ZIO_HAS_ALLOCATOR(zio) ((zio)->io_allocator != ZIO_ALLOCATOR_NONE)
boolean_t zp_brtwrite;
boolean_t zp_encrypt;
boolean_t zp_byteorder;
+ boolean_t zp_direct_write;
uint8_t zp_salt[ZIO_DATA_SALT_LEN];
uint8_t zp_iv[ZIO_DATA_IV_LEN];
uint8_t zp_mac[ZIO_DATA_MAC_LEN];
ZIO_STAGE_VDEV_IO_ASSESS = 1 << 23, /* RW--XT */
ZIO_STAGE_CHECKSUM_VERIFY = 1 << 24, /* R----- */
+ ZIO_STAGE_DIO_CHECKSUM_VERIFY = 1 << 25, /* -W---- */
- ZIO_STAGE_DONE = 1 << 25 /* RWFCXT */
+ ZIO_STAGE_DONE = 1 << 26 /* RWFCXT */
};
#define ZIO_ROOT_PIPELINE \
ZIO_STAGE_DVA_THROTTLE | \
ZIO_STAGE_DVA_ALLOCATE)
+#define ZIO_DIRECT_WRITE_PIPELINE \
+ ZIO_WRITE_PIPELINE & \
+ (~ZIO_STAGE_ISSUE_ASYNC)
+
#define ZIO_DDT_CHILD_WRITE_PIPELINE \
(ZIO_INTERLOCK_STAGES | \
ZIO_VDEV_IO_STAGES | \
#define zfs_uio_iovlen(uio, idx) (uio)->uio_iov[(idx)].iov_len
#define zfs_uio_iovbase(uio, idx) (uio)->uio_iov[(idx)].iov_base
+static inline boolean_t
+zfs_dio_page_aligned(void *buf)
+{
+ return ((((unsigned long)(buf) & (PAGESIZE - 1)) == 0) ?
+ B_TRUE : B_FALSE);
+}
+
+static inline boolean_t
+zfs_dio_offset_aligned(uint64_t offset, uint64_t blksz)
+{
+ return (IS_P2ALIGNED(offset, blksz));
+}
+
+static inline boolean_t
+zfs_dio_size_aligned(uint64_t size, uint64_t blksz)
+{
+ return ((size % blksz) == 0);
+}
+
+static inline boolean_t
+zfs_dio_aligned(uint64_t offset, uint64_t size, uint64_t blksz)
+{
+ return (zfs_dio_offset_aligned(offset, blksz) &&
+ zfs_dio_size_aligned(size, blksz));
+}
+
static inline void
zfs_uio_iov_at_index(zfs_uio_t *uio, uint_t idx, void **base, uint64_t *len)
{
<elf-needed>
<dependency name='libzfs_core.so.3'/>
<dependency name='libnvpair.so.3'/>
+ <dependency name='libtirpc.so.3'/>
<dependency name='libuuid.so.1'/>
<dependency name='libblkid.so.1'/>
<dependency name='libudev.so.1'/>
<parameter type-id='80f4b756'/>
<return type-id='48b5725f'/>
</function-decl>
+ <function-decl name='bsearch' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='eaa32e2f'/>
+ <parameter type-id='eaa32e2f'/>
+ <parameter type-id='b59d7dce'/>
+ <parameter type-id='b59d7dce'/>
+ <parameter type-id='aba7edd8'/>
+ <return type-id='eaa32e2f'/>
+ </function-decl>
+ <function-decl name='memmove' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='eaa32e2f'/>
+ <parameter type-id='eaa32e2f'/>
+ <parameter type-id='b59d7dce'/>
+ <return type-id='eaa32e2f'/>
+ </function-decl>
+ <function-decl name='strcat' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='26a90f95'/>
+ <parameter type-id='80f4b756'/>
+ <return type-id='26a90f95'/>
+ </function-decl>
<function-type size-in-bits='64' id='276427e1'>
<return type-id='95e97e5e'/>
</function-type>
</abi-instr>
<abi-instr address-size='64' path='lib/libshare/os/linux/smb.c' language='LANG_C99'>
<var-decl name='libshare_smb_type' type-id='d19dbca9' visibility='default'/>
- <function-decl name='__fgets_chk' visibility='default' binding='global' size-in-bits='64'>
+ <function-decl name='fgets' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='266fe297'/>
- <parameter type-id='b59d7dce'/>
<parameter type-id='95e97e5e'/>
<parameter type-id='e75a27e9'/>
<return type-id='26a90f95'/>
<function-decl name='gettid' visibility='default' binding='global' size-in-bits='64'>
<return type-id='3629bad8'/>
</function-decl>
+ <function-decl name='vfprintf' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='e75a27e9'/>
+ <parameter type-id='9d26089a'/>
+ <parameter type-id='b7f2d5e6'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
<function-decl name='prctl' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='95e97e5e'/>
<parameter is-variadic='yes'/>
<qualified-type-def type-id='f077d3f8' restrict='yes' id='598aab80'/>
<pointer-type-def type-id='928221d2' size-in-bits='64' id='323d93c1'/>
<qualified-type-def type-id='323d93c1' restrict='yes' id='f1358bc3'/>
- <function-decl name='__mbstowcs_chk' visibility='default' binding='global' size-in-bits='64'>
+ <function-decl name='mbstowcs' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='f1358bc3'/>
<parameter type-id='9d26089a'/>
<parameter type-id='b59d7dce'/>
- <parameter type-id='b59d7dce'/>
<return type-id='b59d7dce'/>
</function-decl>
- <function-decl name='__wcstombs_chk' visibility='default' binding='global' size-in-bits='64'>
+ <function-decl name='wcstombs' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='266fe297'/>
<parameter type-id='598aab80'/>
<parameter type-id='b59d7dce'/>
- <parameter type-id='b59d7dce'/>
<return type-id='b59d7dce'/>
</function-decl>
</abi-instr>
<parameter type-id='822cd80b'/>
<return type-id='95e97e5e'/>
</function-decl>
+ <function-decl name='gnu_dev_major' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='35ed8932'/>
+ <return type-id='f0981eeb'/>
+ </function-decl>
+ <function-decl name='gnu_dev_minor' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='35ed8932'/>
+ <return type-id='f0981eeb'/>
+ </function-decl>
+ <function-decl name='gnu_dev_makedev' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='f0981eeb'/>
+ <parameter type-id='f0981eeb'/>
+ <return type-id='35ed8932'/>
+ </function-decl>
</abi-instr>
<abi-instr address-size='64' path='lib/libspl/timestamp.c' language='LANG_C99'>
<typedef-decl name='nl_item' type-id='95e97e5e' id='03b79a94'/>
<pointer-type-def type-id='6fcda10e' size-in-bits='64' id='ad33e5e7'/>
<pointer-type-def type-id='66a0afc9' size-in-bits='64' id='f32b30e4'/>
<qualified-type-def type-id='63e171df' restrict='yes' id='9e7a3a7d'/>
+ <function-decl name='__sysconf' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='95e97e5e'/>
+ <return type-id='bd54fe1a'/>
+ </function-decl>
<function-decl name='pthread_self' visibility='default' binding='global' size-in-bits='64'>
<return type-id='4051f5e7'/>
</function-decl>
<parameter type-id='0be2e71c'/>
<return type-id='95e97e5e'/>
</function-decl>
- <function-decl name='__sysconf' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='95e97e5e'/>
- <return type-id='bd54fe1a'/>
- </function-decl>
<function-decl name='tpool_abandon' mangled-name='tpool_abandon' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='tpool_abandon'>
<parameter type-id='9cf59a50' name='tpool'/>
<return type-id='48b5725f'/>
<type-decl name='unsigned char' size-in-bits='8' id='002ac4a6'/>
<type-decl name='unsigned int' size-in-bits='32' id='f0981eeb'/>
<type-decl name='unsigned long int' size-in-bits='64' id='7359adad'/>
+ <type-decl name='variadic parameter type' id='2c1145c5'/>
<type-decl name='void' id='48b5725f'/>
<typedef-decl name='uu_compare_fn_t' type-id='add6e811' id='40f93560'/>
<typedef-decl name='uu_avl_pool_t' type-id='12a530a8' id='7f84e390'/>
<enumerator name='ZFS_PROP_SNAPSHOTS_CHANGED' value='95'/>
<enumerator name='ZFS_PROP_PREFETCH' value='96'/>
<enumerator name='ZFS_PROP_VOLTHREADING' value='97'/>
- <enumerator name='ZFS_NUM_PROPS' value='98'/>
+ <enumerator name='ZFS_PROP_DIRECT' value='98'/>
+ <enumerator name='ZFS_NUM_PROPS' value='99'/>
</enum-decl>
<typedef-decl name='zfs_prop_t' type-id='4b000d60' id='58603c44'/>
<enum-decl name='zprop_source_t' naming-typedef-id='a2256d42' id='5903f80e'>
<typedef-decl name='longlong_t' type-id='1eb56b1e' id='9b3ff54f'/>
<typedef-decl name='diskaddr_t' type-id='9b3ff54f' id='804dc465'/>
<typedef-decl name='zoneid_t' type-id='3502e3ff' id='4da03624'/>
- <typedef-decl name='__re_long_size_t' type-id='7359adad' id='ba516949'/>
- <typedef-decl name='reg_syntax_t' type-id='7359adad' id='1b72c3b3'/>
- <class-decl name='re_pattern_buffer' size-in-bits='512' is-struct='yes' visibility='default' id='19fc9a8c'>
- <data-member access='public' layout-offset-in-bits='0'>
- <var-decl name='buffer' type-id='33976309' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='64'>
- <var-decl name='allocated' type-id='ba516949' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='128'>
- <var-decl name='used' type-id='ba516949' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='192'>
- <var-decl name='syntax' type-id='1b72c3b3' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='256'>
- <var-decl name='fastmap' type-id='26a90f95' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='320'>
- <var-decl name='translate' type-id='cf536864' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='384'>
- <var-decl name='re_nsub' type-id='b59d7dce' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='448'>
- <var-decl name='can_be_null' type-id='f0981eeb' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='449'>
- <var-decl name='regs_allocated' type-id='f0981eeb' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='451'>
- <var-decl name='fastmap_accurate' type-id='f0981eeb' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='452'>
- <var-decl name='no_sub' type-id='f0981eeb' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='453'>
- <var-decl name='not_bol' type-id='f0981eeb' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='454'>
- <var-decl name='not_eol' type-id='f0981eeb' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='455'>
- <var-decl name='newline_anchor' type-id='f0981eeb' visibility='default'/>
- </data-member>
- </class-decl>
- <typedef-decl name='regex_t' type-id='19fc9a8c' id='aca3bac8'/>
- <typedef-decl name='uintptr_t' type-id='7359adad' id='e475ab95'/>
<union-decl name='pthread_mutex_t' size-in-bits='320' naming-typedef-id='7a6844eb' visibility='default' id='70681f9b'>
<data-member access='public'>
<var-decl name='__data' type-id='4c734837' visibility='default'/>
<typedef-decl name='__int32_t' type-id='95e97e5e' id='33f57a65'/>
<typedef-decl name='__uint32_t' type-id='f0981eeb' id='62f1140c'/>
<typedef-decl name='__uint64_t' type-id='7359adad' id='8910171f'/>
+ <typedef-decl name='__re_long_size_t' type-id='7359adad' id='ba516949'/>
+ <typedef-decl name='reg_syntax_t' type-id='7359adad' id='1b72c3b3'/>
+ <class-decl name='re_pattern_buffer' size-in-bits='512' is-struct='yes' visibility='default' id='19fc9a8c'>
+ <data-member access='public' layout-offset-in-bits='0'>
+ <var-decl name='buffer' type-id='33976309' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='64'>
+ <var-decl name='allocated' type-id='ba516949' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='128'>
+ <var-decl name='used' type-id='ba516949' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='192'>
+ <var-decl name='syntax' type-id='1b72c3b3' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='256'>
+ <var-decl name='fastmap' type-id='26a90f95' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='320'>
+ <var-decl name='translate' type-id='cf536864' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='384'>
+ <var-decl name='re_nsub' type-id='b59d7dce' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='448'>
+ <var-decl name='can_be_null' type-id='f0981eeb' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='449'>
+ <var-decl name='regs_allocated' type-id='f0981eeb' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='451'>
+ <var-decl name='fastmap_accurate' type-id='f0981eeb' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='452'>
+ <var-decl name='no_sub' type-id='f0981eeb' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='453'>
+ <var-decl name='not_bol' type-id='f0981eeb' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='454'>
+ <var-decl name='not_eol' type-id='f0981eeb' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='455'>
+ <var-decl name='newline_anchor' type-id='f0981eeb' visibility='default'/>
+ </data-member>
+ </class-decl>
+ <typedef-decl name='regex_t' type-id='19fc9a8c' id='aca3bac8'/>
+ <typedef-decl name='uintptr_t' type-id='7359adad' id='e475ab95'/>
<typedef-decl name='size_t' type-id='7359adad' id='b59d7dce'/>
<class-decl name='libzfs_handle' size-in-bits='18240' is-struct='yes' visibility='default' id='c8a9d9d8'>
<data-member access='public' layout-offset-in-bits='0'>
<class-decl name='uu_avl' is-struct='yes' visibility='default' is-declaration-only='yes' id='4af029d1'/>
<class-decl name='uu_avl_pool' is-struct='yes' visibility='default' is-declaration-only='yes' id='12a530a8'/>
<class-decl name='uu_avl_walk' is-struct='yes' visibility='default' is-declaration-only='yes' id='e70a39e3'/>
+ <function-decl name='uu_error' visibility='default' binding='global' size-in-bits='64'>
+ <return type-id='8f92235e'/>
+ </function-decl>
<function-decl name='uu_avl_pool_create' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='80f4b756'/>
<parameter type-id='b59d7dce'/>
<function-decl name='getzoneid' mangled-name='getzoneid' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getzoneid'>
<return type-id='4da03624'/>
</function-decl>
+ <function-decl name='libspl_assertf' mangled-name='libspl_assertf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libspl_assertf'>
+ <parameter type-id='80f4b756'/>
+ <parameter type-id='80f4b756'/>
+ <parameter type-id='95e97e5e'/>
+ <parameter type-id='80f4b756'/>
+ <parameter is-variadic='yes'/>
+ <return type-id='48b5725f'/>
+ </function-decl>
<function-decl name='sa_commit_shares' mangled-name='sa_commit_shares' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_commit_shares'>
<parameter type-id='9155d4b5'/>
<return type-id='48b5725f'/>
<parameter type-id='b59d7dce'/>
<return type-id='b59d7dce'/>
</function-decl>
+ <function-decl name='__assert_fail' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='80f4b756'/>
+ <parameter type-id='80f4b756'/>
+ <parameter type-id='f0981eeb'/>
+ <parameter type-id='80f4b756'/>
+ <return type-id='48b5725f'/>
+ </function-decl>
<function-decl name='free' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='eaa32e2f'/>
<return type-id='48b5725f'/>
<array-type-def dimensions='1' type-id='b96825af' size-in-bits='24' id='d3490169'>
<subrange length='3' type-id='7359adad' id='56f209d2'/>
</array-type-def>
- <type-decl name='variadic parameter type' id='2c1145c5'/>
<typedef-decl name='zpool_iter_f' type-id='3aebb66f' id='fa476e62'/>
<enum-decl name='data_type_t' naming-typedef-id='8d0687d2' id='aeeae136'>
<underlying-type type-id='9cac1fee'/>
<parameter type-id='3fa542f0'/>
<return type-id='5ce45b60'/>
</function-decl>
- <function-decl name='libspl_assertf' mangled-name='libspl_assertf' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libspl_assertf'>
- <parameter type-id='80f4b756'/>
- <parameter type-id='80f4b756'/>
- <parameter type-id='95e97e5e'/>
- <parameter type-id='80f4b756'/>
- <parameter is-variadic='yes'/>
- <return type-id='48b5725f'/>
- </function-decl>
<function-decl name='__errno_location' visibility='default' binding='global' size-in-bits='64'>
<return type-id='7292109c'/>
</function-decl>
<parameter type-id='80f4b756'/>
<return type-id='26a90f95'/>
</function-decl>
+ <function-decl name='strcpy' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='26a90f95'/>
+ <parameter type-id='80f4b756'/>
+ <return type-id='26a90f95'/>
+ </function-decl>
<function-decl name='strchr' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='80f4b756'/>
<parameter type-id='95e97e5e'/>
<enumerator name='ZPOOL_NUM_PROPS' value='39'/>
</enum-decl>
<typedef-decl name='zpool_prop_t' type-id='af1ba157' id='5d0c23fb'/>
- <typedef-decl name='regoff_t' type-id='95e97e5e' id='54a2a2a8'/>
- <class-decl name='regmatch_t' size-in-bits='64' is-struct='yes' naming-typedef-id='1b941664' visibility='default' id='4f932615'>
- <data-member access='public' layout-offset-in-bits='0'>
- <var-decl name='rm_so' type-id='54a2a2a8' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='32'>
- <var-decl name='rm_eo' type-id='54a2a2a8' visibility='default'/>
- </data-member>
- </class-decl>
- <typedef-decl name='regmatch_t' type-id='4f932615' id='1b941664'/>
- <typedef-decl name='__sighandler_t' type-id='03347643' id='8cdd9566'/>
- <typedef-decl name='ssize_t' type-id='41060289' id='79a0948f'/>
<class-decl name='sigaction' size-in-bits='1216' is-struct='yes' visibility='default' id='fe391c48'>
<data-member access='public' layout-offset-in-bits='0'>
<var-decl name='__sigaction_handler' type-id='ac5ab595' visibility='default'/>
<var-decl name='_unused2' type-id='664ac0b7' visibility='default'/>
</data-member>
</class-decl>
+ <typedef-decl name='regoff_t' type-id='95e97e5e' id='54a2a2a8'/>
+ <class-decl name='regmatch_t' size-in-bits='64' is-struct='yes' naming-typedef-id='1b941664' visibility='default' id='4f932615'>
+ <data-member access='public' layout-offset-in-bits='0'>
+ <var-decl name='rm_so' type-id='54a2a2a8' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='32'>
+ <var-decl name='rm_eo' type-id='54a2a2a8' visibility='default'/>
+ </data-member>
+ </class-decl>
+ <typedef-decl name='regmatch_t' type-id='4f932615' id='1b941664'/>
+ <typedef-decl name='__sighandler_t' type-id='03347643' id='8cdd9566'/>
+ <typedef-decl name='ssize_t' type-id='41060289' id='79a0948f'/>
<pointer-type-def type-id='aa12d1ba' size-in-bits='64' id='822cd80b'/>
<qualified-type-def type-id='822cd80b' restrict='yes' id='e75a27e9'/>
<pointer-type-def type-id='ec1ed955' size-in-bits='64' id='dca988a5'/>
<parameter type-id='80f4b756'/>
<return type-id='822cd80b'/>
</function-decl>
+ <function-decl name='printf' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='80f4b756'/>
+ <parameter is-variadic='yes'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
+ <function-decl name='snprintf' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='26a90f95'/>
+ <parameter type-id='b59d7dce'/>
+ <parameter type-id='80f4b756'/>
+ <parameter is-variadic='yes'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
+ <function-decl name='asprintf' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='8c85230f'/>
+ <parameter type-id='9d26089a'/>
+ <parameter is-variadic='yes'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
<function-decl name='fputc' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='95e97e5e'/>
<parameter type-id='822cd80b'/>
<return type-id='95e97e5e'/>
</function-decl>
- <function-decl name='__getdelim' visibility='default' binding='global' size-in-bits='64'>
+ <function-decl name='getline' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='8c85230f'/>
<parameter type-id='d19b2c25'/>
- <parameter type-id='95e97e5e'/>
<parameter type-id='e75a27e9'/>
<return type-id='41060289'/>
</function-decl>
+ <function-decl name='fread' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='1b7446cd'/>
+ <parameter type-id='b59d7dce'/>
+ <parameter type-id='b59d7dce'/>
+ <parameter type-id='e75a27e9'/>
+ <return type-id='b59d7dce'/>
+ </function-decl>
<function-decl name='rewind' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='822cd80b'/>
<return type-id='48b5725f'/>
<parameter type-id='b59d7dce'/>
<return type-id='eaa32e2f'/>
</function-decl>
+ <function-decl name='memcpy' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='eaa32e2f'/>
+ <parameter type-id='eaa32e2f'/>
+ <parameter type-id='b59d7dce'/>
+ <return type-id='eaa32e2f'/>
+ </function-decl>
<function-decl name='strdup' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='80f4b756'/>
<return type-id='26a90f95'/>
<parameter type-id='95e97e5e'/>
<return type-id='95e97e5e'/>
</function-decl>
+ <function-decl name='read' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='95e97e5e'/>
+ <parameter type-id='eaa32e2f'/>
+ <parameter type-id='b59d7dce'/>
+ <return type-id='79a0948f'/>
+ </function-decl>
<function-decl name='getpid' visibility='default' binding='global' size-in-bits='64'>
<return type-id='3629bad8'/>
</function-decl>
<parameter type-id='80f4b756'/>
<return type-id='95e97e5e'/>
</function-decl>
- <function-decl name='__open_too_many_args' visibility='default' binding='global' size-in-bits='64'>
- <return type-id='48b5725f'/>
- </function-decl>
- <function-decl name='__open_missing_mode' visibility='default' binding='global' size-in-bits='64'>
- <return type-id='48b5725f'/>
- </function-decl>
- <function-decl name='__printf_chk' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='95e97e5e'/>
- <parameter type-id='80f4b756'/>
- <parameter is-variadic='yes'/>
- <return type-id='95e97e5e'/>
- </function-decl>
- <function-decl name='__asprintf_chk' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='8c85230f'/>
- <parameter type-id='95e97e5e'/>
- <parameter type-id='9d26089a'/>
- <parameter is-variadic='yes'/>
- <return type-id='95e97e5e'/>
- </function-decl>
- <function-decl name='__fread_chk' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='1b7446cd'/>
- <parameter type-id='b59d7dce'/>
- <parameter type-id='b59d7dce'/>
- <parameter type-id='b59d7dce'/>
- <parameter type-id='e75a27e9'/>
- <return type-id='b59d7dce'/>
- </function-decl>
- <function-decl name='__read_chk' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='95e97e5e'/>
- <parameter type-id='eaa32e2f'/>
- <parameter type-id='b59d7dce'/>
- <parameter type-id='b59d7dce'/>
- <return type-id='79a0948f'/>
- </function-decl>
<function-decl name='zfs_crypto_get_encryption_root' mangled-name='zfs_crypto_get_encryption_root' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_get_encryption_root'>
<parameter type-id='9200a744' name='zhp'/>
<parameter type-id='37e3bd22' name='is_encroot'/>
<var-decl name='mnt_mntopts' type-id='26a90f95' visibility='default'/>
</data-member>
</class-decl>
+ <union-decl name='pthread_mutexattr_t' size-in-bits='32' naming-typedef-id='8afd6070' visibility='default' id='7300eb00'>
+ <data-member access='public'>
+ <var-decl name='__size' type-id='8e0573fd' visibility='default'/>
+ </data-member>
+ <data-member access='public'>
+ <var-decl name='__align' type-id='95e97e5e' visibility='default'/>
+ </data-member>
+ </union-decl>
+ <typedef-decl name='pthread_mutexattr_t' type-id='7300eb00' id='8afd6070'/>
+ <typedef-decl name='int64_t' type-id='0c9942d2' id='9da381c4'/>
+ <typedef-decl name='__int64_t' type-id='bd54fe1a' id='0c9942d2'/>
+ <typedef-decl name='__gid_t' type-id='f0981eeb' id='d94ec6d9'/>
+ <typedef-decl name='__time_t' type-id='bd54fe1a' id='65eda9c0'/>
+ <class-decl name='tm' size-in-bits='448' is-struct='yes' visibility='default' id='dddf6ca2'>
+ <data-member access='public' layout-offset-in-bits='0'>
+ <var-decl name='tm_sec' type-id='95e97e5e' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='32'>
+ <var-decl name='tm_min' type-id='95e97e5e' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='64'>
+ <var-decl name='tm_hour' type-id='95e97e5e' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='96'>
+ <var-decl name='tm_mday' type-id='95e97e5e' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='128'>
+ <var-decl name='tm_mon' type-id='95e97e5e' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='160'>
+ <var-decl name='tm_year' type-id='95e97e5e' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='192'>
+ <var-decl name='tm_wday' type-id='95e97e5e' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='224'>
+ <var-decl name='tm_yday' type-id='95e97e5e' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='256'>
+ <var-decl name='tm_isdst' type-id='95e97e5e' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='320'>
+ <var-decl name='tm_gmtoff' type-id='bd54fe1a' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='384'>
+ <var-decl name='tm_zone' type-id='80f4b756' visibility='default'/>
+ </data-member>
+ </class-decl>
+ <typedef-decl name='time_t' type-id='65eda9c0' id='c9d12d66'/>
<class-decl name='group' size-in-bits='256' is-struct='yes' visibility='default' id='01a1b934'>
<data-member access='public' layout-offset-in-bits='0'>
<var-decl name='gr_name' type-id='26a90f95' visibility='default'/>
<data-member access='public' layout-offset-in-bits='192'>
<var-decl name='mnt_opts' type-id='26a90f95' visibility='default'/>
</data-member>
- <data-member access='public' layout-offset-in-bits='256'>
- <var-decl name='mnt_freq' type-id='95e97e5e' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='288'>
- <var-decl name='mnt_passno' type-id='95e97e5e' visibility='default'/>
- </data-member>
- </class-decl>
- <class-decl name='passwd' size-in-bits='384' is-struct='yes' visibility='default' id='a63d15a3'>
- <data-member access='public' layout-offset-in-bits='0'>
- <var-decl name='pw_name' type-id='26a90f95' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='64'>
- <var-decl name='pw_passwd' type-id='26a90f95' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='128'>
- <var-decl name='pw_uid' type-id='cc5fcceb' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='160'>
- <var-decl name='pw_gid' type-id='d94ec6d9' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='192'>
- <var-decl name='pw_gecos' type-id='26a90f95' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='256'>
- <var-decl name='pw_dir' type-id='26a90f95' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='320'>
- <var-decl name='pw_shell' type-id='26a90f95' visibility='default'/>
- </data-member>
- </class-decl>
- <union-decl name='pthread_mutexattr_t' size-in-bits='32' naming-typedef-id='8afd6070' visibility='default' id='7300eb00'>
- <data-member access='public'>
- <var-decl name='__size' type-id='8e0573fd' visibility='default'/>
- </data-member>
- <data-member access='public'>
- <var-decl name='__align' type-id='95e97e5e' visibility='default'/>
- </data-member>
- </union-decl>
- <typedef-decl name='pthread_mutexattr_t' type-id='7300eb00' id='8afd6070'/>
- <typedef-decl name='int64_t' type-id='0c9942d2' id='9da381c4'/>
- <typedef-decl name='__int64_t' type-id='bd54fe1a' id='0c9942d2'/>
- <typedef-decl name='__gid_t' type-id='f0981eeb' id='d94ec6d9'/>
- <typedef-decl name='__time_t' type-id='bd54fe1a' id='65eda9c0'/>
- <class-decl name='tm' size-in-bits='448' is-struct='yes' visibility='default' id='dddf6ca2'>
- <data-member access='public' layout-offset-in-bits='0'>
- <var-decl name='tm_sec' type-id='95e97e5e' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='32'>
- <var-decl name='tm_min' type-id='95e97e5e' visibility='default'/>
+ <data-member access='public' layout-offset-in-bits='256'>
+ <var-decl name='mnt_freq' type-id='95e97e5e' visibility='default'/>
</data-member>
- <data-member access='public' layout-offset-in-bits='64'>
- <var-decl name='tm_hour' type-id='95e97e5e' visibility='default'/>
+ <data-member access='public' layout-offset-in-bits='288'>
+ <var-decl name='mnt_passno' type-id='95e97e5e' visibility='default'/>
</data-member>
- <data-member access='public' layout-offset-in-bits='96'>
- <var-decl name='tm_mday' type-id='95e97e5e' visibility='default'/>
+ </class-decl>
+ <class-decl name='passwd' size-in-bits='384' is-struct='yes' visibility='default' id='a63d15a3'>
+ <data-member access='public' layout-offset-in-bits='0'>
+ <var-decl name='pw_name' type-id='26a90f95' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='64'>
+ <var-decl name='pw_passwd' type-id='26a90f95' visibility='default'/>
</data-member>
<data-member access='public' layout-offset-in-bits='128'>
- <var-decl name='tm_mon' type-id='95e97e5e' visibility='default'/>
+ <var-decl name='pw_uid' type-id='cc5fcceb' visibility='default'/>
</data-member>
<data-member access='public' layout-offset-in-bits='160'>
- <var-decl name='tm_year' type-id='95e97e5e' visibility='default'/>
+ <var-decl name='pw_gid' type-id='d94ec6d9' visibility='default'/>
</data-member>
<data-member access='public' layout-offset-in-bits='192'>
- <var-decl name='tm_wday' type-id='95e97e5e' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='224'>
- <var-decl name='tm_yday' type-id='95e97e5e' visibility='default'/>
+ <var-decl name='pw_gecos' type-id='26a90f95' visibility='default'/>
</data-member>
<data-member access='public' layout-offset-in-bits='256'>
- <var-decl name='tm_isdst' type-id='95e97e5e' visibility='default'/>
+ <var-decl name='pw_dir' type-id='26a90f95' visibility='default'/>
</data-member>
<data-member access='public' layout-offset-in-bits='320'>
- <var-decl name='tm_gmtoff' type-id='bd54fe1a' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='384'>
- <var-decl name='tm_zone' type-id='80f4b756' visibility='default'/>
+ <var-decl name='pw_shell' type-id='26a90f95' visibility='default'/>
</data-member>
</class-decl>
- <typedef-decl name='time_t' type-id='65eda9c0' id='c9d12d66'/>
<typedef-decl name='uid_t' type-id='cc5fcceb' id='354978ed'/>
<typedef-decl name='prop_changelist_t' type-id='d86edc51' id='eae6431d'/>
<pointer-type-def type-id='fba6cb51' size-in-bits='64' id='32adbf30'/>
<parameter type-id='8f2c7109'/>
<return type-id='95e97e5e'/>
</function-decl>
- <function-decl name='strtol' visibility='default' binding='global' size-in-bits='64'>
+ <function-decl name='fprintf' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='e75a27e9'/>
<parameter type-id='9d26089a'/>
- <parameter type-id='8c85230f'/>
- <parameter type-id='95e97e5e'/>
- <return type-id='bd54fe1a'/>
+ <parameter is-variadic='yes'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
+ <function-decl name='atoi' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='80f4b756'/>
+ <return type-id='95e97e5e'/>
</function-decl>
<function-decl name='strtoul' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='9d26089a'/>
<parameter type-id='9d26089a'/>
<return type-id='26a90f95'/>
</function-decl>
+ <function-decl name='ioctl' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='95e97e5e'/>
+ <parameter type-id='7359adad'/>
+ <parameter is-variadic='yes'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
<function-decl name='strftime' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='266fe297'/>
<parameter type-id='b59d7dce'/>
<parameter type-id='f099ad08'/>
<return type-id='d915a820'/>
</function-decl>
- <function-decl name='__fprintf_chk' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='e75a27e9'/>
- <parameter type-id='95e97e5e'/>
- <parameter type-id='9d26089a'/>
- <parameter is-variadic='yes'/>
- <return type-id='95e97e5e'/>
- </function-decl>
- <function-decl name='ioctl' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='95e97e5e'/>
- <parameter type-id='7359adad'/>
- <parameter is-variadic='yes'/>
- <return type-id='95e97e5e'/>
- </function-decl>
<function-decl name='zfs_type_to_name' mangled-name='zfs_type_to_name' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_type_to_name'>
<parameter type-id='2e45de5d' name='type'/>
<return type-id='80f4b756'/>
<parameter type-id='7292109c'/>
<return type-id='95e97e5e'/>
</function-decl>
- <function-decl name='pwrite64' visibility='default' binding='global' size-in-bits='64'>
+ <function-decl name='memset' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='eaa32e2f'/>
+ <parameter type-id='95e97e5e'/>
+ <parameter type-id='b59d7dce'/>
+ <return type-id='eaa32e2f'/>
+ </function-decl>
+ <function-decl name='fstat64' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='95e97e5e'/>
+ <parameter type-id='62f7a03d'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
+ <function-decl name='pread64' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='95e97e5e'/>
<parameter type-id='eaa32e2f'/>
<parameter type-id='b59d7dce'/>
<parameter type-id='724e4de6'/>
<return type-id='79a0948f'/>
</function-decl>
- <function-decl name='__pread64_chk' visibility='default' binding='global' size-in-bits='64'>
+ <function-decl name='pwrite64' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='95e97e5e'/>
<parameter type-id='eaa32e2f'/>
<parameter type-id='b59d7dce'/>
<parameter type-id='724e4de6'/>
- <parameter type-id='b59d7dce'/>
<return type-id='79a0948f'/>
</function-decl>
- <function-decl name='fstat64' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='95e97e5e'/>
- <parameter type-id='62f7a03d'/>
- <return type-id='95e97e5e'/>
- </function-decl>
<function-decl name='zcmd_write_conf_nvlist' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='b0382bb3'/>
<parameter type-id='e4ec4540'/>
</class-decl>
<typedef-decl name='get_all_cb_t' type-id='803dac95' id='9b293607'/>
<typedef-decl name='tpool_t' type-id='88d1b7f9' id='b1bbf10d'/>
- <typedef-decl name='DIR' type-id='20cd73f2' id='54a5d683'/>
- <typedef-decl name='mode_t' type-id='e1c52942' id='d50d396c'/>
- <typedef-decl name='__compar_fn_t' type-id='585e1de9' id='aba7edd8'/>
<class-decl name='dirent64' size-in-bits='2240' is-struct='yes' visibility='default' id='5725d813'>
<data-member access='public' layout-offset-in-bits='0'>
<var-decl name='d_ino' type-id='71288a47' visibility='default'/>
<typedef-decl name='__fsblkcnt64_t' type-id='7359adad' id='95fe1a02'/>
<typedef-decl name='__fsfilcnt64_t' type-id='7359adad' id='0c3a4dde'/>
<typedef-decl name='__fsword_t' type-id='bd54fe1a' id='6028cbfe'/>
+ <typedef-decl name='DIR' type-id='20cd73f2' id='54a5d683'/>
+ <typedef-decl name='mode_t' type-id='e1c52942' id='d50d396c'/>
+ <typedef-decl name='__compar_fn_t' type-id='585e1de9' id='aba7edd8'/>
<pointer-type-def type-id='54a5d683' size-in-bits='64' id='f09217ba'/>
<pointer-type-def type-id='5725d813' size-in-bits='64' id='07b96073'/>
<pointer-type-def type-id='9b293607' size-in-bits='64' id='77bf1784'/>
<parameter type-id='9155d4b5'/>
<return type-id='48b5725f'/>
</function-decl>
- <function-decl name='fdopendir' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='95e97e5e'/>
- <return type-id='f09217ba'/>
- </function-decl>
<function-decl name='closedir' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='f09217ba'/>
<return type-id='95e97e5e'/>
</function-decl>
+ <function-decl name='fdopendir' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='95e97e5e'/>
+ <return type-id='f09217ba'/>
+ </function-decl>
<function-decl name='readdir64' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='f09217ba'/>
<return type-id='07b96073'/>
<parameter type-id='aba7edd8'/>
<return type-id='48b5725f'/>
</function-decl>
- <function-decl name='rmdir' visibility='default' binding='global' size-in-bits='64'>
+ <function-decl name='statfs64' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='80f4b756'/>
+ <parameter type-id='7fd094c8'/>
<return type-id='95e97e5e'/>
</function-decl>
- <function-decl name='__openat_too_many_args' visibility='default' binding='global' size-in-bits='64'>
- <return type-id='48b5725f'/>
- </function-decl>
- <function-decl name='__openat_missing_mode' visibility='default' binding='global' size-in-bits='64'>
- <return type-id='48b5725f'/>
- </function-decl>
- <function-decl name='statfs64' visibility='default' binding='global' size-in-bits='64'>
+ <function-decl name='rmdir' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='80f4b756'/>
- <parameter type-id='7fd094c8'/>
<return type-id='95e97e5e'/>
</function-decl>
<function-decl name='zfs_realloc' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='80f4b756'/>
<return type-id='c19b74c3'/>
</function-decl>
+ <function-decl name='zpool_prop_unsupported' mangled-name='zpool_prop_unsupported' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_unsupported'>
+ <parameter type-id='80f4b756'/>
+ <return type-id='c19b74c3'/>
+ </function-decl>
<function-decl name='zpool_prop_index_to_string' mangled-name='zpool_prop_index_to_string' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_index_to_string'>
<parameter type-id='5d0c23fb'/>
<parameter type-id='9c313c2d'/>
<parameter type-id='95e97e5e'/>
<return type-id='3a47d82b'/>
</function-decl>
+ <function-decl name='realpath' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='9d26089a'/>
+ <parameter type-id='266fe297'/>
+ <return type-id='26a90f95'/>
+ </function-decl>
<function-decl name='memcmp' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='eaa32e2f'/>
<parameter type-id='eaa32e2f'/>
<parameter type-id='8c85230f'/>
<return type-id='26a90f95'/>
</function-decl>
- <function-decl name='ctime_r' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='d6e2847c'/>
- <parameter type-id='266fe297'/>
- <return type-id='26a90f95'/>
- </function-decl>
- <function-decl name='__realpath_chk' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='9d26089a'/>
- <parameter type-id='266fe297'/>
- <parameter type-id='b59d7dce'/>
- <return type-id='26a90f95'/>
- </function-decl>
<function-decl name='munmap' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='eaa32e2f'/>
<parameter type-id='b59d7dce'/>
<parameter type-id='f1cadedf'/>
<return type-id='95e97e5e'/>
</function-decl>
+ <function-decl name='ctime_r' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='d6e2847c'/>
+ <parameter type-id='266fe297'/>
+ <return type-id='26a90f95'/>
+ </function-decl>
<function-decl name='zpool_standard_error' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='b0382bb3'/>
<parameter type-id='95e97e5e'/>
<var-decl name='drr_checksum' type-id='39730d0b' visibility='default'/>
</data-member>
</class-decl>
- <class-decl name='__cancel_jmp_buf_tag' size-in-bits='576' is-struct='yes' visibility='default' id='8901473c'>
- <data-member access='public' layout-offset-in-bits='0'>
- <var-decl name='__cancel_jmp_buf' type-id='379a1ab7' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='512'>
- <var-decl name='__mask_was_saved' type-id='95e97e5e' visibility='default'/>
- </data-member>
- </class-decl>
- <class-decl name='__pthread_unwind_buf_t' size-in-bits='832' is-struct='yes' naming-typedef-id='4423cf7f' visibility='default' id='a0abc656'>
- <data-member access='public' layout-offset-in-bits='0'>
- <var-decl name='__cancel_jmp_buf' type-id='f5da478b' visibility='default'/>
- </data-member>
- <data-member access='public' layout-offset-in-bits='576'>
- <var-decl name='__pad' type-id='209ef23f' visibility='default'/>
- </data-member>
- </class-decl>
- <typedef-decl name='__pthread_unwind_buf_t' type-id='a0abc656' id='4423cf7f'/>
<typedef-decl name='__jmp_buf' type-id='5d4efd44' id='379a1ab7'/>
<typedef-decl name='__clockid_t' type-id='95e97e5e' id='08f9a87a'/>
<typedef-decl name='__timer_t' type-id='eaa32e2f' id='df209b60'/>
</data-member>
</class-decl>
<typedef-decl name='timer_t' type-id='df209b60' id='b07ae406'/>
+ <class-decl name='__cancel_jmp_buf_tag' size-in-bits='576' is-struct='yes' visibility='default' id='8901473c'>
+ <data-member access='public' layout-offset-in-bits='0'>
+ <var-decl name='__cancel_jmp_buf' type-id='379a1ab7' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='512'>
+ <var-decl name='__mask_was_saved' type-id='95e97e5e' visibility='default'/>
+ </data-member>
+ </class-decl>
+ <class-decl name='__pthread_unwind_buf_t' size-in-bits='832' is-struct='yes' naming-typedef-id='4423cf7f' visibility='default' id='a0abc656'>
+ <data-member access='public' layout-offset-in-bits='0'>
+ <var-decl name='__cancel_jmp_buf' type-id='f5da478b' visibility='default'/>
+ </data-member>
+ <data-member access='public' layout-offset-in-bits='576'>
+ <var-decl name='__pad' type-id='209ef23f' visibility='default'/>
+ </data-member>
+ </class-decl>
+ <typedef-decl name='__pthread_unwind_buf_t' type-id='a0abc656' id='4423cf7f'/>
<typedef-decl name='Byte' type-id='002ac4a6' id='efb9ba06'/>
<typedef-decl name='uLong' type-id='7359adad' id='5bbcce85'/>
<typedef-decl name='Bytef' type-id='efb9ba06' id='c1606520'/>
<parameter type-id='eaa32e2f'/>
<return type-id='95e97e5e'/>
</function-decl>
+ <function-decl name='pthread_sigmask' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='95e97e5e'/>
+ <parameter type-id='5a8729d0'/>
+ <parameter type-id='65e6ec45'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
<function-decl name='pthread_exit' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='eaa32e2f'/>
<return type-id='48b5725f'/>
<parameter type-id='95e97e5e'/>
<return type-id='95e97e5e'/>
</function-decl>
+ <function-decl name='sprintf' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='26a90f95'/>
+ <parameter type-id='80f4b756'/>
+ <parameter is-variadic='yes'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
<function-decl name='perror' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='80f4b756'/>
<return type-id='48b5725f'/>
<function-decl name='pause' visibility='default' binding='global' size-in-bits='64'>
<return type-id='95e97e5e'/>
</function-decl>
- <function-decl name='pthread_sigmask' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='95e97e5e'/>
- <parameter type-id='5a8729d0'/>
- <parameter type-id='65e6ec45'/>
- <return type-id='95e97e5e'/>
- </function-decl>
<function-decl name='uncompress' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='4c667223'/>
<parameter type-id='60db3356'/>
<parameter type-id='80f4b756'/>
<return type-id='26a90f95'/>
</function-decl>
- <function-decl name='zpool_prop_unsupported' mangled-name='zpool_prop_unsupported' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_unsupported'>
- <parameter type-id='80f4b756'/>
- <return type-id='c19b74c3'/>
- </function-decl>
<function-decl name='zpool_feature_init' mangled-name='zpool_feature_init' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_feature_init'>
<return type-id='48b5725f'/>
</function-decl>
<parameter type-id='62f7a03d'/>
<return type-id='95e97e5e'/>
</function-decl>
+ <function-decl name='pow' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='a0eb0f08'/>
+ <parameter type-id='a0eb0f08'/>
+ <return type-id='a0eb0f08'/>
+ </function-decl>
<function-decl name='__ctype_toupper_loc' visibility='default' binding='global' size-in-bits='64'>
<return type-id='24f95ba5'/>
</function-decl>
<parameter type-id='d33f11cb'/>
<return type-id='48b5725f'/>
</function-decl>
- <function-decl name='putc' visibility='default' binding='global' size-in-bits='64'>
+ <function-decl name='vprintf' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='80f4b756'/>
+ <parameter type-id='b7f2d5e6'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
+ <function-decl name='vsnprintf' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='26a90f95'/>
+ <parameter type-id='b59d7dce'/>
+ <parameter type-id='80f4b756'/>
+ <parameter type-id='b7f2d5e6'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
+ <function-decl name='vasprintf' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='8c85230f'/>
+ <parameter type-id='9d26089a'/>
+ <parameter type-id='b7f2d5e6'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
+ <function-decl name='putchar' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='95e97e5e'/>
- <parameter type-id='822cd80b'/>
<return type-id='95e97e5e'/>
</function-decl>
<function-decl name='puts' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='b59d7dce'/>
<return type-id='95e97e5e'/>
</function-decl>
+ <function-decl name='waitpid' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='3629bad8'/>
+ <parameter type-id='7292109c'/>
+ <parameter type-id='95e97e5e'/>
+ <return type-id='3629bad8'/>
+ </function-decl>
<function-decl name='access' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='80f4b756'/>
<parameter type-id='95e97e5e'/>
<function-decl name='fork' visibility='default' binding='global' size-in-bits='64'>
<return type-id='3629bad8'/>
</function-decl>
- <function-decl name='pow' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='a0eb0f08'/>
- <parameter type-id='a0eb0f08'/>
- <return type-id='a0eb0f08'/>
- </function-decl>
- <function-decl name='__vfprintf_chk' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='e75a27e9'/>
- <parameter type-id='95e97e5e'/>
- <parameter type-id='9d26089a'/>
- <parameter type-id='b7f2d5e6'/>
- <return type-id='95e97e5e'/>
- </function-decl>
- <function-decl name='__vasprintf_chk' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='8c85230f'/>
- <parameter type-id='95e97e5e'/>
- <parameter type-id='9d26089a'/>
- <parameter type-id='b7f2d5e6'/>
- <return type-id='95e97e5e'/>
- </function-decl>
- <function-decl name='waitpid' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='3629bad8'/>
- <parameter type-id='7292109c'/>
- <parameter type-id='95e97e5e'/>
- <return type-id='3629bad8'/>
- </function-decl>
<function-decl name='namespace_clear' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='b0382bb3'/>
<return type-id='48b5725f'/>
</abi-instr>
<abi-instr address-size='64' path='lib/libzfs/os/linux/libzfs_mount_os.c' language='LANG_C99'>
<pointer-type-def type-id='7359adad' size-in-bits='64' id='1d2c2b85'/>
- <function-decl name='geteuid' visibility='default' binding='global' size-in-bits='64'>
- <return type-id='cc5fcceb'/>
- </function-decl>
<function-decl name='mount' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='80f4b756'/>
<parameter type-id='80f4b756'/>
<parameter type-id='95e97e5e'/>
<return type-id='95e97e5e'/>
</function-decl>
+ <function-decl name='geteuid' visibility='default' binding='global' size-in-bits='64'>
+ <return type-id='cc5fcceb'/>
+ </function-decl>
<function-decl name='zfs_parse_mount_options' mangled-name='zfs_parse_mount_options' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_parse_mount_options'>
<parameter type-id='80f4b756' name='mntopts'/>
<parameter type-id='1d2c2b85' name='mntflags'/>
</data-member>
</class-decl>
<pointer-type-def type-id='b440e872' size-in-bits='64' id='3ac36db0'/>
- <function-decl name='__poll_chk' visibility='default' binding='global' size-in-bits='64'>
- <parameter type-id='3ac36db0'/>
- <parameter type-id='555eef66'/>
+ <function-decl name='strtol' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='9d26089a'/>
+ <parameter type-id='8c85230f'/>
<parameter type-id='95e97e5e'/>
- <parameter type-id='7359adad'/>
- <return type-id='95e97e5e'/>
+ <return type-id='bd54fe1a'/>
</function-decl>
<function-decl name='inotify_init1' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='95e97e5e'/>
<parameter type-id='8f92235e'/>
<return type-id='95e97e5e'/>
</function-decl>
+ <function-decl name='poll' visibility='default' binding='global' size-in-bits='64'>
+ <parameter type-id='3ac36db0'/>
+ <parameter type-id='555eef66'/>
+ <parameter type-id='95e97e5e'/>
+ <return type-id='95e97e5e'/>
+ </function-decl>
<function-decl name='timerfd_create' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='08f9a87a'/>
<parameter type-id='95e97e5e'/>
<parameter type-id='80f4b756'/>
<return type-id='80f4b756'/>
</function-decl>
- <function-decl name='__readlink_chk' visibility='default' binding='global' size-in-bits='64'>
+ <function-decl name='readlink' visibility='default' binding='global' size-in-bits='64'>
<parameter type-id='9d26089a'/>
<parameter type-id='266fe297'/>
<parameter type-id='b59d7dce'/>
- <parameter type-id='b59d7dce'/>
<return type-id='79a0948f'/>
</function-decl>
<function-decl name='zfs_get_enclosure_sysfs_path' mangled-name='zfs_get_enclosure_sysfs_path' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_enclosure_sysfs_path'>
<class-decl name='blkid_struct_dev_iterate' is-struct='yes' visibility='default' is-declaration-only='yes' id='d88420d6'/>
<class-decl name='udev_list_entry' is-struct='yes' visibility='default' is-declaration-only='yes' id='e7dbdca3'/>
<typedef-decl name='pool_vdev_iter_f' type-id='6c16a6c8' id='dff793e0'/>
+ <typedef-decl name='__useconds_t' type-id='f0981eeb' id='4e80d4b1'/>
<typedef-decl name='blkid_dev' type-id='8433f053' id='f47b023a'/>
<typedef-decl name='blkid_cache' type-id='940e3afc' id='0882dfdf'/>
<typedef-decl name='blkid_dev_iterate' type-id='b8fa2efc' id='f4760fa7'/>
- <typedef-decl name='__useconds_t' type-id='f0981eeb' id='4e80d4b1'/>
<pointer-type-def type-id='0882dfdf' size-in-bits='64' id='2e3e7caa'/>
<pointer-type-def type-id='f47b023a' size-in-bits='64' id='d87f9b75'/>
<pointer-type-def type-id='09286066' size-in-bits='64' id='940e3afc'/>
</data-member>
</class-decl>
<typedef-decl name='zfeature_info_t' type-id='1178d146' id='83f29ca2'/>
- <typedef-decl name='__free_fn_t' type-id='b7f9d8e6' id='3ff5e51e'/>
<class-decl name='dirent' size-in-bits='2240' is-struct='yes' visibility='default' id='611586a1'>
<data-member access='public' layout-offset-in-bits='0'>
<var-decl name='d_ino' type-id='71288a47' visibility='default'/>
<var-decl name='d_name' type-id='d1617432' visibility='default'/>
</data-member>
</class-decl>
+ <typedef-decl name='__free_fn_t' type-id='b7f9d8e6' id='3ff5e51e'/>
<class-decl name='zfs_mod_supported_features' size-in-bits='128' is-struct='yes' visibility='default' id='3eee3342'>
<data-member access='public' layout-offset-in-bits='0'>
<var-decl name='tree' type-id='eaa32e2f' visibility='default'/>
module/zfs/ddt_zap.c \
module/zfs/dmu.c \
module/zfs/dmu_diff.c \
+ module/zfs/dmu_direct.c \
module/zfs/dmu_object.c \
module/zfs/dmu_objset.c \
module/zfs/dmu_recv.c \
abd_cache_reap_now(void)
{
}
+
+/*
+ * Borrow a raw buffer from an ABD without copying the contents of the ABD
+ * into the buffer. If the ABD is scattered, this will alloate a raw buffer
+ * whose contents are undefined. To copy over the existing data in the ABD, use
+ * abd_borrow_buf_copy() instead.
+ */
+void *
+abd_borrow_buf(abd_t *abd, size_t n)
+{
+ void *buf;
+ abd_verify(abd);
+ ASSERT3U(abd->abd_size, >=, 0);
+ if (abd_is_linear(abd)) {
+ buf = abd_to_buf(abd);
+ } else {
+ buf = zio_buf_alloc(n);
+ }
+#ifdef ZFS_DEBUG
+ (void) zfs_refcount_add_many(&abd->abd_children, n, buf);
+#endif
+ return (buf);
+}
+
+void *
+abd_borrow_buf_copy(abd_t *abd, size_t n)
+{
+ void *buf = abd_borrow_buf(abd, n);
+ if (!abd_is_linear(abd)) {
+ abd_copy_to_buf(buf, abd, n);
+ }
+ return (buf);
+}
+
+/*
+ * Return a borrowed raw buffer to an ABD. If the ABD is scattered, this will
+ * no change the contents of the ABD and will ASSERT that you didn't modify
+ * the buffer since it was borrowed. If you want any changes you made to buf to
+ * be copied back to abd, use abd_return_buf_copy() instead.
+ */
+void
+abd_return_buf(abd_t *abd, void *buf, size_t n)
+{
+ abd_verify(abd);
+ ASSERT3U(abd->abd_size, >=, n);
+#ifdef ZFS_DEBUG
+ (void) zfs_refcount_remove_many(&abd->abd_children, n, buf);
+#endif
+ if (abd_is_linear(abd)) {
+ ASSERT3P(buf, ==, abd_to_buf(abd));
+ } else {
+ ASSERT0(abd_cmp_buf(abd, buf, n));
+ zio_buf_free(buf, n);
+ }
+}
+
+void
+abd_return_buf_copy(abd_t *abd, void *buf, size_t n)
+{
+ if (!abd_is_linear(abd)) {
+ abd_copy_from_buf(abd, buf, n);
+ }
+ abd_return_buf(abd, buf, n);
+}
.It Sy zfs_default_ibs Ns = Ns Sy 17 Po 128 KiB Pc Pq int
Default dnode indirect block size as a power of 2.
.
+.It Sy zfs_dio_enabled Ns = Ns Sy 0 Ns | Ns 1 Pq int
+Enable Direct I/O.
+If this setting is 0, then all I/O requests will be directed through the ARC
+acting as though the dataset property
+.Sy direct
+was set to
+.Sy disabled .
+.
.It Sy zfs_history_output_max Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq u64
When attempting to log an output nvlist of an ioctl in the on-disk history,
the output will not be stored if it is larger than this size (in bytes).
.Sy ASHIFT_MAX Po 16 Pc ,
but this may negatively impact pool space efficiency.
.
+.It Sy zfs_vdev_direct_write_verify Ns = Ns Sy Linux 1 | FreeBSD 0 Pq uint
+If non-zero, then a Direct I/O write's checksum will be verified every
+time the write is issued and before it is commited to the block pointer.
+In the event the checksum is not valid then the I/O operation will return EIO.
+This module parameter can be used to detect if the
+contents of the users buffer have changed in the process of doing a Direct I/O
+write.
+It can also help to identify if reported checksum errors are tied to Direct I/O
+writes.
+Each verify error causes a
+.Sy dio_verify
+zevent.
+Direct Write I/O checkum verify errors can be seen with
+.Nm zpool Cm status Fl d .
+The default value for this is 1 on Linux, but is 0 for
+.Fx
+because user pages can be placed under write protection in
+.Fx
+before the Direct I/O write is issued.
+.
.It Sy zfs_vdev_min_auto_ashift Ns = Ns Sy ASHIFT_MIN Po 9 Pc Pq uint
Minimum ashift used when creating new top-level vdevs.
.
.Pp
.Sy zfs_delay_scale No \(mu Sy zfs_dirty_data_max Em must No be smaller than Sy 2^64 .
.
+.It Sy zfs_dio_write_verify_events_per_second Ns = Ns Sy 20 Ns /s Pq uint
+Rate limit Direct I/O write verify events to this many per second.
+.
.It Sy zfs_disable_ivset_guid_check Ns = Ns Sy 0 Ns | Ns 1 Pq int
Disables requirement for IVset GUIDs to be present and match when doing a raw
receive of encrypted datasets.
section of
.Xr zfsconcepts 7 .
.It Xo
+.Sy direct Ns = Ns Sy disabled Ns | Ns Sy standard Ns | Ns Sy always
+.Xc
+Controls the behavior of Direct I/O requests
+.Pq e.g. Dv O_DIRECT .
+The
+.Sy standard
+behavior for Direct I/O requests is to bypass the ARC when possible.
+These requests will not be cached and performance will be limited by the
+raw speed of the underlying disks
+.Pq Dv this is the default .
+.Sy always
+causes every properly aligned read or write to be treated as a direct request.
+.Sy disabled
+causes the O_DIRECT flag to be silently ignored and all direct requests will
+be handled by the ARC.
+This is the default behavior for OpenZFS 2.2 and prior releases.
+.Pp
+Bypassing the ARC requires that a direct request be correctly aligned.
+For write requests the starting offset and size of the request must be
+.Sy recordsize Ns
+-aligned, if not then the unaligned portion of the request will be silently
+redirected through the ARC.
+For read requests there is no
+.Sy recordsize
+alignment restriction on either the starting offset or size.
+All direct requests must use a page-aligned memory buffer and the request
+size must be a multiple of the page size or an error is returned.
+.Pp
+Concurrently mixing buffered and direct requests to overlapping regions of
+a file can decrease performance.
+However, the resulting file will always be coherent.
+For example, a direct read after a buffered write will return the data
+from the buffered write.
+Furthermore, if an application uses
+.Xr mmap 2
+based file access then in order to maintain coherency all direct requests
+are converted to buffered requests while the file is mapped.
+Currently Direct I/O is not supported with zvols.
+If dedup is enabled on a dataset, Direct I/O writes will not check for
+deduplication.
+Deduplication and Direct I/O writes are currently incompatible.
+.It Xo
.Sy dnodesize Ns = Ns Sy legacy Ns | Ns Sy auto Ns | Ns Sy 1k Ns | Ns
.Sy 2k Ns | Ns Sy 4k Ns | Ns Sy 8k Ns | Ns Sy 16k
.Xc
The number of delay events is ratelimited by the
.Sy zfs_slow_io_events_per_second
module parameter.
+.It Sy dio_verify
+Issued when there was a checksum verify error after a Direct I/O write has been
+issued.
+This event can only take place if the module parameter
+.Sy zfs_vdev_direct_write_verify
+is not set to zero.
+See
+.Xr zfs 4
+for more details on the
+.Sy zfs_vdev_direct_write_verify
+module paramter.
.It Sy config
Issued every time a vdev change have been done to the pool.
.It Sy zpool
ZIO_STAGE_VDEV_IO_ASSESS:0x00800000:RW--XT
ZIO_STAGE_CHECKSUM_VERIFY:0x01000000:R-----
+ZIO_STAGE_DIO_CHECKSUM_VERIFY:0x02000000:-W----
-ZIO_STAGE_DONE:0x02000000:RWFCXT
+ZIO_STAGE_DONE:0x04000000:RWFCXT
.TE
.
.Sh I/O FLAGS
.Sh SYNOPSIS
.Nm zpool
.Cm status
-.Op Fl DegiLpPstvx
+.Op Fl dDegiLpPstvx
.Op Fl T Sy u Ns | Ns Sy d
.Op Fl c Op Ar SCRIPT1 Ns Oo , Ns Ar SCRIPT2 Oc Ns …
.Oo Ar pool Oc Ns …
Specify
.Sy --json-pool-key-guid
to set pool GUID as key for pool objects instead of pool names.
+.It Fl d
+Display the number of Direct I/O write checksum verify errors that have occured
+on a top-level VDEV.
+See
+.Sx zfs_vdev_direct_write_verify
+in
+.Xr zfs 4
+for details about the conditions that can cause Direct I/O write checksum
+verify failures to occur.
.It Fl D
Display a histogram of deduplication statistics, showing the allocated
.Pq physically present on disk
ddt_stats.o \
ddt_zap.o \
dmu.o \
+ dmu_direct.o \
dmu_diff.o \
dmu_object.o \
dmu_objset.o \
ddt_stats.c \
ddt_zap.c \
dmu.c \
+ dmu_direct.c \
dmu_diff.c \
dmu_object.c \
dmu_objset.c \
#include <sys/uio_impl.h>
#include <sys/vnode.h>
#include <sys/zfs_znode.h>
+#include <sys/byteorder.h>
+#include <sys/lock.h>
+#include <sys/vm.h>
+#include <vm/vm_map.h>
static void
zfs_freeuio(struct uio *uio)
ASSERT3U(zfs_uio_rw(uio), ==, dir);
return (vn_io_fault_uiomove(p, n, GET_UIO_STRUCT(uio)));
}
+
+/*
+ * Check if the uio is page-aligned in memory.
+ */
+boolean_t
+zfs_uio_page_aligned(zfs_uio_t *uio)
+{
+ const struct iovec *iov = GET_UIO_STRUCT(uio)->uio_iov;
+
+ for (int i = zfs_uio_iovcnt(uio); i > 0; iov++, i--) {
+ uintptr_t addr = (uintptr_t)iov->iov_base;
+ size_t size = iov->iov_len;
+ if ((addr & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1))) {
+ return (B_FALSE);
+ }
+ }
+
+ return (B_TRUE);
+}
+
+static void
+zfs_uio_set_pages_to_stable(zfs_uio_t *uio)
+{
+ ASSERT3P(uio->uio_dio.pages, !=, NULL);
+ ASSERT3S(uio->uio_dio.npages, >, 0);
+
+ for (int i = 0; i < uio->uio_dio.npages; i++) {
+ vm_page_t page = uio->uio_dio.pages[i];
+ ASSERT3P(page, !=, NULL);
+
+ MPASS(page == PHYS_TO_VM_PAGE(VM_PAGE_TO_PHYS(page)));
+ vm_page_busy_acquire(page, VM_ALLOC_SBUSY);
+ pmap_remove_write(page);
+ }
+}
+
+static void
+zfs_uio_release_stable_pages(zfs_uio_t *uio)
+{
+ ASSERT3P(uio->uio_dio.pages, !=, NULL);
+ for (int i = 0; i < uio->uio_dio.npages; i++) {
+ vm_page_t page = uio->uio_dio.pages[i];
+
+ ASSERT3P(page, !=, NULL);
+ vm_page_sunbusy(page);
+ }
+}
+
+/*
+ * If the operation is marked as read, then we are stating the pages will be
+ * written to and must be given write access.
+ */
+static int
+zfs_uio_hold_pages(unsigned long start, size_t len, int nr_pages,
+ zfs_uio_rw_t rw, vm_page_t *pages)
+{
+ vm_map_t map;
+ vm_prot_t prot;
+ int count;
+
+ map = &curthread->td_proc->p_vmspace->vm_map;
+ ASSERT3S(len, >, 0);
+
+ prot = rw == UIO_READ ? (VM_PROT_READ | VM_PROT_WRITE) : VM_PROT_READ;
+ count = vm_fault_quick_hold_pages(map, start, len, prot, pages,
+ nr_pages);
+
+ return (count);
+}
+
+void
+zfs_uio_free_dio_pages(zfs_uio_t *uio, zfs_uio_rw_t rw)
+{
+ ASSERT(uio->uio_extflg & UIO_DIRECT);
+ ASSERT3P(uio->uio_dio.pages, !=, NULL);
+ ASSERT(zfs_uio_rw(uio) == rw);
+
+ if (rw == UIO_WRITE)
+ zfs_uio_release_stable_pages(uio);
+
+ vm_page_unhold_pages(&uio->uio_dio.pages[0],
+ uio->uio_dio.npages);
+
+ kmem_free(uio->uio_dio.pages,
+ uio->uio_dio.npages * sizeof (vm_page_t));
+}
+
+static int
+zfs_uio_get_user_pages(unsigned long start, int nr_pages,
+ size_t len, zfs_uio_rw_t rw, vm_page_t *pages)
+{
+ int count;
+
+ count = zfs_uio_hold_pages(start, len, nr_pages, rw, pages);
+
+ if (count != nr_pages) {
+ if (count > 0)
+ vm_page_unhold_pages(pages, count);
+ return (0);
+ }
+
+ ASSERT3S(count, ==, nr_pages);
+
+ return (count);
+}
+
+static int
+zfs_uio_iov_step(struct iovec v, zfs_uio_t *uio, int *numpages)
+{
+ unsigned long addr = (unsigned long)(v.iov_base);
+ size_t len = v.iov_len;
+ int n = DIV_ROUND_UP(len, PAGE_SIZE);
+
+ int res = zfs_uio_get_user_pages(
+ P2ALIGN_TYPED(addr, PAGE_SIZE, unsigned long), n, len,
+ zfs_uio_rw(uio), &uio->uio_dio.pages[uio->uio_dio.npages]);
+
+ if (res != n)
+ return (SET_ERROR(EFAULT));
+
+ ASSERT3U(len, ==, res * PAGE_SIZE);
+ *numpages = res;
+ return (0);
+}
+
+static int
+zfs_uio_get_dio_pages_impl(zfs_uio_t *uio)
+{
+ const struct iovec *iovp = GET_UIO_STRUCT(uio)->uio_iov;
+ size_t len = zfs_uio_resid(uio);
+
+ for (int i = 0; i < zfs_uio_iovcnt(uio); i++) {
+ struct iovec iov;
+ int numpages = 0;
+
+ if (iovp->iov_len == 0) {
+ iovp++;
+ continue;
+ }
+ iov.iov_len = MIN(len, iovp->iov_len);
+ iov.iov_base = iovp->iov_base;
+ int error = zfs_uio_iov_step(iov, uio, &numpages);
+
+ if (error)
+ return (error);
+
+ uio->uio_dio.npages += numpages;
+ len -= iov.iov_len;
+ iovp++;
+ }
+
+ ASSERT0(len);
+
+ return (0);
+}
+
+/*
+ * This function holds user pages into the kernel. In the event that the user
+ * pages are not successfully held an error value is returned.
+ *
+ * On success, 0 is returned.
+ */
+int
+zfs_uio_get_dio_pages_alloc(zfs_uio_t *uio, zfs_uio_rw_t rw)
+{
+ int error = 0;
+ int npages = DIV_ROUND_UP(zfs_uio_resid(uio), PAGE_SIZE);
+ size_t size = npages * sizeof (vm_page_t);
+
+ ASSERT(zfs_uio_rw(uio) == rw);
+
+ uio->uio_dio.pages = kmem_alloc(size, KM_SLEEP);
+
+ error = zfs_uio_get_dio_pages_impl(uio);
+
+ if (error) {
+ vm_page_unhold_pages(&uio->uio_dio.pages[0],
+ uio->uio_dio.npages);
+ kmem_free(uio->uio_dio.pages, size);
+ return (error);
+ }
+
+ ASSERT3S(uio->uio_dio.npages, >, 0);
+
+ /*
+ * Since we will be writing the user pages we must make sure that
+ * they are stable. That way the contents of the pages can not change
+ * while we are doing: compression, checksumming, encryption, parity
+ * calculations or deduplication.
+ */
+ if (zfs_uio_rw(uio) == UIO_WRITE)
+ zfs_uio_set_pages_to_stable(uio);
+
+ uio->uio_extflg |= UIO_DIRECT;
+
+ return (0);
+}
#include <sys/zio.h>
#include <sys/zfs_context.h>
#include <sys/zfs_znode.h>
+#include <sys/vm.h>
typedef struct abd_stats {
kstat_named_t abdstat_struct_size;
void
abd_update_scatter_stats(abd_t *abd, abd_stats_op_t op)
{
- uint_t n = abd_scatter_chunkcnt(abd);
+ uint_t n;
+
+ n = abd_scatter_chunkcnt(abd);
ASSERT(op == ABDSTAT_INCR || op == ABDSTAT_DECR);
int waste = (n << PAGE_SHIFT) - abd->abd_size;
if (op == ABDSTAT_INCR) {
{
uint_t i, n;
- n = abd_scatter_chunkcnt(abd);
- for (i = 0; i < n; i++) {
- kmem_cache_free(abd_chunk_cache,
- ABD_SCATTER(abd).abd_chunks[i]);
+ /*
+ * Scatter ABDs may be constructed by abd_alloc_from_pages() from
+ * an array of pages. In which case they should not be freed.
+ */
+ if (!abd_is_from_pages(abd)) {
+ n = abd_scatter_chunkcnt(abd);
+ for (i = 0; i < n; i++) {
+ kmem_cache_free(abd_chunk_cache,
+ ABD_SCATTER(abd).abd_chunks[i]);
+ }
}
}
void
abd_free_linear_page(abd_t *abd)
{
- /*
- * FreeBSD does not have scatter linear pages
- * so there is an error.
- */
- VERIFY(0);
+ ASSERT3P(abd->abd_u.abd_linear.sf, !=, NULL);
+ zfs_unmap_page(abd->abd_u.abd_linear.sf);
}
/*
return (abd_alloc_linear(size, is_metadata));
}
+static abd_t *
+abd_get_offset_from_pages(abd_t *abd, abd_t *sabd, size_t chunkcnt,
+ size_t new_offset)
+{
+ ASSERT(abd_is_from_pages(sabd));
+
+ /*
+ * Set the child child chunks to point at the parent chunks as
+ * the chunks are just pages and we don't want to copy them.
+ */
+ size_t parent_offset = new_offset / PAGE_SIZE;
+ ASSERT3U(parent_offset, <, abd_scatter_chunkcnt(sabd));
+ for (int i = 0; i < chunkcnt; i++)
+ ABD_SCATTER(abd).abd_chunks[i] =
+ ABD_SCATTER(sabd).abd_chunks[parent_offset + i];
+
+ abd->abd_flags |= ABD_FLAG_FROM_PAGES;
+ return (abd);
+}
+
abd_t *
abd_get_offset_scatter(abd_t *abd, abd_t *sabd, size_t off,
size_t size)
ABD_SCATTER(abd).abd_offset = new_offset & PAGE_MASK;
+ if (abd_is_from_pages(sabd)) {
+ return (abd_get_offset_from_pages(abd, sabd, chunkcnt,
+ new_offset));
+ }
+
/* Copy the scatterlist starting at the correct offset */
(void) memcpy(&ABD_SCATTER(abd).abd_chunks,
&ABD_SCATTER(sabd).abd_chunks[new_offset >> PAGE_SHIFT],
return (abd);
}
+/*
+ * Allocate a scatter ABD structure from user pages.
+ */
+abd_t *
+abd_alloc_from_pages(vm_page_t *pages, unsigned long offset, uint64_t size)
+{
+ VERIFY3U(size, <=, DMU_MAX_ACCESS);
+ ASSERT3U(offset, <, PAGE_SIZE);
+ ASSERT3P(pages, !=, NULL);
+
+ abd_t *abd = abd_alloc_struct(size);
+ abd->abd_flags |= ABD_FLAG_OWNER | ABD_FLAG_FROM_PAGES;
+ abd->abd_size = size;
+
+ if ((offset + size) <= PAGE_SIZE) {
+ /*
+ * There is only a single page worth of data, so we will just
+ * use a linear ABD. We have to make sure to take into account
+ * the offset though. In all other cases our offset will be 0
+ * as we are always PAGE_SIZE aligned.
+ */
+ abd->abd_flags |= ABD_FLAG_LINEAR | ABD_FLAG_LINEAR_PAGE;
+ ABD_LINEAR_BUF(abd) = (char *)zfs_map_page(pages[0],
+ &abd->abd_u.abd_linear.sf) + offset;
+ } else {
+ ABD_SCATTER(abd).abd_offset = offset;
+ ASSERT0(ABD_SCATTER(abd).abd_offset);
+
+ /*
+ * Setting the ABD's abd_chunks to point to the user pages.
+ */
+ for (int i = 0; i < abd_chunkcnt_for_bytes(size); i++)
+ ABD_SCATTER(abd).abd_chunks[i] = pages[i];
+ }
+
+ return (abd);
+}
+
/*
* Initialize the abd_iter.
*/
if (abd_is_linear(abd)) {
aiter->iter_mapsize = abd->abd_size - offset;
paddr = ABD_LINEAR_BUF(abd);
+ } else if (abd_is_from_pages(abd)) {
+ aiter->sf = NULL;
+ offset += ABD_SCATTER(abd).abd_offset;
+ size_t index = offset / PAGE_SIZE;
+ offset &= PAGE_MASK;
+ aiter->iter_mapsize = MIN(PAGE_SIZE - offset,
+ abd->abd_size - aiter->iter_pos);
+ paddr = zfs_map_page(
+ ABD_SCATTER(aiter->iter_abd).abd_chunks[index],
+ &aiter->sf);
} else {
offset += ABD_SCATTER(abd).abd_offset;
paddr = ABD_SCATTER(abd).abd_chunks[offset >> PAGE_SHIFT];
ASSERT3U(aiter->iter_mapsize, >, 0);
}
+ if (abd_is_from_pages(aiter->iter_abd) &&
+ !abd_is_linear_page(aiter->iter_abd)) {
+ ASSERT3P(aiter->sf, !=, NULL);
+ zfs_unmap_page(aiter->sf);
+ }
+
aiter->iter_mapaddr = NULL;
aiter->iter_mapsize = 0;
}
{
kmem_cache_reap_soon(abd_chunk_cache);
}
+
+/*
+ * Borrow a raw buffer from an ABD without copying the contents of the ABD
+ * into the buffer. If the ABD is scattered, this will alloate a raw buffer
+ * whose contents are undefined. To copy over the existing data in the ABD, use
+ * abd_borrow_buf_copy() instead.
+ */
+void *
+abd_borrow_buf(abd_t *abd, size_t n)
+{
+ void *buf;
+ abd_verify(abd);
+ ASSERT3U(abd->abd_size, >=, 0);
+ if (abd_is_linear(abd)) {
+ buf = abd_to_buf(abd);
+ } else {
+ buf = zio_buf_alloc(n);
+ }
+#ifdef ZFS_DEBUG
+ (void) zfs_refcount_add_many(&abd->abd_children, n, buf);
+#endif
+ return (buf);
+}
+
+void *
+abd_borrow_buf_copy(abd_t *abd, size_t n)
+{
+ void *buf = abd_borrow_buf(abd, n);
+ if (!abd_is_linear(abd)) {
+ abd_copy_to_buf(buf, abd, n);
+ }
+ return (buf);
+}
+
+/*
+ * Return a borrowed raw buffer to an ABD. If the ABD is scattered, this will
+ * no change the contents of the ABD and will ASSERT that you didn't modify
+ * the buffer since it was borrowed. If you want any changes you made to buf to
+ * be copied back to abd, use abd_return_buf_copy() instead.
+ */
+void
+abd_return_buf(abd_t *abd, void *buf, size_t n)
+{
+ abd_verify(abd);
+ ASSERT3U(abd->abd_size, >=, n);
+#ifdef ZFS_DEBUG
+ (void) zfs_refcount_remove_many(&abd->abd_children, n, buf);
+#endif
+ if (abd_is_linear(abd)) {
+ ASSERT3P(buf, ==, abd_to_buf(abd));
+ } else {
+ ASSERT0(abd_cmp_buf(abd, buf, n));
+ zio_buf_free(buf, n);
+ }
+}
+
+void
+abd_return_buf_copy(abd_t *abd, void *buf, size_t n)
+{
+ if (!abd_is_linear(abd)) {
+ abd_copy_from_buf(abd, buf, n);
+ }
+ abd_return_buf(abd, buf, n);
+}
#include <sys/racct.h>
void
-zfs_racct_read(uint64_t size, uint64_t iops)
+zfs_racct_read(spa_t *spa, uint64_t size, uint64_t iops, uint32_t flags)
{
curthread->td_ru.ru_inblock += iops;
#ifdef RACCT
#else
(void) size;
#endif /* RACCT */
+
+ spa_iostats_read_add(spa, size, iops, flags);
}
void
-zfs_racct_write(uint64_t size, uint64_t iops)
+zfs_racct_write(spa_t *spa, uint64_t size, uint64_t iops, uint32_t flags)
{
curthread->td_ru.ru_oublock += iops;
#ifdef RACCT
#else
(void) size;
#endif /* RACCT */
+
+ spa_iostats_write_add(spa, size, iops, flags);
}
* but that would make the locking messier
*/
zfs_log_write(zfsvfs->z_log, tx, TX_WRITE, zp, off,
- len, commit, NULL, NULL);
+ len, commit, B_FALSE, NULL, NULL);
zfs_vmobject_wlock(object);
for (i = 0; i < ncount; i++) {
flags |= O_APPEND;
if (ioflags & IO_NDELAY)
flags |= O_NONBLOCK;
+ if (ioflags & IO_DIRECT)
+ flags |= O_DIRECT;
if (ioflags & IO_SYNC)
flags |= O_SYNC;
zfs_freebsd_read(struct vop_read_args *ap)
{
zfs_uio_t uio;
+ int error = 0;
zfs_uio_init(&uio, ap->a_uio);
- return (zfs_read(VTOZ(ap->a_vp), &uio, ioflags(ap->a_ioflag),
- ap->a_cred));
+ error = zfs_read(VTOZ(ap->a_vp), &uio, ioflags(ap->a_ioflag),
+ ap->a_cred);
+ /*
+ * XXX We occasionally get an EFAULT for Direct I/O reads on
+ * FreeBSD 13. This still needs to be resolved. The EFAULT comes
+ * from:
+ * zfs_uio_get__dio_pages_alloc() ->
+ * zfs_uio_get_dio_pages_impl() ->
+ * zfs_uio_iov_step() ->
+ * zfs_uio_get_user_pages().
+ * We return EFAULT from zfs_uio_iov_step(). When a Direct I/O
+ * read fails to map in the user pages (returning EFAULT) the
+ * Direct I/O request is broken up into two separate IO requests
+ * and issued separately using Direct I/O.
+ */
+#ifdef ZFS_DEBUG
+ if (error == EFAULT && uio.uio_extflg & UIO_DIRECT) {
+#if 0
+ printf("%s(%d): Direct I/O read returning EFAULT "
+ "uio = %p, zfs_uio_offset(uio) = %lu "
+ "zfs_uio_resid(uio) = %lu\n",
+ __FUNCTION__, __LINE__, &uio, zfs_uio_offset(&uio),
+ zfs_uio_resid(&uio));
+#endif
+ }
+
+#endif
+ return (error);
}
#ifndef _SYS_SYSPROTO_H_
if (commit)
zil_commit(zv->zv_zilog, ZVOL_OBJ);
rw_exit(&zv->zv_suspend_lock);
+
return (error);
}
abd_t *abd_zero_scatter = NULL;
struct page;
+
/*
* abd_zero_page is assigned to each of the pages of abd_zero_scatter. It will
* point to ZERO_PAGE if it is available or it will be an allocated zero'd
if (abd->abd_flags & ABD_FLAG_MULTI_CHUNK)
ABDSTAT_BUMPDOWN(abdstat_scatter_page_multi_chunk);
- abd_for_each_sg(abd, sg, nr_pages, i) {
- page = sg_page(sg);
- abd_unmark_zfs_page(page);
- order = compound_order(page);
- __free_pages(page, order);
- ASSERT3U(sg->length, <=, PAGE_SIZE << order);
- ABDSTAT_BUMPDOWN(abdstat_scatter_orders[order]);
+ /*
+ * Scatter ABDs may be constructed by abd_alloc_from_pages() from
+ * an array of pages. In which case they should not be freed.
+ */
+ if (!abd_is_from_pages(abd)) {
+ abd_for_each_sg(abd, sg, nr_pages, i) {
+ page = sg_page(sg);
+ abd_unmark_zfs_page(page);
+ order = compound_order(page);
+ __free_pages(page, order);
+ ASSERT3U(sg->length, <=, PAGE_SIZE << order);
+ ABDSTAT_BUMPDOWN(abdstat_scatter_orders[order]);
+ }
}
+
abd_free_sg_table(abd);
}
void
abd_verify_scatter(abd_t *abd)
{
- size_t n;
- int i = 0;
- struct scatterlist *sg = NULL;
-
ASSERT3U(ABD_SCATTER(abd).abd_nents, >, 0);
ASSERT3U(ABD_SCATTER(abd).abd_offset, <,
ABD_SCATTER(abd).abd_sgl->length);
- n = ABD_SCATTER(abd).abd_nents;
+
+#ifdef ZFS_DEBUG
+ struct scatterlist *sg = NULL;
+ size_t n = ABD_SCATTER(abd).abd_nents;
+ int i = 0;
+
abd_for_each_sg(abd, sg, n, i) {
ASSERT3P(sg_page(sg), !=, NULL);
}
+#endif
}
static void
{
/* Transform it back into a scatter ABD for freeing */
struct scatterlist *sg = abd->abd_u.abd_linear.abd_sgl;
+
+ /* When backed by user page unmap it */
+ if (abd_is_from_pages(abd))
+ zfs_kunmap(sg_page(sg));
+
abd->abd_flags &= ~ABD_FLAG_LINEAR;
abd->abd_flags &= ~ABD_FLAG_LINEAR_PAGE;
ABD_SCATTER(abd).abd_nents = 1;
ABD_SCATTER(abd).abd_offset = 0;
ABD_SCATTER(abd).abd_sgl = sg;
abd_free_chunks(abd);
+}
+
+/*
+ * Allocate a scatter ABD structure from user pages. The pages must be
+ * pinned with get_user_pages, or similiar, but need not be mapped via
+ * the kmap interfaces.
+ */
+abd_t *
+abd_alloc_from_pages(struct page **pages, unsigned long offset, uint64_t size)
+{
+ uint_t npages = DIV_ROUND_UP(size, PAGE_SIZE);
+ struct sg_table table;
+
+ VERIFY3U(size, <=, DMU_MAX_ACCESS);
+ ASSERT3U(offset, <, PAGE_SIZE);
+ ASSERT3P(pages, !=, NULL);
+
+ /*
+ * Even if this buf is filesystem metadata, we only track that we
+ * own the underlying data buffer, which is not true in this case.
+ * Therefore, we don't ever use ABD_FLAG_META here.
+ */
+ abd_t *abd = abd_alloc_struct(0);
+ abd->abd_flags |= ABD_FLAG_FROM_PAGES | ABD_FLAG_OWNER;
+ abd->abd_size = size;
+
+ while (sg_alloc_table_from_pages(&table, pages, npages, offset,
+ size, __GFP_NOWARN | GFP_NOIO) != 0) {
+ ABDSTAT_BUMP(abdstat_scatter_sg_table_retry);
+ schedule_timeout_interruptible(1);
+ }
+
+ if ((offset + size) <= PAGE_SIZE) {
+ /*
+ * Since there is only one entry, this ABD can be represented
+ * as a linear buffer. All single-page (4K) ABD's constructed
+ * from a user page can be represented this way as long as the
+ * page is mapped to a virtual address. This allows us to
+ * apply an offset in to the mapped page.
+ *
+ * Note that kmap() must be used, not kmap_atomic(), because
+ * the mapping needs to bet set up on all CPUs. Using kmap()
+ * also enables the user of highmem pages when required.
+ */
+ abd->abd_flags |= ABD_FLAG_LINEAR | ABD_FLAG_LINEAR_PAGE;
+ abd->abd_u.abd_linear.abd_sgl = table.sgl;
+ zfs_kmap(sg_page(table.sgl));
+ ABD_LINEAR_BUF(abd) = sg_virt(table.sgl);
+ } else {
+ ABDSTAT_BUMP(abdstat_scatter_page_multi_chunk);
+ abd->abd_flags |= ABD_FLAG_MULTI_CHUNK;
+
+ ABD_SCATTER(abd).abd_offset = offset;
+ ABD_SCATTER(abd).abd_sgl = table.sgl;
+ ABD_SCATTER(abd).abd_nents = table.nents;
+
+ ASSERT0(ABD_SCATTER(abd).abd_offset);
+ }
- abd_update_scatter_stats(abd, ABDSTAT_DECR);
+ return (abd);
}
/*
ABD_SCATTER(abd).abd_offset = new_offset;
ABD_SCATTER(abd).abd_nents = ABD_SCATTER(sabd).abd_nents - i;
+ if (abd_is_from_pages(sabd))
+ abd->abd_flags |= ABD_FLAG_FROM_PAGES;
+
return (abd);
}
{
}
+/*
+ * Borrow a raw buffer from an ABD without copying the contents of the ABD
+ * into the buffer. If the ABD is scattered, this will allocate a raw buffer
+ * whose contents are undefined. To copy over the existing data in the ABD, use
+ * abd_borrow_buf_copy() instead.
+ */
+void *
+abd_borrow_buf(abd_t *abd, size_t n)
+{
+ void *buf;
+ abd_verify(abd);
+ ASSERT3U(abd->abd_size, >=, 0);
+ /*
+ * In the event the ABD is composed of a single user page from Direct
+ * I/O we can not direclty return the raw buffer. This is a consequence
+ * of not being able to write protect the page and the contents of the
+ * page can be changed at any time by the user.
+ */
+ if (abd_is_from_pages(abd)) {
+ buf = zio_buf_alloc(n);
+ } else if (abd_is_linear(abd)) {
+ buf = abd_to_buf(abd);
+ } else {
+ buf = zio_buf_alloc(n);
+ }
+
+#ifdef ZFS_DEBUG
+ (void) zfs_refcount_add_many(&abd->abd_children, n, buf);
+#endif
+ return (buf);
+}
+
+void *
+abd_borrow_buf_copy(abd_t *abd, size_t n)
+{
+ void *buf = abd_borrow_buf(abd, n);
+
+ /*
+ * In the event the ABD is composed of a single user page from Direct
+ * I/O we must make sure copy the data over into the newly allocated
+ * buffer. This is a consequence of the fact that we can not write
+ * protect the user page and there is a risk the contents of the page
+ * could be changed by the user at any moment.
+ */
+ if (!abd_is_linear(abd) || abd_is_from_pages(abd)) {
+ abd_copy_to_buf(buf, abd, n);
+ }
+ return (buf);
+}
+
+/*
+ * Return a borrowed raw buffer to an ABD. If the ABD is scatterd, this will
+ * not change the contents of the ABD. If you want any changes you made to
+ * buf to be copied back to abd, use abd_return_buf_copy() instead. If the
+ * ABD is not constructed from user pages for Direct I/O then an ASSERT
+ * checks to make sure the contents of buffer have not changed since it was
+ * borrowed. We can not ASSERT that the contents of the buffer have not changed
+ * if it is composed of user pages because the pages can not be placed under
+ * write protection and the user could have possibly changed the contents in
+ * the pages at any time.
+ */
+void
+abd_return_buf(abd_t *abd, void *buf, size_t n)
+{
+ abd_verify(abd);
+ ASSERT3U(abd->abd_size, >=, n);
+#ifdef ZFS_DEBUG
+ (void) zfs_refcount_remove_many(&abd->abd_children, n, buf);
+#endif
+ if (abd_is_from_pages(abd)) {
+ zio_buf_free(buf, n);
+ } else if (abd_is_linear(abd)) {
+ ASSERT3P(buf, ==, abd_to_buf(abd));
+ } else if (abd_is_gang(abd)) {
+#ifdef ZFS_DEBUG
+ /*
+ * We have to be careful with gang ABD's that we do not ASSERT0
+ * for any ABD's that contain user pages from Direct I/O. In
+ * order to handle this, we just iterate through the gang ABD
+ * and only verify ABDs that are not from user pages.
+ */
+ void *cmp_buf = buf;
+
+ for (abd_t *cabd = list_head(&ABD_GANG(abd).abd_gang_chain);
+ cabd != NULL;
+ cabd = list_next(&ABD_GANG(abd).abd_gang_chain, cabd)) {
+ if (!abd_is_from_pages(cabd)) {
+ ASSERT0(abd_cmp_buf(cabd, cmp_buf,
+ cabd->abd_size));
+ }
+ cmp_buf = (char *)cmp_buf + cabd->abd_size;
+ }
+#endif
+ zio_buf_free(buf, n);
+ } else {
+ ASSERT0(abd_cmp_buf(abd, buf, n));
+ zio_buf_free(buf, n);
+ }
+}
+
+void
+abd_return_buf_copy(abd_t *abd, void *buf, size_t n)
+{
+ if (!abd_is_linear(abd) || abd_is_from_pages(abd)) {
+ abd_copy_from_buf(abd, buf, n);
+ }
+ abd_return_buf(abd, buf, n);
+}
+
/*
* This is abd_iter_page(), the function underneath abd_iterate_page_func().
* It yields the next page struct and data offset and size within it, without
#include <sys/zfs_racct.h>
+#ifdef _KERNEL
+#include <linux/task_io_accounting_ops.h>
+
+void
+zfs_racct_read(spa_t *spa, uint64_t size, uint64_t iops, uint32_t flags)
+{
+ task_io_account_read(size);
+ spa_iostats_read_add(spa, size, iops, flags);
+}
+
void
-zfs_racct_read(uint64_t size, uint64_t iops)
+zfs_racct_write(spa_t *spa, uint64_t size, uint64_t iops, uint32_t flags)
{
- (void) size, (void) iops;
+ task_io_account_write(size);
+ spa_iostats_write_add(spa, size, iops, flags);
}
+#else
+
void
-zfs_racct_write(uint64_t size, uint64_t iops)
+zfs_racct_read(spa_t *spa, uint64_t size, uint64_t iops, uint32_t flags)
{
- (void) size, (void) iops;
+ (void) spa, (void) size, (void) iops, (void) flags;
}
+
+void
+zfs_racct_write(spa_t *spa, uint64_t size, uint64_t iops, uint32_t flags)
+{
+ (void) spa, (void) size, (void) iops, (void) flags;
+}
+
+#endif /* _KERNEL */
#ifdef _KERNEL
+#include <sys/errno.h>
+#include <sys/vmem.h>
+#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/uio_impl.h>
#include <sys/sysmacros.h>
#include <sys/string.h>
+#include <sys/zfs_refcount.h>
+#include <sys/zfs_debug.h>
#include <linux/kmap_compat.h>
#include <linux/uaccess.h>
+#include <linux/pagemap.h>
+#include <linux/mman.h>
/*
* Move "n" bytes at byte address "p"; "rw" indicates the direction
int
zfs_uio_prefaultpages(ssize_t n, zfs_uio_t *uio)
{
- if (uio->uio_segflg == UIO_SYSSPACE || uio->uio_segflg == UIO_BVEC) {
- /* There's never a need to fault in kernel pages */
+ if (uio->uio_segflg == UIO_SYSSPACE || uio->uio_segflg == UIO_BVEC ||
+ (uio->uio_extflg & UIO_DIRECT)) {
+ /*
+ * There's never a need to fault in kernel pages or Direct I/O
+ * write pages. Direct I/O write pages have been pinned in so
+ * there is never a time for these pages a fault will occur.
+ */
return (0);
#if defined(HAVE_VFS_IOV_ITER)
} else if (uio->uio_segflg == UIO_ITER) {
uio->uio_iovcnt--;
}
}
+
uio->uio_loffset += n;
uio->uio_resid -= n;
}
EXPORT_SYMBOL(zfs_uioskip);
+/*
+ * Check if the uio is page-aligned in memory.
+ */
+boolean_t
+zfs_uio_page_aligned(zfs_uio_t *uio)
+{
+ boolean_t aligned = B_TRUE;
+
+ if (uio->uio_segflg == UIO_USERSPACE ||
+ uio->uio_segflg == UIO_SYSSPACE) {
+ const struct iovec *iov = uio->uio_iov;
+ size_t skip = uio->uio_skip;
+
+ for (int i = uio->uio_iovcnt; i > 0; iov++, i--) {
+ uintptr_t addr = (uintptr_t)(iov->iov_base + skip);
+ size_t size = iov->iov_len - skip;
+ if ((addr & (PAGE_SIZE - 1)) ||
+ (size & (PAGE_SIZE - 1))) {
+ aligned = B_FALSE;
+ break;
+ }
+ skip = 0;
+ }
+#if defined(HAVE_VFS_IOV_ITER)
+ } else if (uio->uio_segflg == UIO_ITER) {
+ unsigned long alignment =
+ iov_iter_alignment(uio->uio_iter);
+ aligned = IS_P2ALIGNED(alignment, PAGE_SIZE);
+#endif
+ } else {
+ /* Currently not supported */
+ aligned = B_FALSE;
+ }
+
+ return (aligned);
+}
+
+
+#if defined(HAVE_ZERO_PAGE_GPL_ONLY) || !defined(_LP64)
+#define ZFS_MARKEED_PAGE 0x0
+#define IS_ZFS_MARKED_PAGE(_p) 0
+#define zfs_mark_page(_p)
+#define zfs_unmark_page(_p)
+#define IS_ZERO_PAGE(_p) 0
+
+#else
+/*
+ * Mark pages to know if they were allocated to replace ZERO_PAGE() for
+ * Direct I/O writes.
+ */
+#define ZFS_MARKED_PAGE 0x5a465350414745 /* ASCII: ZFSPAGE */
+#define IS_ZFS_MARKED_PAGE(_p) \
+ (page_private(_p) == (unsigned long)ZFS_MARKED_PAGE)
+#define IS_ZERO_PAGE(_p) ((_p) == ZERO_PAGE(0))
+
+static inline void
+zfs_mark_page(struct page *page)
+{
+ ASSERT3P(page, !=, NULL);
+ get_page(page);
+ SetPagePrivate(page);
+ set_page_private(page, ZFS_MARKED_PAGE);
+}
+
+static inline void
+zfs_unmark_page(struct page *page)
+{
+ ASSERT3P(page, !=, NULL);
+ set_page_private(page, 0UL);
+ ClearPagePrivate(page);
+ put_page(page);
+}
+#endif /* HAVE_ZERO_PAGE_GPL_ONLY || !_LP64 */
+
+static void
+zfs_uio_dio_check_for_zero_page(zfs_uio_t *uio)
+{
+ ASSERT3P(uio->uio_dio.pages, !=, NULL);
+
+ for (long i = 0; i < uio->uio_dio.npages; i++) {
+ struct page *p = uio->uio_dio.pages[i];
+ lock_page(p);
+
+ if (IS_ZERO_PAGE(p)) {
+ /*
+ * If the user page points the kernels ZERO_PAGE() a
+ * new zero filled page will just be allocated so the
+ * contents of the page can not be changed by the user
+ * while a Direct I/O write is taking place.
+ */
+ gfp_t gfp_zero_page = __GFP_NOWARN | GFP_NOIO |
+ __GFP_ZERO | GFP_KERNEL;
+
+ ASSERT0(IS_ZFS_MARKED_PAGE(p));
+ unlock_page(p);
+ put_page(p);
+
+ p = __page_cache_alloc(gfp_zero_page);
+ zfs_mark_page(p);
+ } else {
+ unlock_page(p);
+ }
+ }
+}
+
+void
+zfs_uio_free_dio_pages(zfs_uio_t *uio, zfs_uio_rw_t rw)
+{
+
+ ASSERT(uio->uio_extflg & UIO_DIRECT);
+ ASSERT3P(uio->uio_dio.pages, !=, NULL);
+
+ for (long i = 0; i < uio->uio_dio.npages; i++) {
+ struct page *p = uio->uio_dio.pages[i];
+
+ if (IS_ZFS_MARKED_PAGE(p)) {
+ zfs_unmark_page(p);
+ __free_page(p);
+ continue;
+ }
+
+ put_page(p);
+ }
+
+ vmem_free(uio->uio_dio.pages,
+ uio->uio_dio.npages * sizeof (struct page *));
+}
+
+/*
+ * zfs_uio_iov_step() is just a modified version of the STEP function of Linux's
+ * iov_iter_get_pages().
+ */
+static int
+zfs_uio_iov_step(struct iovec v, zfs_uio_rw_t rw, zfs_uio_t *uio,
+ long *numpages)
+{
+ unsigned long addr = (unsigned long)(v.iov_base);
+ size_t len = v.iov_len;
+ unsigned long n = DIV_ROUND_UP(len, PAGE_SIZE);
+
+ long res = zfs_get_user_pages(
+ P2ALIGN_TYPED(addr, PAGE_SIZE, unsigned long), n, rw == UIO_READ,
+ &uio->uio_dio.pages[uio->uio_dio.npages]);
+ if (res < 0) {
+ return (SET_ERROR(-res));
+ } else if (len != (res * PAGE_SIZE)) {
+ return (SET_ERROR(EFAULT));
+ }
+
+ ASSERT3S(len, ==, res * PAGE_SIZE);
+ *numpages = res;
+ return (0);
+}
+
+static int
+zfs_uio_get_dio_pages_iov(zfs_uio_t *uio, zfs_uio_rw_t rw)
+{
+ const struct iovec *iovp = uio->uio_iov;
+ size_t skip = uio->uio_skip;
+ size_t len = uio->uio_resid - skip;
+
+ ASSERT(uio->uio_segflg != UIO_SYSSPACE);
+
+ for (int i = 0; i < uio->uio_iovcnt; i++) {
+ struct iovec iov;
+ long numpages = 0;
+
+ if (iovp->iov_len == 0) {
+ iovp++;
+ skip = 0;
+ continue;
+ }
+ iov.iov_len = MIN(len, iovp->iov_len - skip);
+ iov.iov_base = iovp->iov_base + skip;
+ int error = zfs_uio_iov_step(iov, rw, uio, &numpages);
+
+ if (error)
+ return (error);
+
+ uio->uio_dio.npages += numpages;
+ len -= iov.iov_len;
+ skip = 0;
+ iovp++;
+ }
+
+ ASSERT0(len);
+
+ return (0);
+}
+
+#if defined(HAVE_VFS_IOV_ITER)
+static int
+zfs_uio_get_dio_pages_iov_iter(zfs_uio_t *uio, zfs_uio_rw_t rw)
+{
+ size_t skip = uio->uio_skip;
+ size_t wanted = uio->uio_resid - uio->uio_skip;
+ ssize_t rollback = 0;
+ ssize_t cnt;
+ unsigned maxpages = DIV_ROUND_UP(wanted, PAGE_SIZE);
+
+ while (wanted) {
+#if defined(HAVE_IOV_ITER_GET_PAGES2)
+ cnt = iov_iter_get_pages2(uio->uio_iter,
+ &uio->uio_dio.pages[uio->uio_dio.npages],
+ wanted, maxpages, &skip);
+#else
+ cnt = iov_iter_get_pages(uio->uio_iter,
+ &uio->uio_dio.pages[uio->uio_dio.npages],
+ wanted, maxpages, &skip);
+#endif
+ if (cnt < 0) {
+ iov_iter_revert(uio->uio_iter, rollback);
+ return (SET_ERROR(-cnt));
+ }
+ uio->uio_dio.npages += DIV_ROUND_UP(cnt, PAGE_SIZE);
+ rollback += cnt;
+ wanted -= cnt;
+ skip = 0;
+#if !defined(HAVE_IOV_ITER_GET_PAGES2)
+ /*
+ * iov_iter_get_pages2() advances the iov_iter on success.
+ */
+ iov_iter_advance(uio->uio_iter, cnt);
+#endif
+
+ }
+ ASSERT3U(rollback, ==, uio->uio_resid - uio->uio_skip);
+ iov_iter_revert(uio->uio_iter, rollback);
+
+ return (0);
+}
+#endif /* HAVE_VFS_IOV_ITER */
+
+/*
+ * This function pins user pages. In the event that the user pages were not
+ * successfully pinned an error value is returned.
+ *
+ * On success, 0 is returned.
+ */
+int
+zfs_uio_get_dio_pages_alloc(zfs_uio_t *uio, zfs_uio_rw_t rw)
+{
+ int error = 0;
+ long npages = DIV_ROUND_UP(uio->uio_resid, PAGE_SIZE);
+ size_t size = npages * sizeof (struct page *);
+
+ if (uio->uio_segflg == UIO_USERSPACE) {
+ uio->uio_dio.pages = vmem_alloc(size, KM_SLEEP);
+ error = zfs_uio_get_dio_pages_iov(uio, rw);
+#if defined(HAVE_VFS_IOV_ITER)
+ } else if (uio->uio_segflg == UIO_ITER) {
+ uio->uio_dio.pages = vmem_alloc(size, KM_SLEEP);
+ error = zfs_uio_get_dio_pages_iov_iter(uio, rw);
+#endif
+ } else {
+ return (SET_ERROR(EOPNOTSUPP));
+ }
+
+ ASSERT3S(uio->uio_dio.npages, >=, 0);
+
+ if (error) {
+ for (long i = 0; i < uio->uio_dio.npages; i++)
+ put_page(uio->uio_dio.pages[i]);
+ vmem_free(uio->uio_dio.pages, size);
+ return (error);
+ } else {
+ ASSERT3S(uio->uio_dio.npages, ==, npages);
+ }
+
+ if (rw == UIO_WRITE) {
+ zfs_uio_dio_check_for_zero_page(uio);
+ }
+
+ uio->uio_extflg |= UIO_DIRECT;
+
+ return (0);
+}
+
#endif /* _KERNEL */
#include <sys/objlist.h>
#include <sys/zpl.h>
#include <linux/vfs_compat.h>
+#include <linux/fs.h>
#include "zfs_comutil.h"
enum {
struct page *pp = find_lock_page(mp, start >> PAGE_SHIFT);
if (pp) {
+
/*
* If filemap_fault() retries there exists a window
* where the page will be unlocked and not up to date.
}
zfs_log_write(zfsvfs->z_log, tx, TX_WRITE, zp, pgoff, pglen, commit,
- for_sync ? zfs_putpage_sync_commit_cb :
+ B_FALSE, for_sync ? zfs_putpage_sync_commit_cb :
zfs_putpage_async_commit_cb, pp);
dmu_tx_commit(tx);
static int
zfs_fillpage(struct inode *ip, struct page *pp)
{
+ znode_t *zp = ITOZ(ip);
zfsvfs_t *zfsvfs = ITOZSB(ip);
loff_t i_size = i_size_read(ip);
u_offset_t io_off = page_offset(pp);
io_len = i_size - io_off;
void *va = kmap(pp);
- int error = dmu_read(zfsvfs->z_os, ITOZ(ip)->z_id, io_off,
+ int error = dmu_read(zfsvfs->z_os, zp->z_id, io_off,
io_len, va, DMU_READ_PREFETCH);
if (io_len != PAGE_SIZE)
memset((char *)va + io_len, 0, PAGE_SIZE - io_len);
zfsvfs_t *zfsvfs = ITOZSB(ip);
znode_t *zp = ITOZ(ip);
int error;
+ loff_t i_size = i_size_read(ip);
+ u_offset_t io_off = page_offset(pp);
+ size_t io_len = PAGE_SIZE;
if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0)
return (error);
+ ASSERT3U(io_off, <, i_size);
+
+ if (io_off + io_len > i_size)
+ io_len = i_size - io_off;
+
+ /*
+ * It is important to hold the rangelock here because it is possible
+ * a Direct I/O write or block clone might be taking place at the same
+ * time that a page is being faulted in through filemap_fault(). With
+ * Direct I/O writes and block cloning db->db_data will be set to NULL
+ * with dbuf_clear_data() in dmu_buif_will_clone_or_dio(). If the
+ * rangelock is not held, then there is a race between faulting in a
+ * page and writing out a Direct I/O write or block cloning. Without
+ * the rangelock a NULL pointer dereference can occur in
+ * dmu_read_impl() for db->db_data during the mempcy operation when
+ * zfs_fillpage() calls dmu_read().
+ */
+ zfs_locked_range_t *lr = zfs_rangelock_tryenter(&zp->z_rangelock,
+ io_off, io_len, RL_READER);
+ if (lr == NULL) {
+ /*
+ * It is important to drop the page lock before grabbing the
+ * rangelock to avoid another deadlock between here and
+ * zfs_write() -> update_pages(). update_pages() holds both the
+ * rangelock and the page lock.
+ */
+ get_page(pp);
+ unlock_page(pp);
+ lr = zfs_rangelock_enter(&zp->z_rangelock, io_off,
+ io_len, RL_READER);
+ lock_page(pp);
+ put_page(pp);
+ }
error = zfs_fillpage(ip, pp);
+ zfs_rangelock_exit(lr);
+
if (error == 0)
dataset_kstats_update_read_kstats(&zfsvfs->z_kstat, PAGE_SIZE);
crhold(cr);
cookie = spl_fstrans_mark();
- int error = -zfs_read(ITOZ(filp->f_mapping->host), &uio,
+ ssize_t ret = -zfs_read(ITOZ(filp->f_mapping->host), &uio,
filp->f_flags | zfs_io_flags(kiocb), cr);
spl_fstrans_unmark(cookie);
crfree(cr);
- if (error < 0)
- return (error);
+ if (ret < 0)
+ return (ret);
ssize_t read = count - uio.uio_resid;
kiocb->ki_pos += read;
crhold(cr);
cookie = spl_fstrans_mark();
- int error = -zfs_write(ITOZ(ip), &uio,
+ ret = -zfs_write(ITOZ(ip), &uio,
filp->f_flags | zfs_io_flags(kiocb), cr);
spl_fstrans_unmark(cookie);
crfree(cr);
- if (error < 0)
- return (error);
+ if (ret < 0)
+ return (ret);
ssize_t wrote = count - uio.uio_resid;
kiocb->ki_pos += wrote;
crhold(cr);
cookie = spl_fstrans_mark();
- int error = -zfs_read(ITOZ(filp->f_mapping->host), &uio,
- filp->f_flags | zfs_io_flags(kiocb), cr);
+ ret = -zfs_read(ITOZ(filp->f_mapping->host), &uio,
+ flip->f_flags | zfs_io_flags(kiocb), cr);
spl_fstrans_unmark(cookie);
crfree(cr);
- if (error < 0)
- return (error);
+ if (ret < 0)
+ return (ret);
ssize_t read = count - uio.uio_resid;
kiocb->ki_pos += read;
crhold(cr);
cookie = spl_fstrans_mark();
- int error = -zfs_write(ITOZ(ip), &uio,
+ ret = -zfs_write(ITOZ(ip), &uio,
filp->f_flags | zfs_io_flags(kiocb), cr);
spl_fstrans_unmark(cookie);
crfree(cr);
- if (error < 0)
- return (error);
+ if (ret < 0)
+ return (ret);
ssize_t wrote = count - uio.uio_resid;
kiocb->ki_pos += wrote;
return (wrote);
}
+
#endif /* HAVE_VFS_RW_ITERATE */
-#if defined(HAVE_VFS_RW_ITERATE)
static ssize_t
-zpl_direct_IO_impl(int rw, struct kiocb *kiocb, struct iov_iter *iter)
+zpl_direct_IO_impl(void)
{
- if (rw == WRITE)
- return (zpl_iter_write(kiocb, iter));
- else
- return (zpl_iter_read(kiocb, iter));
+ /*
+ * All O_DIRECT requests should be handled by
+ * zpl_{iter/aio}_{write/read}(). There is no way kernel generic code
+ * should call the direct_IO address_space_operations function. We set
+ * this code path to be fatal if it is executed.
+ */
+ PANIC(0);
+ return (0);
}
+
+#if defined(HAVE_VFS_RW_ITERATE)
#if defined(HAVE_VFS_DIRECT_IO_ITER)
static ssize_t
zpl_direct_IO(struct kiocb *kiocb, struct iov_iter *iter)
{
- return (zpl_direct_IO_impl(iov_iter_rw(iter), kiocb, iter));
+ return (zpl_direct_IO_impl());
}
#elif defined(HAVE_VFS_DIRECT_IO_ITER_OFFSET)
static ssize_t
zpl_direct_IO(struct kiocb *kiocb, struct iov_iter *iter, loff_t pos)
{
- ASSERT3S(pos, ==, kiocb->ki_pos);
- return (zpl_direct_IO_impl(iov_iter_rw(iter), kiocb, iter));
+ return (zpl_direct_IO_impl());
}
#elif defined(HAVE_VFS_DIRECT_IO_ITER_RW_OFFSET)
static ssize_t
zpl_direct_IO(int rw, struct kiocb *kiocb, struct iov_iter *iter, loff_t pos)
{
- ASSERT3S(pos, ==, kiocb->ki_pos);
- return (zpl_direct_IO_impl(rw, kiocb, iter));
+ return (zpl_direct_IO_impl());
}
#else
-#error "Unknown direct IO interface"
+#error "Unknown Direct I/O interface"
#endif
#else /* HAVE_VFS_RW_ITERATE */
zpl_direct_IO(int rw, struct kiocb *kiocb, const struct iovec *iov,
loff_t pos, unsigned long nr_segs)
{
- if (rw == WRITE)
- return (zpl_aio_write(kiocb, iov, nr_segs, pos));
- else
- return (zpl_aio_read(kiocb, iov, nr_segs, pos));
+ return (zpl_direct_IO_impl());
}
#elif defined(HAVE_VFS_DIRECT_IO_ITER_RW_OFFSET)
static ssize_t
zpl_direct_IO(int rw, struct kiocb *kiocb, struct iov_iter *iter, loff_t pos)
{
- const struct iovec *iovp = iov_iter_iovec(iter);
- unsigned long nr_segs = iter->nr_segs;
-
- ASSERT3S(pos, ==, kiocb->ki_pos);
- if (rw == WRITE)
- return (zpl_aio_write(kiocb, iovp, nr_segs, pos));
- else
- return (zpl_aio_read(kiocb, iovp, nr_segs, pos));
+ return (zpl_direct_IO_impl());
}
#else
-#error "Unknown direct IO interface"
+#error "Unknown Direct I/O interface"
#endif
#endif /* HAVE_VFS_RW_ITERATE */
error = -zfs_map(ip, vma->vm_pgoff, (caddr_t *)vma->vm_start,
(size_t)(vma->vm_end - vma->vm_start), vma->vm_flags);
spl_fstrans_unmark(cookie);
+
if (error)
return (error);
{ NULL }
};
+ static const zprop_index_t direct_table[] = {
+ { "disabled", ZFS_DIRECT_DISABLED },
+ { "standard", ZFS_DIRECT_STANDARD },
+ { "always", ZFS_DIRECT_ALWAYS },
+ { NULL }
+ };
+
struct zfs_mod_supported_features *sfeatures =
zfs_mod_list_supported(ZFS_SYSFS_DATASET_PROPERTIES);
ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
"default | full | geom | dev | none", "VOLMODE", volmode_table,
sfeatures);
+ zprop_register_index(ZFS_PROP_DIRECT, "direct",
+ ZFS_DIRECT_STANDARD, PROP_INHERIT, ZFS_TYPE_FILESYSTEM,
+ "disabled | standard | always", "DIRECT", direct_table,
+ sfeatures);
/* inherit index (boolean) properties */
zprop_register_index(ZFS_PROP_ATIME, "atime", 1, PROP_INHERIT,
{ '.', "NP", "NOPWRITE" },
{ '.', "EX", "REEXECUTED" },
{ '.', "DG", "DELEGATED" },
+ { '.', "DC", "DIO_CHKSUM_ERR" },
)
/* END CSTYLED */
{ 'V', "VD", "VDEV_IO_DONE" },
{ 'V', "VA", "VDEV_IO_ASSESS" },
{ 'C', "CV", "CHECKSUM_VERIFY" },
+ { 'C', "DC", "DIO_CHECKSUM_VERIFY" },
{ 'X', "X ", "DONE" },
)
/* END CSTYLED */
* functions.
*
* As an additional feature, linear and scatter ABD's can be stitched together
- * by using the gang ABD type (abd_alloc_gang_abd()). This allows for
- * multiple ABDs to be viewed as a singular ABD.
+ * by using the gang ABD type (abd_alloc_gang()). This allows for multiple ABDs
+ * to be viewed as a singular ABD.
*
* It is possible to make all ABDs linear by setting zfs_abd_scatter_enabled to
* B_FALSE.
abd_verify(abd_t *abd)
{
#ifdef ZFS_DEBUG
- ASSERT3U(abd->abd_size, <=, SPA_MAXBLOCKSIZE);
+ if (abd_is_from_pages(abd)) {
+ ASSERT3U(abd->abd_size, <=, DMU_MAX_ACCESS);
+ } else {
+ ASSERT3U(abd->abd_size, <=, SPA_MAXBLOCKSIZE);
+ }
ASSERT3U(abd->abd_flags, ==, abd->abd_flags & (ABD_FLAG_LINEAR |
ABD_FLAG_OWNER | ABD_FLAG_META | ABD_FLAG_MULTI_ZONE |
ABD_FLAG_MULTI_CHUNK | ABD_FLAG_LINEAR_PAGE | ABD_FLAG_GANG |
- ABD_FLAG_GANG_FREE | ABD_FLAG_ALLOCD));
+ ABD_FLAG_GANG_FREE | ABD_FLAG_ALLOCD | ABD_FLAG_FROM_PAGES));
IMPLY(abd->abd_parent != NULL, !(abd->abd_flags & ABD_FLAG_OWNER));
IMPLY(abd->abd_flags & ABD_FLAG_META, abd->abd_flags & ABD_FLAG_OWNER);
if (abd_is_linear(abd)) {
#endif
}
-static void
+void
abd_init_struct(abd_t *abd)
{
list_link_init(&abd->abd_gang_link);
abd_free_linear_page(abd);
return;
}
+
if (abd->abd_flags & ABD_FLAG_META) {
zio_buf_free(ABD_LINEAR_BUF(abd), abd->abd_size);
} else {
*/
abd->abd_flags |= ABD_FLAG_LINEAR;
+ /*
+ * User pages from Direct I/O requests may be in a single page
+ * (ABD_FLAG_LINEAR_PAGE), and we must make sure to still flag
+ * that here for abd. This is required because we have to be
+ * careful when borrowing the buffer from the ABD because we
+ * can not place user pages under write protection on Linux.
+ * See the comments in abd_os.c for abd_borrow_buf(),
+ * abd_borrow_buf_copy(), abd_return_buf() and
+ * abd_return_buf_copy().
+ */
+ if (abd_is_from_pages(sabd)) {
+ abd->abd_flags |= ABD_FLAG_FROM_PAGES |
+ ABD_FLAG_LINEAR_PAGE;
+ }
+
ABD_LINEAR_BUF(abd) = (char *)ABD_LINEAR_BUF(sabd) + off;
} else if (abd_is_gang(sabd)) {
size_t left = size;
return (ABD_LINEAR_BUF(abd));
}
-/*
- * Borrow a raw buffer from an ABD without copying the contents of the ABD
- * into the buffer. If the ABD is scattered, this will allocate a raw buffer
- * whose contents are undefined. To copy over the existing data in the ABD, use
- * abd_borrow_buf_copy() instead.
- */
-void *
-abd_borrow_buf(abd_t *abd, size_t n)
-{
- void *buf;
- abd_verify(abd);
- ASSERT3U(abd->abd_size, >=, n);
- if (abd_is_linear(abd)) {
- buf = abd_to_buf(abd);
- } else {
- buf = zio_buf_alloc(n);
- }
-#ifdef ZFS_DEBUG
- (void) zfs_refcount_add_many(&abd->abd_children, n, buf);
-#endif
- return (buf);
-}
-
-void *
-abd_borrow_buf_copy(abd_t *abd, size_t n)
-{
- void *buf = abd_borrow_buf(abd, n);
- if (!abd_is_linear(abd)) {
- abd_copy_to_buf(buf, abd, n);
- }
- return (buf);
-}
-
-/*
- * Return a borrowed raw buffer to an ABD. If the ABD is scattered, this will
- * not change the contents of the ABD and will ASSERT that you didn't modify
- * the buffer since it was borrowed. If you want any changes you made to buf to
- * be copied back to abd, use abd_return_buf_copy() instead.
- */
-void
-abd_return_buf(abd_t *abd, void *buf, size_t n)
-{
- abd_verify(abd);
- ASSERT3U(abd->abd_size, >=, n);
-#ifdef ZFS_DEBUG
- (void) zfs_refcount_remove_many(&abd->abd_children, n, buf);
-#endif
- if (abd_is_linear(abd)) {
- ASSERT3P(buf, ==, abd_to_buf(abd));
- } else {
- ASSERT0(abd_cmp_buf(abd, buf, n));
- zio_buf_free(buf, n);
- }
-}
-
-void
-abd_return_buf_copy(abd_t *abd, void *buf, size_t n)
-{
- if (!abd_is_linear(abd)) {
- abd_copy_from_buf(abd, buf, n);
- }
- abd_return_buf(abd, buf, n);
-}
-
void
abd_release_ownership_of_buf(abd_t *abd)
{
ARCSTAT_CONDSTAT(!(*arc_flags & ARC_FLAG_PREFETCH),
demand, prefetch, !HDR_ISTYPE_METADATA(hdr), data,
metadata, misses);
- zfs_racct_read(size, 1);
+ zfs_racct_read(spa, size, 1, 0);
}
/* Check if the spa even has l2 configured */
}
void
-dataset_kstats_update_write_kstats(dataset_kstats_t *dk,
- int64_t nwritten)
+dataset_kstats_update_write_kstats(dataset_kstats_t *dk, int64_t nwritten)
{
ASSERT3S(nwritten, >=, 0);
}
void
-dataset_kstats_update_read_kstats(dataset_kstats_t *dk,
- int64_t nread)
+dataset_kstats_update_read_kstats(dataset_kstats_t *dk, int64_t nread)
{
ASSERT3S(nread, >=, 0);
* L2ARC.
*/
boolean_t
-dbuf_is_l2cacheable(dmu_buf_impl_t *db)
+dbuf_is_l2cacheable(dmu_buf_impl_t *db, blkptr_t *bp)
{
if (db->db_objset->os_secondary_cache == ZFS_CACHE_ALL ||
(db->db_objset->os_secondary_cache ==
if (l2arc_exclude_special == 0)
return (B_TRUE);
- blkptr_t *bp = db->db_blkptr;
- if (bp == NULL || BP_IS_HOLE(bp))
+ /*
+ * bp must be checked in the event it was passed from
+ * dbuf_read_impl() as the result of a the BP being set from
+ * a Direct I/O write in dbuf_read(). See comments in
+ * dbuf_read().
+ */
+ blkptr_t *db_bp = bp == NULL ? db->db_blkptr : bp;
+
+ if (db_bp == NULL || BP_IS_HOLE(db_bp))
return (B_FALSE);
- uint64_t vdev = DVA_GET_VDEV(bp->blk_dva);
+ uint64_t vdev = DVA_GET_VDEV(db_bp->blk_dva);
vdev_t *rvd = db->db_objset->os_spa->spa_root_vdev;
vdev_t *vd = NULL;
mutex_enter(&db->db_mtx);
ASSERT3U(db->db_state, ==, DB_READ);
+
/*
* All reads are synchronous, so we must have a hold on the dbuf
*/
*/
static int
dbuf_read_impl(dmu_buf_impl_t *db, dnode_t *dn, zio_t *zio, uint32_t flags,
- db_lock_type_t dblt, const void *tag)
+ db_lock_type_t dblt, blkptr_t *bp, const void *tag)
{
zbookmark_phys_t zb;
uint32_t aflags = ARC_FLAG_NOWAIT;
int err, zio_flags;
- blkptr_t bp, *bpp = NULL;
ASSERT(!zfs_refcount_is_zero(&db->db_holds));
ASSERT(MUTEX_HELD(&db->db_mtx));
goto early_unlock;
}
- /*
- * If we have a pending block clone, we don't want to read the
- * underlying block, but the content of the block being cloned,
- * pointed by the dirty record, so we have the most recent data.
- * If there is no dirty record, then we hit a race in a sync
- * process when the dirty record is already removed, while the
- * dbuf is not yet destroyed. Such case is equivalent to uncached.
- */
- if (db->db_state == DB_NOFILL) {
- dbuf_dirty_record_t *dr = list_head(&db->db_dirty_records);
- if (dr != NULL) {
- if (!dr->dt.dl.dr_brtwrite) {
- err = EIO;
- goto early_unlock;
- }
- bp = dr->dt.dl.dr_overridden_by;
- bpp = &bp;
- }
- }
-
- if (bpp == NULL && db->db_blkptr != NULL) {
- bp = *db->db_blkptr;
- bpp = &bp;
- }
-
- err = dbuf_read_hole(db, dn, bpp);
+ err = dbuf_read_hole(db, dn, bp);
if (err == 0)
goto early_unlock;
- ASSERT(bpp != NULL);
+ ASSERT(bp != NULL);
/*
* Any attempt to read a redacted block should result in an error. This
* will never happen under normal conditions, but can be useful for
* debugging purposes.
*/
- if (BP_IS_REDACTED(bpp)) {
+ if (BP_IS_REDACTED(bp)) {
ASSERT(dsl_dataset_feature_is_active(
db->db_objset->os_dsl_dataset,
SPA_FEATURE_REDACTED_DATASETS));
* All bps of an encrypted os should have the encryption bit set.
* If this is not true it indicates tampering and we report an error.
*/
- if (db->db_objset->os_encrypted && !BP_USES_CRYPT(bpp)) {
+ if (db->db_objset->os_encrypted && !BP_USES_CRYPT(bp)) {
spa_log_error(db->db_objset->os_spa, &zb,
- BP_GET_LOGICAL_BIRTH(bpp));
+ BP_GET_LOGICAL_BIRTH(bp));
err = SET_ERROR(EIO);
goto early_unlock;
}
if (!DBUF_IS_CACHEABLE(db))
aflags |= ARC_FLAG_UNCACHED;
- else if (dbuf_is_l2cacheable(db))
+ else if (dbuf_is_l2cacheable(db, bp))
aflags |= ARC_FLAG_L2CACHE;
dbuf_add_ref(db, NULL);
zio_flags = (flags & DB_RF_CANFAIL) ?
ZIO_FLAG_CANFAIL : ZIO_FLAG_MUSTSUCCEED;
- if ((flags & DB_RF_NO_DECRYPT) && BP_IS_PROTECTED(db->db_blkptr))
+ if ((flags & DB_RF_NO_DECRYPT) && BP_IS_PROTECTED(bp))
zio_flags |= ZIO_FLAG_RAW;
+
/*
- * The zio layer will copy the provided blkptr later, but we have our
- * own copy so that we can release the parent's rwlock. We have to
- * do that so that if dbuf_read_done is called synchronously (on
+ * The zio layer will copy the provided blkptr later, but we need to
+ * do this now so that we can release the parent's rwlock. We have to
+ * do that now so that if dbuf_read_done is called synchronously (on
* an l1 cache hit) we don't acquire the db_mtx while holding the
* parent's rwlock, which would be a lock ordering violation.
*/
+ blkptr_t copy = *bp;
dmu_buf_unlock_parent(db, dblt, tag);
- return (arc_read(zio, db->db_objset->os_spa, bpp,
+ return (arc_read(zio, db->db_objset->os_spa, ©,
dbuf_read_done, db, ZIO_PRIORITY_SYNC_READ, zio_flags,
&aflags, &zb));
ASSERT(db->db_state == DB_UNCACHED ||
db->db_state == DB_NOFILL);
db_lock_type_t dblt = dmu_buf_lock_parent(db, RW_READER, FTAG);
- if (pio == NULL && (db->db_state == DB_NOFILL ||
- (db->db_blkptr != NULL && !BP_IS_HOLE(db->db_blkptr)))) {
- spa_t *spa = dn->dn_objset->os_spa;
- pio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
- need_wait = B_TRUE;
+ blkptr_t *bp;
+
+ /*
+ * If a block clone or Direct I/O write has occurred we will
+ * get the dirty records overridden BP so we get the most
+ * recent data.
+ */
+ err = dmu_buf_get_bp_from_dbuf(db, &bp);
+
+ if (!err) {
+ if (pio == NULL && (db->db_state == DB_NOFILL ||
+ (bp != NULL && !BP_IS_HOLE(bp)))) {
+ spa_t *spa = dn->dn_objset->os_spa;
+ pio =
+ zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
+ need_wait = B_TRUE;
+ }
+
+ err =
+ dbuf_read_impl(db, dn, pio, flags, dblt, bp, FTAG);
+ } else {
+ mutex_exit(&db->db_mtx);
+ dmu_buf_unlock_parent(db, dblt, FTAG);
}
- err = dbuf_read_impl(db, dn, pio, flags, dblt, FTAG);
/* dbuf_read_impl drops db_mtx and parent's rwlock. */
miss = (db->db_state != DB_CACHED);
}
uint64_t txg = dr->dr_txg;
ASSERT(MUTEX_HELD(&db->db_mtx));
+
/*
* This assert is valid because dmu_sync() expects to be called by
* a zilog's get_data while holding a range lock. This call only
if (!BP_IS_HOLE(bp) && !dr->dt.dl.dr_nopwrite)
zio_free(db->db_objset->os_spa, txg, bp);
- if (dr->dt.dl.dr_brtwrite) {
+ if (dr->dt.dl.dr_brtwrite || dr->dt.dl.dr_diowrite) {
ASSERT0P(dr->dt.dl.dr_data);
dr->dt.dl.dr_data = db->db_buf;
}
dr->dt.dl.dr_override_state = DR_NOT_OVERRIDDEN;
dr->dt.dl.dr_nopwrite = B_FALSE;
dr->dt.dl.dr_brtwrite = B_FALSE;
+ dr->dt.dl.dr_diowrite = B_FALSE;
dr->dt.dl.dr_has_raw_params = B_FALSE;
/*
+ * In the event that Direct I/O was used, we do not
+ * need to release the buffer from the ARC.
+ *
* Release the already-written buffer, so we leave it in
* a consistent dirty state. Note that all callers are
* modifying the buffer, so they will immediately do
*/
dmu_buf_will_dirty(&db->db, tx);
+ VERIFY3P(db->db_buf, !=, NULL);
+
/* create the data buffer for the new block */
buf = arc_alloc_buf(dn->dn_objset->os_spa, db, type, size);
{
uint64_t txg = tx->tx_txg;
boolean_t brtwrite;
+ boolean_t diowrite;
ASSERT(txg != 0);
ASSERT(dr->dr_dbuf == db);
brtwrite = dr->dt.dl.dr_brtwrite;
+ diowrite = dr->dt.dl.dr_diowrite;
if (brtwrite) {
+ ASSERT3B(diowrite, ==, B_FALSE);
/*
* We are freeing a block that we cloned in the same
* transaction group.
if (db->db_state != DB_NOFILL && !brtwrite) {
dbuf_unoverride(dr);
- ASSERT(db->db_buf != NULL);
- ASSERT(dr->dt.dl.dr_data != NULL);
- if (dr->dt.dl.dr_data != db->db_buf)
+ if (dr->dt.dl.dr_data != db->db_buf) {
+ ASSERT(db->db_buf != NULL);
+ ASSERT(dr->dt.dl.dr_data != NULL);
arc_buf_destroy(dr->dt.dl.dr_data, db);
+ }
}
kmem_free(dr, sizeof (dbuf_dirty_record_t));
db->db_dirtycnt -= 1;
if (zfs_refcount_remove(&db->db_holds, (void *)(uintptr_t)txg) == 0) {
- ASSERT(db->db_state == DB_NOFILL || brtwrite ||
+ ASSERT(db->db_state == DB_NOFILL || brtwrite || diowrite ||
arc_released(db->db_buf));
dbuf_destroy(db);
return (B_TRUE);
* Block cloning: Do the dbuf_read() before undirtying the dbuf, as we
* want to make sure dbuf_read() will read the pending cloned block and
* not the uderlying block that is being replaced. dbuf_undirty() will
- * do dbuf_unoverride(), so we will end up with cloned block content,
- * without overridden BP.
+ * do brt_pending_remove() before removing the dirty record.
*/
(void) dbuf_read(db, NULL, flags);
if (undirty) {
return (dr != NULL);
}
+/*
+ * Normally the db_blkptr points to the most recent on-disk content for the
+ * dbuf (and anything newer will be cached in the dbuf). However, a pending
+ * block clone or not yet synced Direct I/O write will have a dirty record BP
+ * pointing to the most recent data.
+ */
+int
+dmu_buf_get_bp_from_dbuf(dmu_buf_impl_t *db, blkptr_t **bp)
+{
+ ASSERT(MUTEX_HELD(&db->db_mtx));
+ int error = 0;
+
+ if (db->db_level != 0) {
+ *bp = db->db_blkptr;
+ return (0);
+ }
+
+ *bp = db->db_blkptr;
+ dbuf_dirty_record_t *dr = list_head(&db->db_dirty_records);
+ if (dr && db->db_state == DB_NOFILL) {
+ /* Block clone */
+ if (!dr->dt.dl.dr_brtwrite)
+ error = EIO;
+ else
+ *bp = &dr->dt.dl.dr_overridden_by;
+ } else if (dr && db->db_state == DB_UNCACHED) {
+ /* Direct I/O write */
+ if (dr->dt.dl.dr_diowrite)
+ *bp = &dr->dt.dl.dr_overridden_by;
+ }
+
+ return (error);
+}
+
+/*
+ * Direct I/O reads can read directly from the ARC, but the data has
+ * to be untransformed in order to copy it over into user pages.
+ */
+int
+dmu_buf_untransform_direct(dmu_buf_impl_t *db, spa_t *spa)
+{
+ int err = 0;
+ DB_DNODE_ENTER(db);
+ dnode_t *dn = DB_DNODE(db);
+
+ ASSERT3S(db->db_state, ==, DB_CACHED);
+ ASSERT(MUTEX_HELD(&db->db_mtx));
+
+ /*
+ * Ensure that this block's dnode has been decrypted if
+ * the caller has requested decrypted data.
+ */
+ err = dbuf_read_verify_dnode_crypt(db, dn, 0);
+
+ /*
+ * If the arc buf is compressed or encrypted and the caller
+ * requested uncompressed data, we need to untransform it
+ * before returning. We also call arc_untransform() on any
+ * unauthenticated blocks, which will verify their MAC if
+ * the key is now available.
+ */
+ if (err == 0 && db->db_buf != NULL &&
+ (arc_is_encrypted(db->db_buf) ||
+ arc_is_unauthenticated(db->db_buf) ||
+ arc_get_compression(db->db_buf) != ZIO_COMPRESS_OFF)) {
+ zbookmark_phys_t zb;
+
+ SET_BOOKMARK(&zb, dmu_objset_id(db->db_objset),
+ db->db.db_object, db->db_level, db->db_blkid);
+ dbuf_fix_old_data(db, spa_syncing_txg(spa));
+ err = arc_untransform(db->db_buf, spa, &zb, B_FALSE);
+ dbuf_set_data(db, db->db_buf);
+ }
+ DB_DNODE_EXIT(db);
+ DBUF_STAT_BUMP(hash_hits);
+
+ return (err);
+}
+
void
-dmu_buf_will_clone(dmu_buf_t *db_fake, dmu_tx_t *tx)
+dmu_buf_will_clone_or_dio(dmu_buf_t *db_fake, dmu_tx_t *tx)
{
+ /*
+ * Block clones and Direct I/O writes always happen in open-context.
+ */
dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
ASSERT0(db->db_level);
+ ASSERT(!dmu_tx_is_syncing(tx));
+ ASSERT0(db->db_level);
ASSERT(db->db_blkid != DMU_BONUS_BLKID);
ASSERT(db->db.db_object != DMU_META_DNODE_OBJECT);
- /*
- * Block cloning: We are going to clone into this block, so undirty
- * modifications done to this block so far in this txg. This includes
- * writes and clones into this block.
- */
mutex_enter(&db->db_mtx);
DBUF_VERIFY(db);
- VERIFY(!dbuf_undirty(db, tx));
+
+ /*
+ * We are going to clone or issue a Direct I/O write on this block, so
+ * undirty modifications done to this block so far in this txg. This
+ * includes writes and clones into this block.
+ *
+ * If there dirty record associated with this txg from a previous Direct
+ * I/O write then space accounting cleanup takes place. It is important
+ * to go ahead free up the space accounting through dbuf_undirty() ->
+ * dbuf_unoverride() -> zio_free(). Space accountiung for determining
+ * if a write can occur in zfs_write() happens through dmu_tx_assign().
+ * This can cause an issue with Direct I/O writes in the case of
+ * overwriting the same block, because all DVA allocations are being
+ * done in open-context. Constantly allowing Direct I/O overwrites to
+ * the same block can exhaust the pools available space leading to
+ * ENOSPC errors at the DVA allocation part of the ZIO pipeline, which
+ * will eventually suspend the pool. By cleaning up sapce acccounting
+ * now, the ENOSPC error can be avoided.
+ *
+ * Since we are undirtying the record in open-context, we must have a
+ * hold on the db, so it should never be evicted after calling
+ * dbuf_undirty().
+ */
+ VERIFY3B(dbuf_undirty(db, tx), ==, B_FALSE);
ASSERT0P(dbuf_find_dirty_eq(db, tx->tx_txg));
+
if (db->db_buf != NULL) {
/*
* If there is an associated ARC buffer with this dbuf we can
if (dr == NULL || dr->dt.dl.dr_data != db->db_buf)
arc_buf_destroy(db->db_buf, db);
+ /*
+ * Setting the dbuf's data pointers to NULL will force all
+ * future reads down to the devices to get the most up to date
+ * version of the data after a Direct I/O write has completed.
+ */
db->db_buf = NULL;
dbuf_clear_data(db);
}
ASSERT3P(db->db.db_data, ==, NULL);
db->db_state = DB_NOFILL;
- DTRACE_SET_STATE(db, "allocating NOFILL buffer for clone");
+ DTRACE_SET_STATE(db,
+ "allocating NOFILL buffer for clone or direct I/O write");
DBUF_VERIFY(db);
mutex_exit(&db->db_mtx);
dmu_tx_private_ok(tx));
mutex_enter(&db->db_mtx);
- if (db->db_state == DB_NOFILL) {
+ dbuf_dirty_record_t *dr = dbuf_find_dirty_eq(db, tx->tx_txg);
+ if (db->db_state == DB_NOFILL ||
+ (db->db_state == DB_UNCACHED && dr && dr->dt.dl.dr_diowrite)) {
/*
- * Block cloning: We will be completely overwriting a block
- * cloned in this transaction group, so let's undirty the
- * pending clone and mark the block as uncached. This will be
- * as if the clone was never done. But if the fill can fail
- * we should have a way to return back to the cloned data.
+ * If the fill can fail we should have a way to return back to
+ * the cloned or Direct I/O write data.
*/
- if (canfail && dbuf_find_dirty_eq(db, tx->tx_txg) != NULL) {
+ if (canfail && dr) {
mutex_exit(&db->db_mtx);
dmu_buf_will_dirty(db_fake, tx);
return;
}
- VERIFY(!dbuf_undirty(db, tx));
- db->db_state = DB_UNCACHED;
+ /*
+ * Block cloning: We will be completely overwriting a block
+ * cloned in this transaction group, so let's undirty the
+ * pending clone and mark the block as uncached. This will be
+ * as if the clone was never done.
+ */
+ if (dr && dr->dt.dl.dr_brtwrite) {
+ VERIFY(!dbuf_undirty(db, tx));
+ db->db_state = DB_UNCACHED;
+ }
}
mutex_exit(&db->db_mtx);
} else {
mutex_exit(&db->db_mtx);
}
-
}
#pragma weak dmu_buf_refcount = dbuf_refcount
mutex_enter(&db->db_mtx);
/*
- * To be synced, we must be dirtied. But we
- * might have been freed after the dirty.
+ * To be synced, we must be dirtied. But we might have been freed
+ * after the dirty.
*/
if (db->db_state == DB_UNCACHED) {
/* This buffer has been freed since it was dirtied */
- ASSERT(db->db.db_data == NULL);
+ ASSERT3P(db->db.db_data, ==, NULL);
} else if (db->db_state == DB_FILL) {
/* This buffer was freed and is now being re-filled */
ASSERT(db->db.db_data != dr->dt.dl.dr_data);
} else if (db->db_state == DB_READ) {
/*
- * This buffer has a clone we need to write, and an in-flight
- * read on the BP we're about to clone. Its safe to issue the
- * write here because the read has already been issued and the
- * contents won't change.
+ * This buffer was either cloned or had a Direct I/O write
+ * occur and has an in-flgiht read on the BP. It is safe to
+ * issue the write here, because the read has already been
+ * issued and the contents won't change.
+ *
+ * We can verify the case of both the clone and Direct I/O
+ * write by making sure the first dirty record for the dbuf
+ * has no ARC buffer associated with it.
*/
- ASSERT(dr->dt.dl.dr_brtwrite &&
- dr->dt.dl.dr_override_state == DR_OVERRIDDEN);
+ dbuf_dirty_record_t *dr_head =
+ list_head(&db->db_dirty_records);
+ ASSERT3P(db->db_buf, ==, NULL);
+ ASSERT3P(db->db.db_data, ==, NULL);
+ ASSERT3P(dr_head->dt.dl.dr_data, ==, NULL);
+ ASSERT3U(dr_head->dt.dl.dr_override_state, ==, DR_OVERRIDDEN);
} else {
ASSERT(db->db_state == DB_CACHED || db->db_state == DB_NOFILL);
}
dbuf_check_blkptr(dn, db);
/*
- * If this buffer is in the middle of an immediate write,
- * wait for the synchronous IO to complete.
+ * If this buffer is in the middle of an immediate write, wait for the
+ * synchronous IO to complete.
+ *
+ * This is also valid even with Direct I/O writes setting a dirty
+ * records override state into DR_IN_DMU_SYNC, because all
+ * Direct I/O writes happen in open-context.
*/
while (dr->dt.dl.dr_override_state == DR_IN_DMU_SYNC) {
ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT);
if (db->db_level == 0) {
ASSERT(db->db_blkid != DMU_BONUS_BLKID);
ASSERT(dr->dt.dl.dr_override_state == DR_NOT_OVERRIDDEN);
+
+ /* no dr_data if this is a NO_FILL or Direct I/O */
if (dr->dt.dl.dr_data != NULL &&
dr->dt.dl.dr_data != db->db_buf) {
+ ASSERT3B(dr->dt.dl.dr_brtwrite, ==, B_FALSE);
+ ASSERT3B(dr->dt.dl.dr_diowrite, ==, B_FALSE);
arc_buf_destroy(dr->dt.dl.dr_data, db);
}
} else {
dr->dt.dl.dr_override_state == DR_OVERRIDDEN) {
/*
* The BP for this block has been provided by open context
- * (by dmu_sync() or dmu_buf_write_embedded()).
+ * (by dmu_sync(), dmu_write_direct(),
+ * or dmu_buf_write_embedded()).
*/
abd_t *contents = (data != NULL) ?
abd_get_from_buf(data->b_data, arc_buf_size(data)) : NULL;
dr->dr_zio = arc_write(pio, os->os_spa, txg,
&dr->dr_bp_copy, data, !DBUF_IS_CACHEABLE(db),
- dbuf_is_l2cacheable(db), &zp, dbuf_write_ready,
+ dbuf_is_l2cacheable(db, NULL), &zp, dbuf_write_ready,
children_ready_cb, dbuf_write_done, db,
ZIO_PRIORITY_ASYNC_WRITE, ZIO_FLAG_MUSTSUCCEED, &zb);
}
EXPORT_SYMBOL(dmu_buf_set_crypt_params);
EXPORT_SYMBOL(dmu_buf_will_dirty);
EXPORT_SYMBOL(dmu_buf_is_dirty);
-EXPORT_SYMBOL(dmu_buf_will_clone);
+EXPORT_SYMBOL(dmu_buf_will_clone_or_dio);
EXPORT_SYMBOL(dmu_buf_will_not_fill);
EXPORT_SYMBOL(dmu_buf_will_fill);
EXPORT_SYMBOL(dmu_buf_fill_done);
dbp[i] = &db->db;
}
- if (!read)
- zfs_racct_write(length, nblks);
+ /*
+ * If we are doing O_DIRECT we still hold the dbufs, even for reads,
+ * but we do not issue any reads here. We do not want to account for
+ * writes in this case.
+ *
+ * O_DIRECT write/read accounting takes place in
+ * dmu_{write/read}_abd().
+ */
+ if (!read && ((flags & DMU_DIRECTIO) == 0))
+ zfs_racct_write(dn->dn_objset->os_spa, length, nblks, flags);
if (zs)
dmu_zfetch_run(&dn->dn_zfetch, zs, missed, B_TRUE);
/*
* Get the next "chunk" of file data to free. We traverse the file from
- * the end so that the file gets shorter over time (if we crashes in the
+ * the end so that the file gets shorter over time (if we crash in the
* middle, this will leave us in a better state). We find allocated file
* data by simply searching the allocated level 1 indirects.
*
/*
* Deal with odd block sizes, where there can't be data past the first
- * block. If we ever do the tail block optimization, we will need to
+ * block. If we ever do the tail block optimization, we will need to
* handle that here as well.
*/
if (dn->dn_maxblkid == 0) {
size = newsz;
}
+ if (size == 0)
+ return (0);
+
+ /* Allow Direct I/O when requested and properly aligned */
+ if ((flags & DMU_DIRECTIO) && zfs_dio_page_aligned(buf) &&
+ zfs_dio_aligned(offset, size, PAGESIZE)) {
+ abd_t *data = abd_get_from_buf(buf, size);
+ err = dmu_read_abd(dn, offset, size, data, flags);
+ abd_free(data);
+ return (err);
+ }
+
while (size > 0) {
uint64_t mylen = MIN(size, DMU_MAX_ACCESS / 2);
int i;
}
/*
- * Note: Lustre is an external consumer of this interface.
+ * This interface is not used internally by ZFS but is provided for
+ * use by Lustre which is built on the DMU interfaces.
*/
-void
-dmu_write_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size,
- const void *buf, dmu_tx_t *tx)
+int
+dmu_write_by_dnode_flags(dnode_t *dn, uint64_t offset, uint64_t size,
+ const void *buf, dmu_tx_t *tx, uint32_t flags)
{
dmu_buf_t **dbp;
int numbufs;
+ int error;
if (size == 0)
- return;
+ return (0);
+
+ /* Allow Direct I/O when requested and properly aligned */
+ if ((flags & DMU_DIRECTIO) && zfs_dio_page_aligned((void *)buf) &&
+ zfs_dio_aligned(offset, size, dn->dn_datablksz)) {
+ abd_t *data = abd_get_from_buf((void *)buf, size);
+ error = dmu_write_abd(dn, offset, size, data, DMU_DIRECTIO, tx);
+ abd_free(data);
+ return (error);
+ }
VERIFY0(dmu_buf_hold_array_by_dnode(dn, offset, size,
FALSE, FTAG, &numbufs, &dbp, DMU_READ_PREFETCH));
dmu_write_impl(dbp, numbufs, offset, size, buf, tx);
dmu_buf_rele_array(dbp, numbufs, FTAG);
+ return (0);
+}
+
+int
+dmu_write_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size,
+ const void *buf, dmu_tx_t *tx)
+{
+ return (dmu_write_by_dnode_flags(dn, offset, size, buf, tx, 0));
}
void
dmu_buf_t **dbp;
int numbufs, i, err;
+ if (uio->uio_extflg & UIO_DIRECT)
+ return (dmu_read_uio_direct(dn, uio, size));
+
/*
* NB: we could do this block-at-a-time, but it's nice
* to be reading in parallel.
dmu_buf_t **dbp;
int numbufs;
int err = 0;
- int i;
+ uint64_t write_size;
- err = dmu_buf_hold_array_by_dnode(dn, zfs_uio_offset(uio), size,
+top:
+ write_size = size;
+
+ /*
+ * We only allow Direct I/O writes to happen if we are block
+ * sized aligned. Otherwise, we pass the write off to the ARC.
+ */
+ if ((uio->uio_extflg & UIO_DIRECT) &&
+ (write_size >= dn->dn_datablksz)) {
+ if (zfs_dio_aligned(zfs_uio_offset(uio), write_size,
+ dn->dn_datablksz)) {
+ return (dmu_write_uio_direct(dn, uio, size, tx));
+ } else if (write_size > dn->dn_datablksz &&
+ zfs_dio_offset_aligned(zfs_uio_offset(uio),
+ dn->dn_datablksz)) {
+ write_size =
+ dn->dn_datablksz * (write_size / dn->dn_datablksz);
+ err = dmu_write_uio_direct(dn, uio, write_size, tx);
+ if (err == 0) {
+ size -= write_size;
+ goto top;
+ } else {
+ return (err);
+ }
+ } else {
+ write_size =
+ P2PHASE(zfs_uio_offset(uio), dn->dn_datablksz);
+ }
+ }
+
+ err = dmu_buf_hold_array_by_dnode(dn, zfs_uio_offset(uio), write_size,
FALSE, FTAG, &numbufs, &dbp, DMU_READ_PREFETCH);
if (err)
return (err);
- for (i = 0; i < numbufs; i++) {
+ for (int i = 0; i < numbufs; i++) {
uint64_t tocpy;
int64_t bufoff;
dmu_buf_t *db = dbp[i];
- ASSERT(size > 0);
+ ASSERT(write_size > 0);
offset_t off = zfs_uio_offset(uio);
bufoff = off - db->db_offset;
- tocpy = MIN(db->db_size - bufoff, size);
+ tocpy = MIN(db->db_size - bufoff, write_size);
ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size);
if (err)
break;
+ write_size -= tocpy;
size -= tocpy;
}
+ IMPLY(err == 0, write_size == 0);
+
dmu_buf_rele_array(dbp, numbufs, FTAG);
+
+ if ((uio->uio_extflg & UIO_DIRECT) && size > 0) {
+ goto top;
+ }
+
return (err);
}
* same size as the dbuf.
*/
if (offset == db->db.db_offset && blksz == db->db.db_size) {
- zfs_racct_write(blksz, 1);
+ zfs_racct_write(os->os_spa, blksz, 1, 0);
dbuf_assign_arcbuf(db, buf, tx);
dbuf_rele(db, FTAG);
} else {
return (err);
}
-typedef struct {
- dbuf_dirty_record_t *dsa_dr;
- dmu_sync_cb_t *dsa_done;
- zgd_t *dsa_zgd;
- dmu_tx_t *dsa_tx;
-} dmu_sync_arg_t;
-
-static void
+void
dmu_sync_ready(zio_t *zio, arc_buf_t *buf, void *varg)
{
(void) buf;
dmu_sync_arg_t *dsa = varg;
- dmu_buf_t *db = dsa->dsa_zgd->zgd_db;
- blkptr_t *bp = zio->io_bp;
if (zio->io_error == 0) {
+ dbuf_dirty_record_t *dr = dsa->dsa_dr;
+ blkptr_t *bp = zio->io_bp;
+
if (BP_IS_HOLE(bp)) {
+ dmu_buf_t *db = NULL;
+ if (dr)
+ db = &(dr->dr_dbuf->db);
+ else
+ db = dsa->dsa_zgd->zgd_db;
/*
* A block of zeros may compress to a hole, but the
* block size still needs to be known for replay.
dmu_sync_ready(zio, NULL, zio->io_private);
}
-static void
+void
dmu_sync_done(zio_t *zio, arc_buf_t *buf, void *varg)
{
(void) buf;
* Record the vdev(s) backing this blkptr so they can be flushed after
* the writes for the lwb have completed.
*/
- if (zio->io_error == 0) {
+ if (zgd && zio->io_error == 0) {
zil_lwb_add_block(zgd->zgd_lwb, zgd->zgd_bp);
}
} else {
dr->dt.dl.dr_override_state = DR_NOT_OVERRIDDEN;
}
+
cv_broadcast(&db->db_changed);
mutex_exit(&db->db_mtx);
- dsa->dsa_done(dsa->dsa_zgd, zio->io_error);
+ if (dsa->dsa_done)
+ dsa->dsa_done(dsa->dsa_zgd, zio->io_error);
kmem_free(dsa, sizeof (*dsa));
}
dsa->dsa_tx = NULL;
zio_nowait(arc_write(pio, os->os_spa, txg, zgd->zgd_bp,
- dr->dt.dl.dr_data, !DBUF_IS_CACHEABLE(db), dbuf_is_l2cacheable(db),
- &zp, dmu_sync_ready, NULL, dmu_sync_done, dsa,
- ZIO_PRIORITY_SYNC_WRITE, ZIO_FLAG_CANFAIL, &zb));
+ dr->dt.dl.dr_data, !DBUF_IS_CACHEABLE(db),
+ dbuf_is_l2cacheable(db, NULL), &zp, dmu_sync_ready, NULL,
+ dmu_sync_done, dsa, ZIO_PRIORITY_SYNC_WRITE, ZIO_FLAG_CANFAIL,
+ &zb));
return (0);
}
zp->zp_nopwrite = nopwrite;
zp->zp_encrypt = encrypt;
zp->zp_byteorder = ZFS_HOST_BYTEORDER;
+ zp->zp_direct_write = (wp & WP_DIRECT_WR) ? B_TRUE : B_FALSE;
memset(zp->zp_salt, 0, ZIO_DATA_SALT_LEN);
memset(zp->zp_iv, 0, ZIO_DATA_IV_LEN);
memset(zp->zp_mac, 0, ZIO_DATA_MAC_LEN);
ASSERT(db->db_blkid != DMU_SPILL_BLKID);
ASSERT(BP_IS_HOLE(bp) || dbuf->db_size == BP_GET_LSIZE(bp));
- dmu_buf_will_clone(dbuf, tx);
+ dmu_buf_will_clone_or_dio(dbuf, tx);
mutex_enter(&db->db_mtx);
EXPORT_SYMBOL(dmu_free_long_object);
EXPORT_SYMBOL(dmu_read);
EXPORT_SYMBOL(dmu_read_by_dnode);
+EXPORT_SYMBOL(dmu_read_uio);
+EXPORT_SYMBOL(dmu_read_uio_dbuf);
+EXPORT_SYMBOL(dmu_read_uio_dnode);
EXPORT_SYMBOL(dmu_write);
EXPORT_SYMBOL(dmu_write_by_dnode);
+EXPORT_SYMBOL(dmu_write_by_dnode_flags);
+EXPORT_SYMBOL(dmu_write_uio);
+EXPORT_SYMBOL(dmu_write_uio_dbuf);
+EXPORT_SYMBOL(dmu_write_uio_dnode);
EXPORT_SYMBOL(dmu_prealloc);
EXPORT_SYMBOL(dmu_object_info);
EXPORT_SYMBOL(dmu_object_info_from_dnode);
--- /dev/null
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or https://opensource.org/licenses/CDDL-1.0.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+
+#include <sys/dmu.h>
+#include <sys/dmu_impl.h>
+#include <sys/dbuf.h>
+#include <sys/dnode.h>
+#include <sys/zfs_context.h>
+#include <sys/zfs_racct.h>
+#include <sys/dsl_dataset.h>
+#include <sys/dmu_objset.h>
+
+static abd_t *
+make_abd_for_dbuf(dmu_buf_impl_t *db, abd_t *data, uint64_t offset,
+ uint64_t size)
+{
+ size_t buf_size = db->db.db_size;
+ abd_t *pre_buf = NULL, *post_buf = NULL, *mbuf = NULL;
+ size_t buf_off = 0;
+
+ ASSERT(MUTEX_HELD(&db->db_mtx));
+
+ if (offset > db->db.db_offset) {
+ size_t pre_size = offset - db->db.db_offset;
+ pre_buf = abd_alloc_for_io(pre_size, B_TRUE);
+ buf_size -= pre_size;
+ buf_off = 0;
+ } else {
+ buf_off = db->db.db_offset - offset;
+ size -= buf_off;
+ }
+
+ if (size < buf_size) {
+ size_t post_size = buf_size - size;
+ post_buf = abd_alloc_for_io(post_size, B_TRUE);
+ buf_size -= post_size;
+ }
+
+ ASSERT3U(buf_size, >, 0);
+ abd_t *buf = abd_get_offset_size(data, buf_off, buf_size);
+
+ if (pre_buf || post_buf) {
+ mbuf = abd_alloc_gang();
+ if (pre_buf)
+ abd_gang_add(mbuf, pre_buf, B_TRUE);
+ abd_gang_add(mbuf, buf, B_TRUE);
+ if (post_buf)
+ abd_gang_add(mbuf, post_buf, B_TRUE);
+ } else {
+ mbuf = buf;
+ }
+
+ return (mbuf);
+}
+
+static void
+dmu_read_abd_done(zio_t *zio)
+{
+ abd_free(zio->io_abd);
+}
+
+static void
+dmu_write_direct_ready(zio_t *zio)
+{
+ dmu_sync_ready(zio, NULL, zio->io_private);
+}
+
+static void
+dmu_write_direct_done(zio_t *zio)
+{
+ dmu_sync_arg_t *dsa = zio->io_private;
+ dbuf_dirty_record_t *dr = dsa->dsa_dr;
+ dmu_buf_impl_t *db = dr->dr_dbuf;
+
+ abd_free(zio->io_abd);
+
+ mutex_enter(&db->db_mtx);
+ ASSERT3P(db->db_buf, ==, NULL);
+ ASSERT3P(dr->dt.dl.dr_data, ==, NULL);
+ ASSERT3P(db->db.db_data, ==, NULL);
+ db->db_state = DB_UNCACHED;
+ mutex_exit(&db->db_mtx);
+
+ dmu_sync_done(zio, NULL, zio->io_private);
+
+ if (zio->io_error != 0) {
+ if (zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR)
+ ASSERT3U(zio->io_error, ==, EIO);
+
+ /*
+ * In the event of an I/O error this block has been freed in
+ * zio_done() through zio_dva_unallocate(). Calling
+ * dmu_sync_done() above set dr_override_state to
+ * DR_NOT_OVERRIDDEN. In this case when dbuf_undirty() calls
+ * dbuf_unoverride(), it will skip doing zio_free() to free
+ * this block as that was already taken care of.
+ *
+ * Since we are undirtying the record in open-context, we must
+ * have a hold on the db, so it should never be evicted after
+ * calling dbuf_undirty().
+ */
+ mutex_enter(&db->db_mtx);
+ VERIFY3B(dbuf_undirty(db, dsa->dsa_tx), ==, B_FALSE);
+ mutex_exit(&db->db_mtx);
+ }
+
+ kmem_free(zio->io_bp, sizeof (blkptr_t));
+ zio->io_bp = NULL;
+}
+
+int
+dmu_write_direct(zio_t *pio, dmu_buf_impl_t *db, abd_t *data, dmu_tx_t *tx)
+{
+ objset_t *os = db->db_objset;
+ dsl_dataset_t *ds = dmu_objset_ds(os);
+ zbookmark_phys_t zb;
+ dbuf_dirty_record_t *dr_head;
+
+ SET_BOOKMARK(&zb, ds->ds_object,
+ db->db.db_object, db->db_level, db->db_blkid);
+
+ DB_DNODE_ENTER(db);
+ zio_prop_t zp;
+ dmu_write_policy(os, DB_DNODE(db), db->db_level,
+ WP_DMU_SYNC | WP_DIRECT_WR, &zp);
+ DB_DNODE_EXIT(db);
+
+ /*
+ * Dirty this dbuf with DB_NOFILL since we will not have any data
+ * associated with the dbuf.
+ */
+ dmu_buf_will_clone_or_dio(&db->db, tx);
+
+ mutex_enter(&db->db_mtx);
+
+ uint64_t txg = dmu_tx_get_txg(tx);
+ ASSERT3U(txg, >, spa_last_synced_txg(os->os_spa));
+ ASSERT3U(txg, >, spa_syncing_txg(os->os_spa));
+
+ dr_head = list_head(&db->db_dirty_records);
+ ASSERT3U(dr_head->dr_txg, ==, txg);
+ dr_head->dt.dl.dr_diowrite = B_TRUE;
+ dr_head->dr_accounted = db->db.db_size;
+
+ blkptr_t *bp = kmem_alloc(sizeof (blkptr_t), KM_SLEEP);
+ if (db->db_blkptr != NULL) {
+ /*
+ * Fill in bp with the current block pointer so that
+ * the nopwrite code can check if we're writing the same
+ * data that's already on disk.
+ */
+ *bp = *db->db_blkptr;
+ } else {
+ memset(bp, 0, sizeof (blkptr_t));
+ }
+
+ /*
+ * Disable nopwrite if the current block pointer could change
+ * before this TXG syncs.
+ */
+ if (list_next(&db->db_dirty_records, dr_head) != NULL)
+ zp.zp_nopwrite = B_FALSE;
+
+ ASSERT3S(dr_head->dt.dl.dr_override_state, ==, DR_NOT_OVERRIDDEN);
+ dr_head->dt.dl.dr_override_state = DR_IN_DMU_SYNC;
+
+ mutex_exit(&db->db_mtx);
+
+ dmu_objset_willuse_space(os, dr_head->dr_accounted, tx);
+
+ dmu_sync_arg_t *dsa = kmem_zalloc(sizeof (dmu_sync_arg_t), KM_SLEEP);
+ dsa->dsa_dr = dr_head;
+ dsa->dsa_tx = tx;
+
+ zio_t *zio = zio_write(pio, os->os_spa, txg, bp, data,
+ db->db.db_size, db->db.db_size, &zp,
+ dmu_write_direct_ready, NULL, dmu_write_direct_done, dsa,
+ ZIO_PRIORITY_SYNC_WRITE, ZIO_FLAG_CANFAIL, &zb);
+
+ if (pio == NULL)
+ return (zio_wait(zio));
+
+ zio_nowait(zio);
+
+ return (0);
+}
+
+int
+dmu_write_abd(dnode_t *dn, uint64_t offset, uint64_t size,
+ abd_t *data, uint32_t flags, dmu_tx_t *tx)
+{
+ dmu_buf_t **dbp;
+ spa_t *spa = dn->dn_objset->os_spa;
+ int numbufs, err;
+
+ ASSERT(flags & DMU_DIRECTIO);
+
+ err = dmu_buf_hold_array_by_dnode(dn, offset,
+ size, B_FALSE, FTAG, &numbufs, &dbp, flags);
+ if (err)
+ return (err);
+
+ zio_t *pio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
+
+ for (int i = 0; i < numbufs && err == 0; i++) {
+ dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp[i];
+
+ abd_t *abd = abd_get_offset_size(data,
+ db->db.db_offset - offset, dn->dn_datablksz);
+
+ zfs_racct_write(spa, db->db.db_size, 1, flags);
+ err = dmu_write_direct(pio, db, abd, tx);
+ ASSERT0(err);
+ }
+
+ err = zio_wait(pio);
+
+ /*
+ * The dbuf must be held until the Direct I/O write has completed in
+ * the event there was any errors and dbuf_undirty() was called.
+ */
+ dmu_buf_rele_array(dbp, numbufs, FTAG);
+
+ return (err);
+}
+
+int
+dmu_read_abd(dnode_t *dn, uint64_t offset, uint64_t size,
+ abd_t *data, uint32_t flags)
+{
+ objset_t *os = dn->dn_objset;
+ spa_t *spa = os->os_spa;
+ dmu_buf_t **dbp;
+ int numbufs, err;
+
+ ASSERT(flags & DMU_DIRECTIO);
+
+ err = dmu_buf_hold_array_by_dnode(dn, offset,
+ size, B_FALSE, FTAG, &numbufs, &dbp, flags);
+ if (err)
+ return (err);
+
+ zio_t *rio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
+
+ for (int i = 0; i < numbufs; i++) {
+ dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp[i];
+ abd_t *mbuf;
+ zbookmark_phys_t zb;
+ blkptr_t *bp;
+
+ mutex_enter(&db->db_mtx);
+
+ SET_BOOKMARK(&zb, dmu_objset_ds(os)->ds_object,
+ db->db.db_object, db->db_level, db->db_blkid);
+
+ /*
+ * If there is another read for this dbuf, we will wait for
+ * that to complete first before checking the db_state below.
+ */
+ while (db->db_state == DB_READ)
+ cv_wait(&db->db_changed, &db->db_mtx);
+
+ err = dmu_buf_get_bp_from_dbuf(db, &bp);
+ if (err) {
+ mutex_exit(&db->db_mtx);
+ goto error;
+ }
+
+ /*
+ * There is no need to read if this is a hole or the data is
+ * cached. This will not be considered a direct read for IO
+ * accounting in the same way that an ARC hit is not counted.
+ */
+ if (bp == NULL || BP_IS_HOLE(bp) || db->db_state == DB_CACHED) {
+ size_t aoff = offset < db->db.db_offset ?
+ db->db.db_offset - offset : 0;
+ size_t boff = offset > db->db.db_offset ?
+ offset - db->db.db_offset : 0;
+ size_t len = MIN(size - aoff, db->db.db_size - boff);
+
+ if (db->db_state == DB_CACHED) {
+ /*
+ * We need to untransformed the ARC buf data
+ * before we copy it over.
+ */
+ err = dmu_buf_untransform_direct(db, spa);
+ ASSERT0(err);
+ abd_copy_from_buf_off(data,
+ (char *)db->db.db_data + boff, aoff, len);
+ } else {
+ abd_zero_off(data, aoff, len);
+ }
+
+ mutex_exit(&db->db_mtx);
+ continue;
+ }
+
+ mbuf = make_abd_for_dbuf(db, data, offset, size);
+ ASSERT3P(mbuf, !=, NULL);
+
+ /*
+ * The dbuf mutex (db_mtx) must be held when creating the ZIO
+ * for the read. The BP returned from
+ * dmu_buf_get_bp_from_dbuf() could be from a pending block
+ * clone or a yet to be synced Direct I/O write that is in the
+ * dbuf's dirty record. When zio_read() is called, zio_create()
+ * will make a copy of the BP. However, if zio_read() is called
+ * without the mutex being held then the dirty record from the
+ * dbuf could be freed in dbuf_write_done() resulting in garbage
+ * being set for the zio BP.
+ */
+ zio_t *cio = zio_read(rio, spa, bp, mbuf, db->db.db_size,
+ dmu_read_abd_done, NULL, ZIO_PRIORITY_SYNC_READ,
+ ZIO_FLAG_CANFAIL, &zb);
+ mutex_exit(&db->db_mtx);
+
+ zfs_racct_read(spa, db->db.db_size, 1, flags);
+ zio_nowait(cio);
+ }
+
+ dmu_buf_rele_array(dbp, numbufs, FTAG);
+
+ return (zio_wait(rio));
+
+error:
+ dmu_buf_rele_array(dbp, numbufs, FTAG);
+ (void) zio_wait(rio);
+ return (err);
+}
+
+#ifdef _KERNEL
+int
+dmu_read_uio_direct(dnode_t *dn, zfs_uio_t *uio, uint64_t size)
+{
+ offset_t offset = zfs_uio_offset(uio);
+ offset_t page_index = (offset - zfs_uio_soffset(uio)) >> PAGESHIFT;
+ int err;
+
+ ASSERT(uio->uio_extflg & UIO_DIRECT);
+ ASSERT3U(page_index, <, uio->uio_dio.npages);
+
+ abd_t *data = abd_alloc_from_pages(&uio->uio_dio.pages[page_index],
+ offset & (PAGESIZE - 1), size);
+ err = dmu_read_abd(dn, offset, size, data, DMU_DIRECTIO);
+ abd_free(data);
+
+ if (err == 0)
+ zfs_uioskip(uio, size);
+
+ return (err);
+}
+
+int
+dmu_write_uio_direct(dnode_t *dn, zfs_uio_t *uio, uint64_t size, dmu_tx_t *tx)
+{
+ offset_t offset = zfs_uio_offset(uio);
+ offset_t page_index = (offset - zfs_uio_soffset(uio)) >> PAGESHIFT;
+ int err;
+
+ ASSERT(uio->uio_extflg & UIO_DIRECT);
+ ASSERT3U(page_index, <, uio->uio_dio.npages);
+
+ abd_t *data = abd_alloc_from_pages(&uio->uio_dio.pages[page_index],
+ offset & (PAGESIZE - 1), size);
+ err = dmu_write_abd(dn, offset, size, data, DMU_DIRECTIO, tx);
+ abd_free(data);
+
+ if (err == 0)
+ zfs_uioskip(uio, size);
+
+ return (err);
+}
+#endif /* _KERNEL */
+
+EXPORT_SYMBOL(dmu_read_uio_direct);
+EXPORT_SYMBOL(dmu_write_uio_direct);
os->os_zpl_special_smallblock = newval;
}
+static void
+direct_changed_cb(void *arg, uint64_t newval)
+{
+ objset_t *os = arg;
+
+ /*
+ * Inheritance and range checking should have been done by now.
+ */
+ ASSERT(newval == ZFS_DIRECT_DISABLED || newval == ZFS_DIRECT_STANDARD ||
+ newval == ZFS_DIRECT_ALWAYS);
+
+ os->os_direct = newval;
+}
+
static void
logbias_changed_cb(void *arg, uint64_t newval)
{
ZFS_PROP_SPECIAL_SMALL_BLOCKS),
smallblk_changed_cb, os);
}
+ if (err == 0) {
+ err = dsl_prop_register(ds,
+ zfs_prop_to_name(ZFS_PROP_DIRECT),
+ direct_changed_cb, os);
+ }
}
if (err != 0) {
arc_buf_destroy(os->os_phys_buf, &os->os_phys_buf);
{ "simple_trim_bytes_skipped", KSTAT_DATA_UINT64 },
{ "simple_trim_extents_failed", KSTAT_DATA_UINT64 },
{ "simple_trim_bytes_failed", KSTAT_DATA_UINT64 },
+ { "arc_read_count", KSTAT_DATA_UINT64 },
+ { "arc_read_bytes", KSTAT_DATA_UINT64 },
+ { "arc_write_count", KSTAT_DATA_UINT64 },
+ { "arc_write_bytes", KSTAT_DATA_UINT64 },
+ { "direct_read_count", KSTAT_DATA_UINT64 },
+ { "direct_read_bytes", KSTAT_DATA_UINT64 },
+ { "direct_write_count", KSTAT_DATA_UINT64 },
+ { "direct_write_bytes", KSTAT_DATA_UINT64 },
};
#define SPA_IOSTATS_ADD(stat, val) \
}
}
+void
+spa_iostats_read_add(spa_t *spa, uint64_t size, uint64_t iops, uint32_t flags)
+{
+ spa_history_kstat_t *shk = &spa->spa_stats.iostats;
+ kstat_t *ksp = shk->kstat;
+
+ if (ksp == NULL)
+ return;
+
+ spa_iostats_t *iostats = ksp->ks_data;
+ if (flags & DMU_DIRECTIO) {
+ SPA_IOSTATS_ADD(direct_read_count, iops);
+ SPA_IOSTATS_ADD(direct_read_bytes, size);
+ } else {
+ SPA_IOSTATS_ADD(arc_read_count, iops);
+ SPA_IOSTATS_ADD(arc_read_bytes, size);
+ }
+}
+
+void
+spa_iostats_write_add(spa_t *spa, uint64_t size, uint64_t iops, uint32_t flags)
+{
+ spa_history_kstat_t *shk = &spa->spa_stats.iostats;
+ kstat_t *ksp = shk->kstat;
+
+ if (ksp == NULL)
+ return;
+
+ spa_iostats_t *iostats = ksp->ks_data;
+ if (flags & DMU_DIRECTIO) {
+ SPA_IOSTATS_ADD(direct_write_count, iops);
+ SPA_IOSTATS_ADD(direct_write_bytes, size);
+ } else {
+ SPA_IOSTATS_ADD(arc_write_count, iops);
+ SPA_IOSTATS_ADD(arc_write_bytes, size);
+ }
+}
+
static int
spa_iostats_update(kstat_t *ksp, int rw)
{
*/
static unsigned int zfs_deadman_events_per_second = 1;
+/*
+ * Rate limit direct write IO verify failures to this many per scond.
+ */
+static unsigned int zfs_dio_write_verify_events_per_second = 20;
+
/*
* Rate limit checksum events after this many checksum errors per second.
*/
uint_t zfs_vdev_max_auto_ashift = 14;
uint_t zfs_vdev_min_auto_ashift = ASHIFT_MIN;
+/*
+ * VDEV checksum verification for Direct I/O writes. This is neccessary for
+ * Linux, because anonymous pages can not be placed under write protection
+ * during Direct I/O writes.
+ */
+#if !defined(__FreeBSD__)
+uint_t zfs_vdev_direct_write_verify = 1;
+#else
+uint_t zfs_vdev_direct_write_verify = 0;
+#endif
+
void
vdev_dbgmsg(vdev_t *vd, const char *fmt, ...)
{
1);
zfs_ratelimit_init(&vd->vdev_deadman_rl, &zfs_deadman_events_per_second,
1);
+ zfs_ratelimit_init(&vd->vdev_dio_verify_rl,
+ &zfs_dio_write_verify_events_per_second, 1);
zfs_ratelimit_init(&vd->vdev_checksum_rl,
&zfs_checksum_events_per_second, 1);
zfs_ratelimit_fini(&vd->vdev_delay_rl);
zfs_ratelimit_fini(&vd->vdev_deadman_rl);
+ zfs_ratelimit_fini(&vd->vdev_dio_verify_rl);
zfs_ratelimit_fini(&vd->vdev_checksum_rl);
if (vd == spa->spa_root_vdev)
vd->vdev_stat.vs_read_errors = 0;
vd->vdev_stat.vs_write_errors = 0;
vd->vdev_stat.vs_checksum_errors = 0;
+ vd->vdev_stat.vs_dio_verify_errors = 0;
vd->vdev_stat.vs_slow_ios = 0;
for (int c = 0; c < vd->vdev_children; c++)
ZFS_MODULE_PARAM(zfs, zfs_, deadman_events_per_second, UINT, ZMOD_RW,
"Rate limit hung IO (deadman) events to this many per second");
+ZFS_MODULE_PARAM(zfs, zfs_, dio_write_verify_events_per_second, UINT, ZMOD_RW,
+ "Rate Direct I/O write verify events to this many per second");
+
/* BEGIN CSTYLED */
+ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, direct_write_verify, UINT, ZMOD_RW,
+ "Direct I/O writes will perform for checksum verification before "
+ "commiting write");
+
ZFS_MODULE_PARAM(zfs, zfs_, checksum_events_per_second, UINT, ZMOD_RW,
"Rate limit checksum events to this many checksum errors per second "
"(do not set below ZED threshold).");
/* IO delays */
fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SLOW_IOS, vs->vs_slow_ios);
+ /* Direct I/O write verify errors */
+ fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_DIO_VERIFY_ERRORS,
+ vs->vs_dio_verify_errors);
+
/* Add extended stats nvlist to main nvlist */
fnvlist_add_nvlist(nv, ZPOOL_CONFIG_VDEV_STATS_EX, nvx);
DATA_TYPE_UINT64, vs->vs_checksum_errors,
FM_EREPORT_PAYLOAD_ZFS_VDEV_DELAYS,
DATA_TYPE_UINT64, vs->vs_slow_ios,
+ FM_EREPORT_PAYLOAD_ZFS_VDEV_DIO_VERIFY_ERRORS,
+ DATA_TYPE_UINT64, vs->vs_dio_verify_errors,
NULL);
}
#include <sys/types.h>
#include <sys/param.h>
#include <sys/errno.h>
-#include <sys/uio_impl.h>
#include <sys/file.h>
#include <sys/kmem.h>
#include <sys/cmn_err.h>
void
zfs_log_write(zilog_t *zilog, dmu_tx_t *tx, int txtype,
znode_t *zp, offset_t off, ssize_t resid, boolean_t commit,
- zil_callback_t callback, void *callback_data)
+ boolean_t o_direct, zil_callback_t callback, void *callback_data)
{
dmu_buf_impl_t *db = (dmu_buf_impl_t *)sa_get_db(zp->z_sa_hdl);
uint32_t blocksize = zp->z_blksz;
return;
}
- if (zilog->zl_logbias == ZFS_LOGBIAS_THROUGHPUT)
+ if (zilog->zl_logbias == ZFS_LOGBIAS_THROUGHPUT || o_direct)
write_state = WR_INDIRECT;
else if (!spa_has_slogs(zilog->zl_spa) &&
resid >= zfs_immediate_write_sz)
#include <sys/time.h>
#include <sys/sysmacros.h>
#include <sys/vfs.h>
-#include <sys/uio_impl.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/kmem.h>
*/
static int zfs_bclone_wait_dirty = 0;
+/*
+ * Enable Direct I/O. If this setting is 0, then all I/O requests will be
+ * directed through the ARC acting as though the dataset property direct was
+ * set to disabled.
+ */
+static int zfs_dio_enabled = 1;
+
+
/*
* Maximum bytes to read per chunk in zfs_read().
*/
return (error);
}
+/*
+ * Determine if Direct I/O has been requested (either via the O_DIRECT flag or
+ * the "direct" dataset property). When inherited by the property only apply
+ * the O_DIRECT flag to correctly aligned IO requests. The rational for this
+ * is it allows the property to be safely set on a dataset without forcing
+ * all of the applications to be aware of the alignment restrictions. When
+ * O_DIRECT is explicitly requested by an application return EINVAL if the
+ * request is unaligned. In all cases, if the range for this request has
+ * been mmap'ed then we will perform buffered I/O to keep the mapped region
+ * synhronized with the ARC.
+ *
+ * It is possible that a file's pages could be mmap'ed after it is checked
+ * here. If so, that is handled coorarding in zfs_write(). See comments in the
+ * following area for how this is handled:
+ * zfs_write() -> update_pages()
+ */
+static int
+zfs_setup_direct(struct znode *zp, zfs_uio_t *uio, zfs_uio_rw_t rw,
+ int *ioflagp)
+{
+ zfsvfs_t *zfsvfs = ZTOZSB(zp);
+ objset_t *os = zfsvfs->z_os;
+ int ioflag = *ioflagp;
+ int error = 0;
+
+ if (!zfs_dio_enabled || os->os_direct == ZFS_DIRECT_DISABLED ||
+ zn_has_cached_data(zp, zfs_uio_offset(uio),
+ zfs_uio_offset(uio) + zfs_uio_resid(uio) - 1)) {
+ /*
+ * Direct I/O is disabled or the region is mmap'ed. In either
+ * case the I/O request will just directed through the ARC.
+ */
+ ioflag &= ~O_DIRECT;
+ goto out;
+ } else if (os->os_direct == ZFS_DIRECT_ALWAYS &&
+ zfs_uio_page_aligned(uio) &&
+ zfs_uio_aligned(uio, PAGE_SIZE)) {
+ if ((rw == UIO_WRITE && zfs_uio_resid(uio) >= zp->z_blksz) ||
+ (rw == UIO_READ)) {
+ ioflag |= O_DIRECT;
+ }
+ } else if (os->os_direct == ZFS_DIRECT_ALWAYS && (ioflag & O_DIRECT)) {
+ /*
+ * Direct I/O was requested through the direct=always, but it
+ * is not properly PAGE_SIZE aligned. The request will be
+ * directed through the ARC.
+ */
+ ioflag &= ~O_DIRECT;
+ }
+
+ if (ioflag & O_DIRECT) {
+ if (!zfs_uio_page_aligned(uio) ||
+ !zfs_uio_aligned(uio, PAGE_SIZE)) {
+ error = SET_ERROR(EINVAL);
+ goto out;
+ }
+
+ error = zfs_uio_get_dio_pages_alloc(uio, rw);
+ if (error) {
+ goto out;
+ }
+ }
+
+ IMPLY(ioflag & O_DIRECT, uio->uio_extflg & UIO_DIRECT);
+ ASSERT0(error);
+
+out:
+ *ioflagp = ioflag;
+ return (error);
+}
+
/*
* Read bytes from specified file into supplied buffer.
*
error = 0;
goto out;
}
-
ASSERT(zfs_uio_offset(uio) < zp->z_size);
+
+ /*
+ * Setting up Direct I/O if requested.
+ */
+ error = zfs_setup_direct(zp, uio, UIO_READ, &ioflag);
+ if (error) {
+ goto out;
+ }
+
#if defined(__linux__)
ssize_t start_offset = zfs_uio_offset(uio);
#endif
+ ssize_t chunk_size = zfs_vnops_read_chunk_size;
ssize_t n = MIN(zfs_uio_resid(uio), zp->z_size - zfs_uio_offset(uio));
ssize_t start_resid = n;
+ ssize_t dio_remaining_resid = 0;
+
+ if (uio->uio_extflg & UIO_DIRECT) {
+ /*
+ * All pages for an O_DIRECT request ahve already been mapped
+ * so there's no compelling reason to handle this uio in
+ * smaller chunks.
+ */
+ chunk_size = DMU_MAX_ACCESS;
+
+ /*
+ * In the event that the O_DIRECT request is reading the entire
+ * file, it is possible file's length is not page sized
+ * aligned. However, lower layers expect that the Direct I/O
+ * request is page-aligned. In this case, as much of the file
+ * that can be read using Direct I/O happens and the remaining
+ * amount will be read through the ARC.
+ *
+ * This is still consistent with the semantics of Direct I/O in
+ * ZFS as at a minimum the I/O request must be page-aligned.
+ */
+ dio_remaining_resid = n - P2ALIGN_TYPED(n, PAGE_SIZE, ssize_t);
+ if (dio_remaining_resid != 0)
+ n -= dio_remaining_resid;
+ }
while (n > 0) {
- ssize_t nbytes = MIN(n, zfs_vnops_read_chunk_size -
- P2PHASE(zfs_uio_offset(uio), zfs_vnops_read_chunk_size));
+ ssize_t nbytes = MIN(n, chunk_size -
+ P2PHASE(zfs_uio_offset(uio), chunk_size));
#ifdef UIO_NOCOPY
if (zfs_uio_segflg(uio) == UIO_NOCOPY)
error = mappedread_sf(zp, nbytes, uio);
else
#endif
if (zn_has_cached_data(zp, zfs_uio_offset(uio),
- zfs_uio_offset(uio) + nbytes - 1) && !(ioflag & O_DIRECT)) {
+ zfs_uio_offset(uio) + nbytes - 1)) {
error = mappedread(zp, nbytes, uio);
} else {
error = dmu_read_uio_dbuf(sa_get_db(zp->z_sa_hdl),
n -= nbytes;
}
+ if (error == 0 && (uio->uio_extflg & UIO_DIRECT) &&
+ dio_remaining_resid != 0) {
+ /*
+ * Temporarily remove the UIO_DIRECT flag from the UIO so the
+ * remainder of the file can be read using the ARC.
+ */
+ uio->uio_extflg &= ~UIO_DIRECT;
+
+ if (zn_has_cached_data(zp, zfs_uio_offset(uio),
+ zfs_uio_offset(uio) + dio_remaining_resid - 1)) {
+ error = mappedread(zp, dio_remaining_resid, uio);
+ } else {
+ error = dmu_read_uio_dbuf(sa_get_db(zp->z_sa_hdl), uio,
+ dio_remaining_resid);
+ }
+ uio->uio_extflg |= UIO_DIRECT;
+
+ if (error != 0)
+ n += dio_remaining_resid;
+ } else if (error && (uio->uio_extflg & UIO_DIRECT)) {
+ n += dio_remaining_resid;
+ }
int64_t nread = start_resid - n;
+
dataset_kstats_update_read_kstats(&zfsvfs->z_kstat, nread);
- task_io_account_read(nread);
out:
zfs_rangelock_exit(lr);
+ /*
+ * Cleanup for Direct I/O if requested.
+ */
+ if (uio->uio_extflg & UIO_DIRECT)
+ zfs_uio_free_dio_pages(uio, UIO_READ);
+
ZFS_ACCESSTIME_STAMP(zfsvfs, zp);
zfs_exit(zfsvfs, FTAG);
return (error);
int error = 0, error1;
ssize_t start_resid = zfs_uio_resid(uio);
uint64_t clear_setid_bits_txg = 0;
+ boolean_t o_direct_defer = B_FALSE;
/*
* Fasttrack empty write
return (SET_ERROR(EINVAL));
}
+ /*
+ * Setting up Direct I/O if requested.
+ */
+ error = zfs_setup_direct(zp, uio, UIO_WRITE, &ioflag);
+ if (error) {
+ zfs_exit(zfsvfs, FTAG);
+ return (SET_ERROR(error));
+ }
+
/*
* Pre-fault the pages to ensure slow (eg NFS) pages
* don't hold up txg.
woff = zp->z_size;
}
zfs_uio_setoffset(uio, woff);
+ /*
+ * We need to update the starting offset as well because it is
+ * set previously in the ZPL (Linux) and VNOPS (FreeBSD)
+ * layers.
+ */
+ zfs_uio_setsoffset(uio, woff);
} else {
/*
* Note that if the file block size will change as a result of
const uint64_t gid = KGID_TO_SGID(ZTOGID(zp));
const uint64_t projid = zp->z_projid;
+ /*
+ * In the event we are increasing the file block size
+ * (lr_length == UINT64_MAX), we will direct the write to the ARC.
+ * Because zfs_grow_blocksize() will read from the ARC in order to
+ * grow the dbuf, we avoid doing Direct I/O here as that would cause
+ * data written to disk to be overwritten by data in the ARC during
+ * the sync phase. Besides writing data twice to disk, we also
+ * want to avoid consistency concerns between data in the the ARC and
+ * on disk while growing the file's blocksize.
+ *
+ * We will only temporarily remove Direct I/O and put it back after
+ * we have grown the blocksize. We do this in the event a request
+ * is larger than max_blksz, so further requests to
+ * dmu_write_uio_dbuf() will still issue the requests using Direct
+ * IO.
+ *
+ * As an example:
+ * The first block to file is being written as a 4k request with
+ * a recorsize of 1K. The first 1K issued in the loop below will go
+ * through the ARC; however, the following 3 1K requests will
+ * use Direct I/O.
+ */
+ if (uio->uio_extflg & UIO_DIRECT && lr->lr_length == UINT64_MAX) {
+ uio->uio_extflg &= ~UIO_DIRECT;
+ o_direct_defer = B_TRUE;
+ }
+
/*
* Write the file in reasonable size chunks. Each chunk is written
* in a separate transaction; this keeps the intent log records small
ssize_t nbytes = n;
if (n >= blksz && woff >= zp->z_size &&
P2PHASE(woff, blksz) == 0 &&
+ !(uio->uio_extflg & UIO_DIRECT) &&
(blksz >= SPA_OLD_MAXBLOCKSIZE || n < 4 * blksz)) {
/*
* This write covers a full block. "Borrow" a buffer
zfs_uioskip(uio, nbytes);
tx_bytes = nbytes;
}
+ /*
+ * There is a window where a file's pages can be mmap'ed after
+ * zfs_setup_direct() is called. This is due to the fact that
+ * the rangelock in this function is acquired after calling
+ * zfs_setup_direct(). This is done so that
+ * zfs_uio_prefaultpages() does not attempt to fault in pages
+ * on Linux for Direct I/O requests. This is not necessary as
+ * the pages are pinned in memory and can not be faulted out.
+ * Ideally, the rangelock would be held before calling
+ * zfs_setup_direct() and zfs_uio_prefaultpages(); however,
+ * this can lead to a deadlock as zfs_getpage() also acquires
+ * the rangelock as a RL_WRITER and prefaulting the pages can
+ * lead to zfs_getpage() being called.
+ *
+ * In the case of the pages being mapped after
+ * zfs_setup_direct() is called, the call to update_pages()
+ * will still be made to make sure there is consistency between
+ * the ARC and the Linux page cache. This is an ufortunate
+ * situation as the data will be read back into the ARC after
+ * the Direct I/O write has completed, but this is the penality
+ * for writing to a mmap'ed region of a file using Direct I/O.
+ */
if (tx_bytes &&
- zn_has_cached_data(zp, woff, woff + tx_bytes - 1) &&
- !(ioflag & O_DIRECT)) {
+ zn_has_cached_data(zp, woff, woff + tx_bytes - 1)) {
update_pages(zp, woff, tx_bytes, zfsvfs->z_os);
}
* the TX_WRITE records logged here.
*/
zfs_log_write(zilog, tx, TX_WRITE, zp, woff, tx_bytes, commit,
- NULL, NULL);
+ uio->uio_extflg & UIO_DIRECT ? B_TRUE : B_FALSE, NULL,
+ NULL);
dmu_tx_commit(tx);
+ /*
+ * Direct I/O was deferred in order to grow the first block.
+ * At this point it can be re-enabled for subsequent writes.
+ */
+ if (o_direct_defer) {
+ ASSERT(ioflag & O_DIRECT);
+ uio->uio_extflg |= UIO_DIRECT;
+ o_direct_defer = B_FALSE;
+ }
+
if (error != 0)
break;
ASSERT3S(tx_bytes, ==, nbytes);
pfbytes -= nbytes;
}
+ if (o_direct_defer) {
+ ASSERT(ioflag & O_DIRECT);
+ uio->uio_extflg |= UIO_DIRECT;
+ o_direct_defer = B_FALSE;
+ }
+
zfs_znode_update_vfs(zp);
zfs_rangelock_exit(lr);
+ /*
+ * Cleanup for Direct I/O if requested.
+ */
+ if (uio->uio_extflg & UIO_DIRECT)
+ zfs_uio_free_dio_pages(uio, UIO_WRITE);
+
/*
* If we're in replay mode, or we made no progress, or the
* uio data is inaccessible return an error. Otherwise, it's
if (commit)
zil_commit(zilog, zp->z_id);
- const int64_t nwritten = start_resid - zfs_uio_resid(uio);
+ int64_t nwritten = start_resid - zfs_uio_resid(uio);
dataset_kstats_update_write_kstats(&zfsvfs->z_kstat, nwritten);
- task_io_account_write(nwritten);
zfs_exit(zfsvfs, FTAG);
return (0);
uint64_t object = lr->lr_foid;
uint64_t offset = lr->lr_offset;
uint64_t size = lr->lr_length;
- dmu_buf_t *db;
zgd_t *zgd;
int error = 0;
uint64_t zp_gen;
* we don't have to write the data twice.
*/
if (buf != NULL) { /* immediate write */
- zgd->zgd_lr = zfs_rangelock_enter(&zp->z_rangelock,
- offset, size, RL_READER);
+ zgd->zgd_lr = zfs_rangelock_enter(&zp->z_rangelock, offset,
+ size, RL_READER);
/* test for truncation needs to be done while range locked */
if (offset >= zp->z_size) {
error = SET_ERROR(ENOENT);
zil_fault_io = 0;
}
#endif
+
+ dmu_buf_t *dbp;
if (error == 0)
error = dmu_buf_hold_noread(os, object, offset, zgd,
- &db);
+ &dbp);
if (error == 0) {
- blkptr_t *bp = &lr->lr_blkptr;
+ zgd->zgd_db = dbp;
+ dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp;
+ boolean_t direct_write = B_FALSE;
+ mutex_enter(&db->db_mtx);
+ dbuf_dirty_record_t *dr =
+ dbuf_find_dirty_eq(db, lr->lr_common.lrc_txg);
+ if (dr != NULL && dr->dt.dl.dr_diowrite)
+ direct_write = B_TRUE;
+ mutex_exit(&db->db_mtx);
+
+ /*
+ * All Direct I/O writes will have already completed and
+ * the block pointer can be immediately stored in the
+ * log record.
+ */
+ if (direct_write) {
+ /*
+ * A Direct I/O write always covers an entire
+ * block.
+ */
+ ASSERT3U(dbp->db_size, ==, zp->z_blksz);
+ lr->lr_blkptr = dr->dt.dl.dr_overridden_by;
+ zfs_get_done(zgd, 0);
+ return (0);
+ }
- zgd->zgd_db = db;
+ blkptr_t *bp = &lr->lr_blkptr;
zgd->zgd_bp = bp;
- ASSERT(db->db_offset == offset);
- ASSERT(db->db_size == size);
+ ASSERT3U(dbp->db_offset, ==, offset);
+ ASSERT3U(dbp->db_size, ==, size);
error = dmu_sync(zio, lr->lr_common.lrc_txg,
zfs_get_done, zgd);
return (error);
}
-
static void
zfs_get_done(zgd_t *zgd, int error)
{
ZFS_MODULE_PARAM(zfs, zfs_, bclone_wait_dirty, INT, ZMOD_RW,
"Wait for dirty blocks when cloning");
+
+ZFS_MODULE_PARAM(zfs, zfs_, dio_enabled, INT, ZMOD_RW,
+ "Enable Direct I/O");
pio->io_reexecute |= zio->io_reexecute;
ASSERT3U(*countp, >, 0);
+ if (zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR) {
+ ASSERT3U(*errorp, ==, EIO);
+ ASSERT3U(pio->io_child_type, ==, ZIO_CHILD_LOGICAL);
+ pio->io_flags |= ZIO_FLAG_DIO_CHKSUM_ERR;
+ }
+
(*countp)--;
if (*countp == 0 && pio->io_stall == countp) {
zio_flag_t flags, const zbookmark_phys_t *zb)
{
zio_t *zio;
+ enum zio_stage pipeline = zp->zp_direct_write == B_TRUE ?
+ ZIO_DIRECT_WRITE_PIPELINE : (flags & ZIO_FLAG_DDT_CHILD) ?
+ ZIO_DDT_CHILD_WRITE_PIPELINE : ZIO_WRITE_PIPELINE;
- ASSERT(zp->zp_checksum >= ZIO_CHECKSUM_OFF &&
- zp->zp_checksum < ZIO_CHECKSUM_FUNCTIONS &&
- zp->zp_compress >= ZIO_COMPRESS_OFF &&
- zp->zp_compress < ZIO_COMPRESS_FUNCTIONS &&
- DMU_OT_IS_VALID(zp->zp_type) &&
- zp->zp_level < 32 &&
- zp->zp_copies > 0 &&
- zp->zp_copies <= spa_max_replication(spa));
zio = zio_create(pio, spa, txg, bp, data, lsize, psize, done, private,
ZIO_TYPE_WRITE, priority, flags, NULL, 0, zb,
- ZIO_STAGE_OPEN, (flags & ZIO_FLAG_DDT_CHILD) ?
- ZIO_DDT_CHILD_WRITE_PIPELINE : ZIO_WRITE_PIPELINE);
+ ZIO_STAGE_OPEN, pipeline);
zio->io_ready = ready;
zio->io_children_ready = children_ready;
*/
pipeline |= ZIO_STAGE_CHECKSUM_VERIFY;
pio->io_pipeline &= ~ZIO_STAGE_CHECKSUM_VERIFY;
+ } else if (type == ZIO_TYPE_WRITE &&
+ pio->io_prop.zp_direct_write == B_TRUE) {
+ /*
+ * By default we only will verify checksums for Direct I/O
+ * writes for Linux. FreeBSD is able to place user pages under
+ * write protection before issuing them to the ZIO pipeline.
+ *
+ * Checksum validation errors will only be reported through
+ * the top-level VDEV, which is set by this child ZIO.
+ */
+ ASSERT3P(bp, !=, NULL);
+ ASSERT3U(pio->io_child_type, ==, ZIO_CHILD_LOGICAL);
+ pipeline |= ZIO_STAGE_DIO_CHECKSUM_VERIFY;
}
if (vd->vdev_ops->vdev_op_leaf) {
zp.zp_nopwrite = B_FALSE;
zp.zp_encrypt = gio->io_prop.zp_encrypt;
zp.zp_byteorder = gio->io_prop.zp_byteorder;
+ zp.zp_direct_write = B_FALSE;
memset(zp.zp_salt, 0, ZIO_DATA_SALT_LEN);
memset(zp.zp_iv, 0, ZIO_DATA_IV_LEN);
memset(zp.zp_mac, 0, ZIO_DATA_MAC_LEN);
ASSERT(BP_GET_CHECKSUM(bp) == zp->zp_checksum);
ASSERT(BP_IS_HOLE(bp) || zio->io_bp_override);
ASSERT(!(zio->io_bp_override && (zio->io_flags & ZIO_FLAG_RAW)));
+ /*
+ * Deduplication will not take place for Direct I/O writes. The
+ * ddt_tree will be emptied in syncing context. Direct I/O writes take
+ * place in the open-context. Direct I/O write can not attempt to
+ * modify the ddt_tree while issuing out a write.
+ */
+ ASSERT3B(zio->io_prop.zp_direct_write, ==, B_FALSE);
ddt_enter(ddt);
dde = ddt_lookup(ddt, bp);
zio->io_vsd = NULL;
}
+ /*
+ * If a Direct I/O write checksum verify error has occurred then this
+ * I/O should not attempt to be issued again. Instead the EIO will
+ * be returned.
+ */
+ if (zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR) {
+ ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_LOGICAL);
+ ASSERT3U(zio->io_error, ==, EIO);
+ zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
+ return (zio);
+ }
+
+
if (zio_injection_enabled && zio->io_error == 0)
zio->io_error = zio_handle_fault_injection(zio, EIO);
return (zio);
}
+static zio_t *
+zio_dio_checksum_verify(zio_t *zio)
+{
+ zio_t *pio = zio_unique_parent(zio);
+ int error;
+
+ ASSERT3P(zio->io_vd, !=, NULL);
+ ASSERT3P(zio->io_bp, !=, NULL);
+ ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);
+ ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
+ ASSERT3B(pio->io_prop.zp_direct_write, ==, B_TRUE);
+ ASSERT3U(pio->io_child_type, ==, ZIO_CHILD_LOGICAL);
+
+ if (zfs_vdev_direct_write_verify == 0 || zio->io_error != 0)
+ goto out;
+
+ if ((error = zio_checksum_error(zio, NULL)) != 0) {
+ zio->io_error = error;
+ if (error == ECKSUM) {
+ mutex_enter(&zio->io_vd->vdev_stat_lock);
+ zio->io_vd->vdev_stat.vs_dio_verify_errors++;
+ mutex_exit(&zio->io_vd->vdev_stat_lock);
+ zio->io_error = SET_ERROR(EIO);
+ zio->io_flags |= ZIO_FLAG_DIO_CHKSUM_ERR;
+
+ /*
+ * The EIO error must be propagated up to the logical
+ * parent ZIO in zio_notify_parent() so it can be
+ * returned to dmu_write_abd().
+ */
+ zio->io_flags &= ~ZIO_FLAG_DONT_PROPAGATE;
+
+ (void) zfs_ereport_post(FM_EREPORT_ZFS_DIO_VERIFY,
+ zio->io_spa, zio->io_vd, &zio->io_bookmark,
+ zio, 0);
+ }
+ }
+
+out:
+ return (zio);
+}
+
+
/*
* Called by RAID-Z to ensure we don't compute the checksum twice.
*/
* device is currently unavailable.
*/
if (zio->io_error != ECKSUM && zio->io_vd != NULL &&
- !vdev_is_dead(zio->io_vd)) {
+ !vdev_is_dead(zio->io_vd) &&
+ !(zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR)) {
int ret = zfs_ereport_post(FM_EREPORT_ZFS_IO,
zio->io_spa, zio->io_vd, &zio->io_bookmark, zio, 0);
if (ret != EALREADY) {
if ((zio->io_error == EIO || !(zio->io_flags &
(ZIO_FLAG_SPECULATIVE | ZIO_FLAG_DONT_PROPAGATE))) &&
+ !(zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR) &&
zio == zio->io_logical) {
/*
* For logical I/O requests, tell the SPA to log the
ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
if (IO_IS_ALLOCATING(zio) &&
- !(zio->io_flags & ZIO_FLAG_CANFAIL)) {
+ !(zio->io_flags & ZIO_FLAG_CANFAIL) &&
+ !(zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR)) {
if (zio->io_error != ENOSPC)
zio->io_reexecute |= ZIO_REEXECUTE_NOW;
else
zio->io_reexecute &= ~ZIO_REEXECUTE_SUSPEND;
if (zio->io_reexecute) {
+ /*
+ * A Direct I/O write that has a checksum verify error should
+ * not attempt to reexecute. Instead, EAGAIN should just be
+ * propagated back up so the write can be attempt to be issued
+ * through the ARC.
+ */
+ ASSERT(!(zio->io_flags & ZIO_FLAG_DIO_CHKSUM_ERR));
+
/*
* This is a logical I/O that wants to reexecute.
*
zio_vdev_io_done,
zio_vdev_io_assess,
zio_checksum_verify,
+ zio_dio_checksum_verify,
zio_done
};
'zfs_unallow_007_neg', 'zfs_unallow_008_neg']
tags = ['functional', 'delegate']
+[tests/functional/direct]
+tests = ['dio_aligned_block', 'dio_async_always', 'dio_async_fio_ioengines',
+ 'dio_compression', 'dio_dedup', 'dio_encryption', 'dio_grow_block',
+ 'dio_max_recordsize', 'dio_mixed', 'dio_mmap', 'dio_overwrites',
+ 'dio_property', 'dio_random', 'dio_recordsize', 'dio_unaligned_block',
+ 'dio_unaligned_filesize']
+tags = ['functional', 'direct']
+
[tests/functional/exec]
tests = ['exec_001_pos', 'exec_002_neg']
tags = ['functional', 'exec']
tags = ['functional', 'inheritance']
[tests/functional/io]
-tests = ['sync', 'psync', 'posixaio', 'mmap']
+tests = ['mmap', 'posixaio', 'psync', 'sync']
tags = ['functional', 'io']
[tests/functional/inuse]
tests = ['pam_basic', 'pam_change_unmounted', 'pam_nounmount', 'pam_recursive',
'pam_short_password']
tags = ['functional', 'pam']
+
+[tests/functional/direct:FreeBSD]
+tests = ['dio_write_stable_pages']
+tags = ['functional', 'direct']
tests = ['devices_001_pos', 'devices_002_neg', 'devices_003_pos']
tags = ['functional', 'devices']
+[tests/functional/direct:Linux]
+tests = ['dio_write_verify']
+tags = ['functional', 'direct']
+
[tests/functional/events:Linux]
tests = ['events_001_pos', 'events_002_pos', 'zed_rc_filter', 'zed_fd_spill',
'zed_cksum_reported', 'zed_cksum_config', 'zed_io_config',
/getversion
/largest_file
/libzfs_input_check
+/manipulate_user_buffer
/mkbusy
/mkfile
/mkfiles
libzfs_core.la \
libnvpair.la
+scripts_zfs_tests_bin_PROGRAMS += %D%/manipulate_user_buffer
+%C%_manipulate_user_buffer_LDADD = -lpthread
scripts_zfs_tests_bin_PROGRAMS += %D%/mkbusy %D%/mkfile %D%/mkfiles %D%/mktree
%C%_mkfile_LDADD = $(LTLIBINTL)
--- /dev/null
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or https://opensource.org/licenses/CDDL-1.0.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (c) 2022 by Triad National Security, LLC.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <pthread.h>
+#include <assert.h>
+
+#ifndef MIN
+#define MIN(a, b) ((a) < (b)) ? (a) : (b)
+#endif
+
+static char *outputfile = NULL;
+static int blocksize = 131072; /* 128K */
+static int wr_err_expected = 0;
+static int numblocks = 100;
+static char *execname = NULL;
+static int print_usage = 0;
+static int randompattern = 0;
+static int ofd;
+char *buf = NULL;
+
+typedef struct {
+ int entire_file_written;
+} pthread_args_t;
+
+static void
+usage(void)
+{
+ (void) fprintf(stderr,
+ "usage %s -o outputfile [-b blocksize] [-e wr_error_expected]\n"
+ " [-n numblocks] [-p randpattern] [-h help]\n"
+ "\n"
+ "Testing whether checksum verify works correctly for O_DIRECT.\n"
+ "when manipulating the contents of a userspace buffer.\n"
+ "\n"
+ " outputfile: File to write to.\n"
+ " blocksize: Size of each block to write (must be at \n"
+ " least >= 512).\n"
+ " wr_err_expected: Whether pwrite() is expected to return EIO\n"
+ " while manipulating the contents of the\n"
+ " buffer.\n"
+ " numblocks: Total number of blocksized blocks to\n"
+ " write.\n"
+ " randpattern: Fill data buffer with random data. Default\n"
+ " behavior is to fill the buffer with the \n"
+ " known data pattern (0xdeadbeef).\n"
+ " help: Print usage information and exit.\n"
+ "\n"
+ " Required parameters:\n"
+ " outputfile\n"
+ "\n"
+ " Default Values:\n"
+ " blocksize -> 131072\n"
+ " wr_err_expexted -> false\n"
+ " numblocks -> 100\n"
+ " randpattern -> false\n",
+ execname);
+ (void) exit(1);
+}
+
+static void
+parse_options(int argc, char *argv[])
+{
+ int c;
+ int errflag = 0;
+ extern char *optarg;
+ extern int optind, optopt;
+ execname = argv[0];
+
+ while ((c = getopt(argc, argv, "b:ehn:o:p")) != -1) {
+ switch (c) {
+ case 'b':
+ blocksize = atoi(optarg);
+ break;
+
+ case 'e':
+ wr_err_expected = 1;
+ break;
+
+ case 'h':
+ print_usage = 1;
+ break;
+
+ case 'n':
+ numblocks = atoi(optarg);
+ break;
+
+ case 'o':
+ outputfile = optarg;
+ break;
+
+ case 'p':
+ randompattern = 1;
+ break;
+
+ case ':':
+ (void) fprintf(stderr,
+ "Option -%c requires an opertand\n",
+ optopt);
+ errflag++;
+ break;
+ case '?':
+ default:
+ (void) fprintf(stderr,
+ "Unrecognized option: -%c\n", optopt);
+ errflag++;
+ break;
+ }
+ }
+
+ if (errflag || print_usage == 1)
+ (void) usage();
+
+ if (blocksize < 512 || outputfile == NULL || numblocks <= 0) {
+ (void) fprintf(stderr,
+ "Required paramater(s) missing or invalid.\n");
+ (void) usage();
+ }
+}
+
+/*
+ * Write blocksize * numblocks to the file using O_DIRECT.
+ */
+static void *
+write_thread(void *arg)
+{
+ size_t offset = 0;
+ int total_data = blocksize * numblocks;
+ int left = total_data;
+ ssize_t wrote = 0;
+ pthread_args_t *args = (pthread_args_t *)arg;
+
+ while (!args->entire_file_written) {
+ wrote = pwrite(ofd, buf, blocksize, offset);
+ if (wrote != blocksize) {
+ if (wr_err_expected)
+ assert(errno == EIO);
+ else
+ exit(2);
+ }
+
+ offset = ((offset + blocksize) % total_data);
+ left -= blocksize;
+
+ if (left == 0)
+ args->entire_file_written = 1;
+ }
+
+ pthread_exit(NULL);
+}
+
+/*
+ * Update the buffers contents with random data.
+ */
+static void *
+manipulate_buf_thread(void *arg)
+{
+ size_t rand_offset;
+ char rand_char;
+ pthread_args_t *args = (pthread_args_t *)arg;
+
+ while (!args->entire_file_written) {
+ rand_offset = (rand() % blocksize);
+ rand_char = (rand() % (126 - 33) + 33);
+ buf[rand_offset] = rand_char;
+ }
+
+ pthread_exit(NULL);
+}
+
+int
+main(int argc, char *argv[])
+{
+ const char *datapattern = "0xdeadbeef";
+ int ofd_flags = O_WRONLY | O_CREAT | O_DIRECT;
+ mode_t mode = S_IRUSR | S_IWUSR;
+ pthread_t write_thr;
+ pthread_t manipul_thr;
+ int left = blocksize;
+ int offset = 0;
+ int rc;
+ pthread_args_t args = { 0 };
+
+ parse_options(argc, argv);
+
+ ofd = open(outputfile, ofd_flags, mode);
+ if (ofd == -1) {
+ (void) fprintf(stderr, "%s, %s\n", execname, outputfile);
+ perror("open");
+ exit(2);
+ }
+
+ int err = posix_memalign((void **)&buf, sysconf(_SC_PAGE_SIZE),
+ blocksize);
+ if (err != 0) {
+ (void) fprintf(stderr,
+ "%s: %s\n", execname, strerror(err));
+ exit(2);
+ }
+
+ if (!randompattern) {
+ /* Putting known data pattern in buffer */
+ while (left) {
+ size_t amt = MIN(strlen(datapattern), left);
+ memcpy(&buf[offset], datapattern, amt);
+ offset += amt;
+ left -= amt;
+ }
+ } else {
+ /* Putting random data in buffer */
+ for (int i = 0; i < blocksize; i++)
+ buf[i] = rand();
+ }
+
+ /*
+ * Writing using O_DIRECT while manipulating the buffer contents until
+ * the entire file is written.
+ */
+ if ((rc = pthread_create(&manipul_thr, NULL, manipulate_buf_thread,
+ &args))) {
+ fprintf(stderr, "error: pthreads_create, manipul_thr, "
+ "rc: %d\n", rc);
+ exit(2);
+ }
+
+ if ((rc = pthread_create(&write_thr, NULL, write_thread, &args))) {
+ fprintf(stderr, "error: pthreads_create, write_thr, "
+ "rc: %d\n", rc);
+ exit(2);
+ }
+
+ pthread_join(write_thr, NULL);
+ pthread_join(manipul_thr, NULL);
+
+ assert(args.entire_file_written == 1);
+
+ (void) close(ofd);
+
+ free(buf);
+
+ return (0);
+}
#include <stdlib.h>
#include <string.h>
+static int alignment = 0;
static int bsize = 0;
static int count = 0;
static char *ifile = NULL;
static char *ofile = NULL;
-static off_t stride = 0;
+static off_t stride = 1;
static off_t seek = 0;
+static int seekbytes = 0;
+static int if_o_direct = 0;
+static int of_o_direct = 0;
+static int skip = 0;
+static int skipbytes = 0;
+static int entire_file = 0;
static const char *execname = "stride_dd";
static void usage(void);
usage(void)
{
(void) fprintf(stderr,
- "usage: %s -i inputfile -o outputfile -b blocksize -c count \n"
- " -s stride [ -k seekblocks]\n"
+ "usage: %s -i inputfile -o outputfile -b blocksize [-c count]\n"
+ " [-s stride] [-k seekblocks] [-K seekbytes]\n"
+ " [-a alignment] [-d if_o_direct] [-D of_o_direct]\n"
+ " [-p skipblocks] [-P skipbytes] [-e entire_file]\n"
"\n"
"Simplified version of dd that supports the stride option.\n"
"A stride of n means that for each block written, n - 1 blocks\n"
"means that blocks are read and written consecutively.\n"
"All numeric parameters must be integers.\n"
"\n"
- " inputfile: File to read from\n"
- " outputfile: File to write to\n"
- " blocksize: Size of each block to read/write\n"
- " count: Number of blocks to read/write\n"
- " stride: Read/write a block then skip (stride - 1) blocks\n"
- " seekblocks: Number of blocks to skip at start of output\n",
+ " inputfile: File to read from\n"
+ " outputfile: File to write to\n"
+ " blocksize: Size of each block to read/write\n"
+ " count: Number of blocks to read/write (Required"
+ " unless -e is used)\n"
+ " stride: Read/write a block then skip (stride - 1) blocks"
+ "\n"
+ " seekblocks: Number of blocks to skip at start of output\n"
+ " seekbytes: Treat seekblocks as byte count\n"
+ " alignment: Alignment passed to posix_memalign() (default"
+ " PAGE_SIZE)\n"
+ " if_o_direct: Use O_DIRECT with inputfile (default no O_DIRECT)"
+ "\n"
+ " of_o_direct: Use O_DIRECT with outputfile (default no "
+ " O_DIRECT)\n"
+ " skipblocks: Number of blocks to skip at start of input "
+ " (default 0)\n"
+ " skipbytes: Treat skipblocks as byte count\n"
+ " entire_file: When used the entire inputfile will be read and"
+ " count will be ignored\n",
execname);
(void) exit(1);
}
+/*
+ * posix_memalign() only allows for alignments which are postive, powers of two
+ * and a multiple of sizeof (void *).
+ */
+static int
+invalid_alignment(int alignment)
+{
+ if ((alignment < 0) || (alignment & (alignment - 1)) ||
+ ((alignment % sizeof (void *)))) {
+ (void) fprintf(stderr,
+ "Alignment must be a postive, power of two, and multiple "
+ "of sizeof (void *).\n");
+ return (1);
+ }
+ return (0);
+}
+
static void
parse_options(int argc, char *argv[])
{
int errflag = 0;
execname = argv[0];
+ alignment = sysconf(_SC_PAGE_SIZE);
extern char *optarg;
extern int optind, optopt;
- while ((c = getopt(argc, argv, ":b:c:i:o:s:k:")) != -1) {
+ while ((c = getopt(argc, argv, "a:b:c:deDi:o:s:k:Kp:P")) != -1) {
switch (c) {
+ case 'a':
+ alignment = atoi(optarg);
+ break;
+
case 'b':
bsize = atoi(optarg);
break;
count = atoi(optarg);
break;
+ case 'd':
+ if_o_direct = 1;
+ break;
+
+ case 'e':
+ entire_file = 1;
+ break;
+
+ case 'D':
+ of_o_direct = 1;
+ break;
+
case 'i':
ifile = optarg;
break;
seek = atoi(optarg);
break;
+ case 'K':
+ seekbytes = 1;
+ break;
+
+ case 'p':
+ skip = atoi(optarg);
+ break;
+
+ case 'P':
+ skipbytes = 1;
+ break;
+
case ':':
(void) fprintf(stderr,
"Option -%c requires an operand\n", optopt);
}
}
- if (bsize <= 0 || count <= 0 || stride <= 0 || ifile == NULL ||
- ofile == NULL || seek < 0) {
+ if (bsize <= 0 || stride <= 0 || ifile == NULL || ofile == NULL ||
+ seek < 0 || invalid_alignment(alignment) || skip < 0) {
+ (void) fprintf(stderr,
+ "Required parameter(s) missing or invalid.\n");
+ (void) usage();
+ }
+
+ if (count <= 0 && entire_file == 0) {
(void) fprintf(stderr,
"Required parameter(s) missing or invalid.\n");
(void) usage();
}
}
-int
-main(int argc, char *argv[])
+static void
+read_entire_file(int ifd, int ofd, void *buf)
{
- int i;
- int ifd;
- int ofd;
- void *buf;
int c;
- parse_options(argc, argv);
-
- ifd = open(ifile, O_RDONLY);
- if (ifd == -1) {
- (void) fprintf(stderr, "%s: %s: ", execname, ifile);
- perror("open");
- exit(2);
- }
-
- ofd = open(ofile, O_WRONLY | O_CREAT, 0666);
- if (ofd == -1) {
- (void) fprintf(stderr, "%s: %s: ", execname, ofile);
- perror("open");
- exit(2);
- }
-
- /*
- * We use valloc because some character block devices expect a
- * page-aligned buffer.
- */
- int err = posix_memalign(&buf, 4096, bsize);
- if (err != 0) {
- (void) fprintf(stderr,
- "%s: %s\n", execname, strerror(err));
- exit(2);
- }
-
- if (seek > 0) {
- if (lseek(ofd, seek * bsize, SEEK_CUR) == -1) {
- perror("output lseek");
+ do {
+ c = read(ifd, buf, bsize);
+ if (c < 0) {
+ perror("read");
exit(2);
+ } else if (c != 0) {
+ c = write(ofd, buf, bsize);
+ if (c < 0) {
+ perror("write");
+ exit(2);
+ }
+
}
- }
+ if (stride > 1) {
+ if (lseek(ifd, (stride - 1) * bsize, SEEK_CUR) == -1) {
+ perror("input lseek");
+ exit(2);
+ }
+ if (lseek(ofd, (stride - 1) * bsize, SEEK_CUR) == -1) {
+ perror("output lseek");
+ exit(2);
+ }
+ }
+ } while (c != 0);
+}
+
+static void
+read_on_count(int ifd, int ofd, void *buf)
+{
+ int i;
+ int c;
for (i = 0; i < count; i++) {
c = read(ifd, buf, bsize);
- if (c != bsize) {
-
- perror("read");
- exit(2);
- }
if (c != bsize) {
if (c < 0) {
perror("read");
}
}
}
+}
+
+int
+main(int argc, char *argv[])
+{
+ int ifd;
+ int ofd;
+ int ifd_flags = O_RDONLY;
+ int ofd_flags = O_WRONLY | O_CREAT;
+ void *buf;
+
+ parse_options(argc, argv);
+
+ if (if_o_direct)
+ ifd_flags |= O_DIRECT;
+
+ if (of_o_direct)
+ ofd_flags |= O_DIRECT;
+
+ ifd = open(ifile, ifd_flags);
+ if (ifd == -1) {
+ (void) fprintf(stderr, "%s: %s: ", execname, ifile);
+ perror("open");
+ exit(2);
+ }
+
+ ofd = open(ofile, ofd_flags, 0666);
+ if (ofd == -1) {
+ (void) fprintf(stderr, "%s: %s: ", execname, ofile);
+ perror("open");
+ exit(2);
+ }
+
+ /*
+ * We use valloc because some character block devices expect a
+ * page-aligned buffer.
+ */
+ int err = posix_memalign(&buf, alignment, bsize);
+ if (err != 0) {
+ (void) fprintf(stderr,
+ "%s: %s\n", execname, strerror(err));
+ exit(2);
+ }
+
+ if (skip > 0) {
+ int skipamt = skipbytes == 1 ? skip : skip * bsize;
+ if (lseek(ifd, skipamt, SEEK_CUR) == -1) {
+ perror("input lseek");
+ exit(2);
+ }
+ }
+
+ if (seek > 0) {
+ int seekamt = seekbytes == 1 ? seek : seek * bsize;
+ if (lseek(ofd, seekamt, SEEK_CUR) == -1) {
+ perror("output lseek");
+ exit(2);
+ }
+ }
+
+ if (entire_file == 1)
+ read_entire_file(ifd, ofd, buf);
+ else
+ read_on_count(ifd, ofd, buf);
+
free(buf);
(void) close(ofd);
getversion
largest_file
libzfs_input_check
+ manipulate_user_buffer
mkbusy
mkfile
mkfiles
esac
}
+#
+# Compare the MD5 digest of two files.
+#
+function cmp_md5s {
+ typeset file1=$1
+ typeset file2=$2
+
+ typeset sum1=$(md5digest $file1)
+ typeset sum2=$(md5digest $file2)
+ test "$sum1" = "$sum2"
+}
+
#
# Compute SHA256 digest for given file or stdin if no file given.
# Note: file path must not contain spaces
VDEV_FILE_PHYSICAL_ASHIFT vdev.file.physical_ashift vdev_file_physical_ashift
VDEV_MAX_AUTO_ASHIFT vdev.max_auto_ashift zfs_vdev_max_auto_ashift
VDEV_MIN_MS_COUNT vdev.min_ms_count zfs_vdev_min_ms_count
+VDEV_DIRECT_WR_VERIFY vdev.direct_write_verify zfs_vdev_direct_write_verify
VDEV_VALIDATE_SKIP vdev.validate_skip vdev_validate_skip
VOL_INHIBIT_DEV UNSUPPORTED zvol_inhibit_dev
VOL_MODE vol.mode zvol_volmode
VOL_USE_BLK_MQ UNSUPPORTED zvol_use_blk_mq
BCLONE_ENABLED bclone_enabled zfs_bclone_enabled
BCLONE_WAIT_DIRTY bclone_wait_dirty zfs_bclone_wait_dirty
+DIO_ENABLED dio_enabled zfs_dio_enabled
XATTR_COMPAT xattr_compat zfs_xattr_compat
ZEVENT_LEN_MAX zevent.len_max zfs_zevent_len_max
ZEVENT_RETAIN_MAX zevent.retain_max zfs_zevent_retain_max
functional/delegate/delegate_common.kshlib \
functional/devices/devices.cfg \
functional/devices/devices_common.kshlib \
+ functional/direct/dio.cfg \
+ functional/direct/dio.kshlib \
functional/events/events.cfg \
functional/events/events_common.kshlib \
functional/fault/fault.cfg \
functional/devices/devices_002_neg.ksh \
functional/devices/devices_003_pos.ksh \
functional/devices/setup.ksh \
+ functional/direct/dio_aligned_block.ksh \
+ functional/direct/dio_async_always.ksh \
+ functional/direct/dio_async_fio_ioengines.ksh \
+ functional/direct/dio_compression.ksh \
+ functional/direct/dio_dedup.ksh \
+ functional/direct/dio_encryption.ksh \
+ functional/direct/dio_grow_block.ksh \
+ functional/direct/dio_max_recordsize.ksh \
+ functional/direct/dio_mixed.ksh \
+ functional/direct/dio_mmap.ksh \
+ functional/direct/dio_overwrites.ksh \
+ functional/direct/dio_property.ksh \
+ functional/direct/dio_random.ksh \
+ functional/direct/dio_recordsize.ksh \
+ functional/direct/dio_unaligned_block.ksh \
+ functional/direct/dio_unaligned_filesize.ksh \
+ functional/direct/dio_write_verify.ksh \
+ functional/direct/dio_write_stable_pages.ksh \
+ functional/direct/setup.ksh \
+ functional/direct/cleanup.ksh \
functional/dos_attributes/cleanup.ksh \
functional/dos_attributes/read_dos_attrs_001.ksh \
functional/dos_attributes/setup.ksh \
export PERF_COMPCHUNK=0
export BLOCKSIZE=128K
export SYNC_TYPE=0
-export DIRECT=1
+export DIRECT=0
export FILE_SIZE=$(( floor($fill_mb / $NUMJOBS) ))
log_must set_tunable32 L2ARC_WRITE_MAX $(( $VCACHE_SZ * 2 ))
export PERF_COMPCHUNK=0
export BLOCKSIZE=128K
export SYNC_TYPE=0
-export DIRECT=1
+export DIRECT=0
#
# DESCRIPTION:
export PERF_COMPCHUNK=0
export BLOCKSIZE=128K
export SYNC_TYPE=0
-export DIRECT=1
+export DIRECT=0
#
# DESCRIPTION:
export PERF_COMPCHUNK=0
export BLOCKSIZE=128K
export SYNC_TYPE=0
-export DIRECT=1
+export DIRECT=0
#
# DESCRIPTION:
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+
+verify_runnable "global"
+
+default_cleanup_noexit
+
+if tunable_exists DIO_ENABLED ; then
+ log_must restore_tunable DIO_ENABLED
+fi
+
+log_pass
--- /dev/null
+#
+# CDDL HEADER START
+#
+# This file and its contents are supplied under the terms of the
+# Common Development and Distribution License ("CDDL"), version 1.0.
+# You may only use this file in accordance with the terms of version
+# 1.0 of the CDDL.
+#
+# A full copy of the text of the CDDL should have accompanied this
+# source. A copy of the CDDL is also available via the Internet at
+# http://www.illumos.org/license/CDDL.
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2018 by Lawrence Livermore National Security, LLC.
+#
+
+DIO_VDEV1=$TEST_BASE_DIR/file1
+DIO_VDEV2=$TEST_BASE_DIR/file2
+DIO_VDEV3=$TEST_BASE_DIR/file3
+DIO_VDEVS="$DIO_VDEV1 $DIO_VDEV2 $DIO_VDEV3"
+
+DIO_FILESIZE=4M
+DIO_BS=128K
--- /dev/null
+#
+# CDDL HEADER START
+#
+# This file and its contents are supplied under the terms of the
+# Common Development and Distribution License ("CDDL"), version 1.0.
+# You may only use this file in accordance with the terms of version
+# 1.0 of the CDDL.
+#
+# A full copy of the text of the CDDL should have accompanied this
+# source. A copy of the CDDL is also available via the Internet at
+# http://www.illumos.org/license/CDDL.
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+
+function dio_cleanup
+{
+ if poolexists $TESTPOOL1; then
+ destroy_pool $TESTPOOL1
+ fi
+
+ rm -f $DIO_VDEVS
+}
+
+#
+# Generate an IO workload using fio and then verify the resulting data.
+#
+function dio_and_verify # mode file-size block-size directory ioengine extra-args
+{
+ typeset mode=$1
+ typeset size=$2
+ typeset bs=$3
+ typeset mntpnt=$4
+ typeset ioengine=$5
+ typeset extra_args=$6
+
+ # Invoke an fio workload via Direct I/O and verify with Direct I/O.
+ log_must fio --directory=$mntpnt --name=direct-$mode \
+ --rw=$mode --size=$size --bs=$bs --direct=1 --numjobs=1 \
+ --verify=sha1 --ioengine=$ioengine --fallocate=none \
+ --group_reporting --minimal --do_verify=1 $extra_args
+
+ # Now just read back the file without Direct I/O into the ARC as an
+ # additional verfication step.
+ log_must fio --directory=$mntpnt --name=direct-$mode \
+ --rw=read --size=$size --bs=$bs --direct=0 --numjobs=1 \
+ --ioengine=$ioengine --group_reporting --minimal
+
+ log_must rm -f "$mntpnt/direct-*"
+}
+
+#
+# Get zpool status -d checksum verify failures
+#
+function get_zpool_status_chksum_verify_failures # pool_name vdev_type
+{
+ typeset pool=$1
+ typeset vdev_type=$2
+
+ if [[ "$vdev_type" == "stripe" ]]; then
+ val=$(zpool status -dp $pool | \
+ awk '{s+=$6} END {print s}' )
+ elif [[ "$vdev_type" == "mirror" || "$vdev_type" == "raidz" ||
+ "$vdev_type" == "draid" ]]; then
+ val=$(zpool status -dp $pool | \
+ awk -v d="$vdev_type" '$0 ~ d {print $6}' )
+ else
+ log_fail "Unsupported VDEV type in \
+ get_zpool_status_chksum_verify_failures(): $vdev_type"
+ fi
+ echo "$val"
+}
+
+#
+# Get ZED dio_verify events
+#
+function get_zed_dio_verify_events # pool
+{
+ typeset pool=$1
+
+ val=$(zpool events $pool | grep -c dio_verify)
+
+ echo "$val"
+}
+
+#
+# Checking for checksum verify write failures with:
+# zpool status -d
+# zpool events
+# After getting that counts will clear the out the ZPool errors and events
+#
+function check_dio_write_chksum_verify_failures # pool vdev_type expect_errors
+{
+ typeset pool=$1
+ typeset vdev_type=$2
+ typeset expect_errors=$3
+ typeset note_str="expecting none"
+
+ if [[ $expect_errors -ne 0 ]]; then
+ note_str="expecting some"
+ fi
+
+ log_note "Checking for Direct I/O write checksum verify errors \
+ $note_str on ZPool: $pool"
+
+ status_failures=$(get_zpool_status_chksum_verify_failures $pool $vdev_type)
+ zed_dio_verify_events=$(get_zed_dio_verify_events $pool)
+
+ if [[ $expect_errors -ne 0 ]]; then
+ if [[ $status_failures -eq 0 ||
+ $zed_dio_verify_events -eq 0 ]]; then
+ zpool status -dp $pool
+ zpool events $pool
+ log_fail "Checksum verifies in zpool status -d \
+ $status_failures. ZED dio_verify events \
+ $zed_dio_verify_events. Neither should be 0."
+ fi
+ else
+ if [[ $status_failures -ne 0 ||
+ $zed_dio_verify_events -ne 0 ]]; then
+ zpool status -dp $pool
+ zpool events $pool
+ log_fail "Checksum verifies in zpool status -d \
+ $status_failures. ZED dio_verify events \
+ $zed_dio_verify_events. Both should be zero."
+ fi
+ fi
+
+ log_must zpool clear $pool
+ log_must zpool events -c
+
+}
+
+#
+# Get the value of a counter from
+# Linux: /proc/spl/kstat/zfs/$pool/iostats file.
+# FreeBSD: kstat.zfs.$pool.msic.iostats.$stat
+#
+function get_iostats_stat # pool stat
+{
+ typeset pool=$1
+ typeset stat=$2
+
+ if is_linux; then
+ iostats_file=/proc/spl/kstat/zfs/$pool/iostats
+ val=$(grep -m1 "$stat" $iostats_file | awk '{ print $3 }')
+ else
+ val=$(sysctl -n kstat.zfs.$pool.misc.iostats.$stat)
+ fi
+ if [[ -z "$val" ]]; then
+ log_fail "Unable to read $stat counter"
+ fi
+
+ echo "$val"
+}
+
+#
+# Evict any buffered blocks by overwritting them using an O_DIRECT request.
+#
+function evict_blocks
+{
+ typeset pool=$1
+ typeset file=$2
+ typeset size=$3
+
+ log_must stride_dd -i /dev/urandom -o $file -b $size -c 1 -D
+}
+
+#
+# Perform FIO Direct I/O writes to a file with the given arguments.
+# Then verify thae minimum expected number of blocks were written as
+# Direct I/O.
+#
+function verify_dio_write_count #pool bs size mnpnt
+{
+ typeset pool=$1
+ typeset bs=$2
+ typeset size=$3
+ typeset mntpnt=$4
+ typeset dio_wr_expected=$(((size / bs) -1))
+
+ log_note "Checking for $dio_wr_expected Direct I/O writes"
+
+ prev_dio_wr=$(get_iostats_stat $pool direct_write_count)
+ dio_and_verify write $size $bs $mntpnt "sync"
+ curr_dio_wr=$(get_iostats_stat $pool direct_write_count)
+ dio_wr_actual=$((curr_dio_wr - prev_dio_wr))
+
+ if [[ $dio_wr_actual -lt $dio_wr_expected ]]; then
+ if is_linux; then
+ cat /proc/spl/kstat/zfs/$pool/iostats
+ else
+ sysctl kstat.zfs.$pool.misc.iostats
+ fi
+ log_fail "Direct writes $dio_wr_actual of $dio_wr_expected"
+ fi
+}
+
+#
+# Perform a stride_dd write command to the file with the given arguments.
+# Then verify the minimum expected number of blocks were written as either
+# buffered IO (by the ARC), or Direct I/O to the application (dd).
+#
+function check_write # pool file bs count seek flags buf_wr dio_wr
+{
+ typeset pool=$1
+ typeset file=$2
+ typeset bs=$3
+ typeset count=$4
+ typeset seek=$5
+ typeset flags=$6
+ typeset buf_wr_expect=$7
+ typeset dio_wr_expect=$8
+
+ log_note "Checking $count * $bs write(s) at offset $seek, $flags"
+
+ prev_buf_wr=$(get_iostats_stat $pool arc_write_count)
+ prev_dio_wr=$(get_iostats_stat $pool direct_write_count)
+
+ log_must stride_dd -i /dev/urandom -o $file -b $bs -c $count \
+ -k $seek $flags
+
+ curr_buf_wr=$(get_iostats_stat $pool arc_write_count)
+ buf_wr_actual=$((curr_buf_wr - prev_buf_wr))
+
+ curr_dio_wr=$(get_iostats_stat $pool direct_write_count)
+ dio_wr_actual=$((curr_dio_wr - prev_dio_wr))
+
+ if [[ $buf_wr_actual -lt $buf_wr_expect ]]; then
+ if is_linux; then
+ cat /proc/spl/kstat/zfs/$pool/iostats
+ else
+ sysctl kstat.zfs.$pool.misc.iostats
+ fi
+ log_fail "Buffered writes $buf_wr_actual of $buf_wr_expect"
+ fi
+
+ if [[ $dio_wr_actual -lt $dio_wr_expect ]]; then
+ if is_linux; then
+ cat /proc/spl/kstat/zfs/$pool/iostats
+ else
+ sysctl kstat.zfs.$pool.misc.iostats
+ fi
+ log_fail "Direct writes $dio_wr_actual of $dio_wr_expect"
+ fi
+}
+
+#
+# Perform a stride_dd read command to the file with the given arguments.
+# Then verify the minimum expected number of blocks were read as either
+# buffered IO (by the ARC), or Direct I/O to the application (dd).
+#
+function check_read # pool file bs count skip flags buf_rd dio_rd
+{
+ typeset pool=$1
+ typeset file=$2
+ typeset bs=$3
+ typeset count=$4
+ typeset skip=$5
+ typeset flags=$6
+ typeset buf_rd_expect=$7
+ typeset dio_rd_expect=$8
+
+ log_note "Checking $count * $bs read(s) at offset $skip, $flags"
+
+ prev_buf_rd=$(get_iostats_stat $pool arc_read_count)
+ prev_dio_rd=$(get_iostats_stat $pool direct_read_count)
+
+ log_must stride_dd -i $file -o /dev/null -b $bs -c $count \
+ -p $skip $flags
+
+ curr_buf_rd=$(get_iostats_stat $pool arc_read_count)
+ buf_rd_actual=$((curr_buf_rd - prev_buf_rd))
+
+ curr_dio_rd=$(get_iostats_stat $pool direct_read_count)
+ dio_rd_actual=$((curr_dio_rd - prev_dio_rd))
+
+ if [[ $buf_rd_actual -lt $buf_rd_expect ]]; then
+ if is_linux; then
+ cat /proc/spl/kstat/zfs/$pool/iostats
+ else
+ sysctl kstat.zfs.$pool.misc.iostats
+ fi
+ log_fail "Buffered reads $buf_rd_actual of $buf_rd_expect"
+ fi
+
+ if [[ $dio_rd_actual -lt $dio_rd_expect ]]; then
+ if is_linux; then
+ cat /proc/spl/kstat/zfs/$pool/iostats
+ else
+ sysctl kstat.zfs.$pool.misc.iostats
+ fi
+ log_fail "Direct reads $dio_rd_actual of $dio_rd_expect"
+ fi
+}
+
+function get_file_size
+{
+ typeset filename="$1"
+
+ if is_linux; then
+ filesize=$(stat -c %s $filename)
+ else
+ filesize=$(stat -s $filename | awk '{print $8}' | grep -o '[0-9]\+')
+ fi
+
+ echo $filesize
+}
+
+function do_truncate_reduce
+{
+ typeset filename=$1
+ typeset size=$2
+
+ filesize=$(get_file_size $filename)
+ eval "echo original filesize: $filesize"
+ if is_linux; then
+ truncate $filename -s $((filesize - size))
+ else
+ truncate -s -$size $filename
+ fi
+ filesize=$(get_file_size $filename)
+ eval "echo new filesize after truncate: $filesize"
+}
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify the number direct/buffered requests for (un)aligned access
+#
+# STRATEGY:
+# 1. Create a multi-block file
+# 2. Perform various (un)aligned accesses and verify the result.
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ zfs set recordsize=$rs $TESTPOOL/$TESTFS
+ log_must rm -f $tmp_file
+}
+
+log_onexit cleanup
+
+log_assert "Verify the number direct/buffered requests for unaligned access"
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+
+rs=$(get_prop recordsize $TESTPOOL/$TESTFS)
+log_must zfs set recordsize=128k $TESTPOOL/$TESTFS
+
+tmp_file=$mntpnt/tmp_file
+file_size=$((rs * 8))
+
+log_must stride_dd -i /dev/urandom -o $tmp_file -b $file_size -c 1
+
+# N recordsize aligned writes which do not span blocks
+check_write $TESTPOOL $tmp_file $rs 1 0 "-D" 0 1
+check_write $TESTPOOL $tmp_file $rs 2 0 "-D" 0 2
+check_write $TESTPOOL $tmp_file $rs 4 0 "-D" 0 4
+check_write $TESTPOOL $tmp_file $rs 8 0 "-D" 0 8
+
+# 1 recordsize aligned write which spans multiple blocks at various offsets
+check_write $TESTPOOL $tmp_file $((rs * 2)) 1 0 "-D" 0 2
+check_write $TESTPOOL $tmp_file $((rs * 2)) 1 1 "-D" 0 2
+check_write $TESTPOOL $tmp_file $((rs * 2)) 1 2 "-D" 0 2
+check_write $TESTPOOL $tmp_file $((rs * 2)) 1 3 "-D" 0 2
+check_write $TESTPOOL $tmp_file $((rs * 4)) 1 0 "-D" 0 4
+check_write $TESTPOOL $tmp_file $((rs * 4)) 1 1 "-D" 0 4
+check_write $TESTPOOL $tmp_file $((rs * 8)) 1 0 "-D" 0 8
+
+# sub-blocksize unaligned writes which do not span blocks.
+check_write $TESTPOOL $tmp_file $((rs / 2)) 1 0 "-D" 1 0
+check_write $TESTPOOL $tmp_file $((rs / 2)) 1 1 "-D" 1 0
+check_write $TESTPOOL $tmp_file $((rs / 2)) 1 2 "-D" 1 0
+check_write $TESTPOOL $tmp_file $((rs / 2)) 1 3 "-D" 1 0
+
+# large unaligned writes which span multiple blocks
+check_write $TESTPOOL $tmp_file $((rs * 2)) 1 $((rs / 2)) "-D -K" 2 1
+check_write $TESTPOOL $tmp_file $((rs * 4)) 2 $((rs / 4)) "-D -K" 4 6
+
+# evict any cached blocks by overwriting with O_DIRECT
+evict_blocks $TESTPOOL $tmp_file $file_size
+
+# recordsize aligned reads which do not span blocks
+check_read $TESTPOOL $tmp_file $rs 1 0 "-d" 0 1
+check_read $TESTPOOL $tmp_file $rs 2 0 "-d" 0 2
+check_read $TESTPOOL $tmp_file $rs 4 0 "-d" 0 4
+check_read $TESTPOOL $tmp_file $rs 8 0 "-d" 0 8
+
+# 1 recordsize aligned read which spans multiple blocks at various offsets
+check_read $TESTPOOL $tmp_file $((rs * 2)) 1 0 "-d" 0 2
+check_read $TESTPOOL $tmp_file $((rs * 2)) 1 1 "-d" 0 2
+check_read $TESTPOOL $tmp_file $((rs * 2)) 1 2 "-d" 0 2
+check_read $TESTPOOL $tmp_file $((rs * 2)) 1 3 "-d" 0 2
+check_read $TESTPOOL $tmp_file $((rs * 4)) 1 0 "-d" 0 4
+check_read $TESTPOOL $tmp_file $((rs * 4)) 1 1 "-d" 0 4
+check_read $TESTPOOL $tmp_file $((rs * 8)) 1 0 "-d" 0 8
+
+# sub-blocksize unaligned reads which do not span blocks.
+check_read $TESTPOOL $tmp_file $((rs / 2)) 1 0 "-d" 0 1
+check_read $TESTPOOL $tmp_file $((rs / 2)) 1 1 "-d" 0 1
+check_read $TESTPOOL $tmp_file $((rs / 2)) 1 2 "-d" 0 1
+check_read $TESTPOOL $tmp_file $((rs / 2)) 1 3 "-d" 0 1
+
+# large unaligned reads which span multiple blocks
+check_read $TESTPOOL $tmp_file $((rs * 2)) 1 $((rs / 2)) "-d -P" 0 3
+check_read $TESTPOOL $tmp_file $((rs * 4)) 1 $((rs / 4)) "-d -P" 0 5
+
+log_pass "Verify the number direct/buffered requests for (un)aligned access"
--- /dev/null
+#!/bin/ksh -p
+#
+# DDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify small async Direct I/O requests
+#
+# STRATEGY:
+# 1. Use fio to issue small read/write requests. Writes are
+# smaller than the block size and thus will be buffered,
+# reads satisfy the minimum alignment and will be direct.
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ zfs set direct=standard $TESTPOOL/$TESTFS
+ rm $tmp_file
+}
+
+log_assert "Verify direct=always mixed small async requests"
+
+log_onexit cleanup
+
+log_must zfs set direct=always $TESTPOOL/$TESTFS
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+tmp_file=$mntpnt/tmp_file
+page_size=$(getconf PAGESIZE)
+file_size=1G
+runtime=10
+
+log_must truncate -s $file_size $tmp_file
+
+log_must fio --filename=$tmp_file --name=always-randrw \
+ --rw=randwrite --bs=$page_size --size=$file_size --numjobs=1 \
+ --ioengine=posixaio --fallocate=none --iodepth=4 --verify=sha1 \
+ --group_reporting --minimal --runtime=$runtime --time_based
+
+log_pass "Verify direct=always mixed small async requests"
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2022 by Triad National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/include/properties.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify FIO async engines work using Direct I/O.
+#
+# STRATEGY:
+# 1. Select a FIO async ioengine
+# 2. Start sequntial Direct I/O and verify with buffered I/O
+# 3. Start mixed Direct I/O and verify with buffered I/O
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ log_must rm -f "$mntpnt/direct-*"
+}
+
+function check_fio_ioengine
+{
+ fio --ioengine=io_uring --parse-only > /dev/null 2>&1
+ return $?
+}
+
+log_assert "Verify FIO async ioengines work using Direct I/O."
+
+log_onexit cleanup
+
+typeset -a async_ioengine_args=("--iodepth=4" "--iodepth=4 --thread")
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+fio_async_ioengines="posixaio"
+
+if is_linux; then
+ fio_async_ioengines+=" libaio"
+ if $(grep -q "CONFIG_IO_URING=y" /boot/config-$(uname -r)); then
+ if [ -e /etc/os-release ] ; then
+ source /etc/os-release
+ if [ $PLATFORM_ID = "platform:el9" ] ; then
+ log_note "io_uring disabled on RHEL 9 " \
+ "variants: fails with " \
+ "'Operation not permitted'"
+ elif $(check_fio_ioengine -eq 0); then
+ fio_async_ioengines+=" io_uring"
+ else
+ log_note "io_uring not supported by fio and " \
+ "will not be tested"
+ fi
+ else
+ if $(check_fio_ioengine); then
+ fio_async_ioengines+=" io_uring"
+
+ else
+ log_note "io_uring not supported by fio and " \
+ "will not be tested"
+ fi
+ fi
+ else
+ log_note "io_uring not supported by kernel will not " \
+ "be tested"
+
+ fi
+fi
+
+for ioengine in $fio_async_ioengines; do
+ for ioengine_args in "${async_ioengine_args[@]}"; do
+ for op in "rw" "randrw" "write"; do
+ log_note "Checking Direct I/O with FIO async ioengine" \
+ " $ioengine with args $ioengine_args --rw=$op"
+ dio_and_verify $op $DIO_FILESIZE $DIO_BS $mntpnt "$ioengine" \
+ "$ioengine_args"
+ done
+ done
+done
+
+log_pass "Verfied FIO async ioengines work using Direct I/O"
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/include/properties.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify compression works using Direct I/O.
+#
+# STRATEGY:
+# 1. Select a random compression algoritm
+# 2. Start sequential Direct I/O and verify with buffered I/O
+# 3. Start mixed Direct I/O and verify with buffered I/O
+# 4. Repeat from 2 for all compression algoritms
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ log_must rm -f "$mntpnt/direct-*"
+ log_must zfs set compression=off $TESTPOOL/$TESTFS
+}
+
+log_assert "Verify compression works using Direct I/O."
+
+log_onexit cleanup
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+compress_args="--buffer_compress_percentage=50"
+
+for comp in "${compress_prop_vals[@]:1}"; do
+ log_must zfs set compression=$comp $TESTPOOL/$TESTFS
+ for op in "rw" "randrw" "write"; do
+ dio_and_verify $op $DIO_FILESIZE $DIO_BS $mntpnt "sync" $compress_args
+ done
+done
+
+log_pass "Verfied compression works using Direct I/O"
--- /dev/null
+#!/bin/ksh -p
+#
+# DDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/include/properties.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify deduplication works. Deduplication is disabled when issuing
+# Direct I/O writes.
+#
+# STRATEGY:
+# 1. Enable dedup
+# 2. Start sequential Direct I/O and verify with buffered I/O
+# 3. Start mixed Direct IO and verify with buffered I/O
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ log_must rm -f "$mntpnt/direct-*"
+ log_must zfs set dedup=off $TESTPOOL/$TESTFS
+}
+
+log_assert "Verify deduplication works using Direct I/O."
+
+log_onexit cleanup
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+dedup_args="--dedupe_percentage=50"
+
+log_must zfs set dedup=on $TESTPOOL/$TESTFS
+for op in "rw" "randrw" "write"; do
+ dio_and_verify $op $DIO_FILESIZE $DIO_BS $mntpnt "sync" $dedup_args
+done
+
+log_pass "Verfied deduplication works using Direct I/O"
--- /dev/null
+#!/bin/ksh -p
+#
+# DDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify encryption works using Direct I/O.
+#
+# STRATEGY:
+# 1. Create multidisk pool.
+# 2. Start some mixed readwrite Direct I/O.
+# 3. Verify the results are as expected using buffered I/O.
+#
+
+verify_runnable "global"
+
+log_assert "Verify encryption works using Direct I/O."
+
+log_onexit dio_cleanup
+
+log_must truncate -s $MINVDEVSIZE $DIO_VDEVS
+
+create_pool $TESTPOOL1 $DIO_VDEVS
+log_must eval "echo 'password' | zfs create -o encryption=on \
+ -o keyformat=passphrase -o keylocation=prompt -o compression=off \
+ $TESTPOOL1/$TESTFS1"
+
+mntpnt=$(get_prop mountpoint $TESTPOOL1/$TESTFS1)
+
+for bs in "4k" "128k" "1m"; do
+ for op in "rw" "randrw" "write"; do
+ dio_and_verify $op $DIO_FILESIZE $bs $mntpnt "sync"
+ done
+done
+
+log_pass "Verified encryption works using Direct I/O"
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify the number direct/buffered requests when growing a file
+#
+# STRATEGY:
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ zfs set recordsize=$rs $TESTPOOL/$TESTFS
+ log_must rm -f $tmp_file
+}
+
+log_assert "Verify the number direct/buffered requests when growing a file"
+
+log_onexit cleanup
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+
+tmp_file=$mntpnt/tmp_file
+
+rs=$(get_prop recordsize $TESTPOOL/$TESTFS)
+log_must zfs set recordsize=128k $TESTPOOL/$TESTFS
+
+#
+# Verify the expected number of buffered and Direct I/O's when growing
+# the first block of a file up to the maximum recordsize.
+#
+for bs in "8192" "16384" "32768" "65536" "131072"; do
+
+ # When O_DIRECT is set the first write to a new file, or when the
+ # block size needs to be grown, it will be done as a buffered write.
+ check_write $TESTPOOL $tmp_file $bs 1 0 "-D" 1 0
+
+ # Overwriting the first block of an existing file with O_DIRECT will
+ # be a buffered write if less than the block size.
+ check_write $TESTPOOL $tmp_file 4096 1 0 "-D" 1 0
+ check_write $TESTPOOL $tmp_file 4096 1 1 "-D" 1 0
+
+ # Overwriting the first block of an existing file with O_DIRECT will
+ # be a direct write as long as the block size matches.
+ check_write $TESTPOOL $tmp_file $bs 1 0 "-D" 0 1
+
+ # Evict any blocks which may be buffered before the read tests.
+ evict_blocks $TESTPOOL $tmp_file $bs
+
+ # Reading the first block of an existing file with O_DIRECT will
+ # be a direct read for part or all of the block size.
+ check_read $TESTPOOL $tmp_file $bs 1 0 "-d" 0 1
+ check_read $TESTPOOL $tmp_file 4096 1 0 "-d" 0 1
+ check_read $TESTPOOL $tmp_file 4096 1 1 "-d" 0 1
+done
+
+log_pass "Verify the number direct/buffered requests when growing a file"
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2022 by Triad National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify max recordsizes are supported for Direct I/O.
+#
+# STRATEGY:
+# 1. Create a pool from each vdev type with varying recordsizes.
+# 2. Start sequential Direct I/O and verify with buffered I/O.
+#
+
+verify_runnable "global"
+
+log_assert "Verify max recordsizes are supported for Direct I/O."
+
+log_onexit dio_cleanup
+
+log_must truncate -s $MINVDEVSIZE $DIO_VDEVS
+
+for type in "" "mirror" "raidz" "draid"; do;
+ for recsize in "2097152" "8388608" "16777216"; do
+ create_pool $TESTPOOL1 $type $DIO_VDEVS
+ log_must eval "zfs create \
+ -o recordsize=$recsize -o compression=off \
+ $TESTPOOL1/$TESTFS1"
+
+ mntpnt=$(get_prop mountpoint $TESTPOOL1/$TESTFS1)
+
+ verify_dio_write_count $TESTPOOL1 $recsize $((4 * recsize)) \
+ $mntpnt
+
+ destroy_pool $TESTPOOL1
+ done
+done
+
+log_pass "Verified max recordsizes are supported for Direct I/O."
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/include/properties.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify mixed buffered and Direct I/O are coherent.
+#
+# STRATEGY:
+# 1. Verify interleaved buffered and Direct I/O
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ log_must rm -f $src_file $new_file $tmp_file
+}
+
+log_assert "Verify mixed buffered and Direct I/O are coherent."
+
+log_onexit cleanup
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+
+src_file=$mntpnt/src_file
+new_file=$mntpnt/new_file
+tmp_file=$mntpnt/tmp_file
+page_size=$(getconf PAGESIZE)
+file_size=1048576
+
+log_must stride_dd -i /dev/urandom -o $src_file -b $file_size -c 1
+
+#
+# Using mixed input and output block sizes verify that buffered and
+# Direct I/O can be interleaved and the result with always be coherent.
+#
+for ibs in "512" "$page_size" "131072"; do
+ for obs in "512" "$page_size" "131072"; do
+ iblocks=$(($file_size / $ibs))
+ oblocks=$(($file_size / $obs))
+ iflags=""
+ oflags=""
+
+ # Only allow Direct I/O when it is at least page sized.
+ if [[ $ibs -ge $page_size ]]; then
+ iflags="-d"
+ fi
+
+ if [[ $obs -ge $page_size ]]; then
+ oflags="-D"
+ fi
+
+ # Verify buffered write followed by a direct read.
+ log_must stride_dd -i $src_file -o $new_file -b $obs \
+ -c $oblocks
+ log_must stride_dd -i $new_file -o $tmp_file -b $ibs \
+ -c $iblocks $iflags
+ log_must cmp_md5s $new_file $tmp_file
+ log_must rm -f $new_file $tmp_file
+
+ # Verify direct write followed by a buffered read.
+ log_must stride_dd -i $src_file -o $new_file -b $obs \
+ -c $oblocks $oflags
+ log_must stride_dd -i $new_file -o $tmp_file -b $ibs \
+ -c $iblocks
+ log_must cmp_md5s $new_file $tmp_file
+ log_must rm -f $new_file $tmp_file
+
+ # Verify direct write followed by a direct read.
+ log_must stride_dd -i $src_file -o $new_file -b $obs \
+ -c $oblocks $oflags
+ log_must stride_dd -i $new_file -o $tmp_file -b $ibs \
+ -c $iblocks $iflags
+ log_must cmp_md5s $new_file $tmp_file
+ log_must rm -f $new_file $tmp_file
+ done
+done
+
+log_pass "Verify mixed buffered and Direct I/O are coherent."
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify mixed Direct I/O and mmap I/O.
+#
+# STRATEGY:
+# 1. Create an empty file.
+# 2. Start a background Direct I/O random read/write fio to the
+# file.
+# 3. Start a background mmap random read/write fio to the file.
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ zfs set recordsize=$rs $TESTPOOL/$TESTFS
+ log_must rm -f "$tmp_file"
+}
+
+log_assert "Verify mixed Direct I/O and mmap I/O"
+
+log_onexit cleanup
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+tmp_file=$mntpnt/file
+bs=$((128 * 1024))
+blocks=64
+size=$((bs * blocks))
+runtime=60
+
+rs=$(get_prop recordsize $TESTPOOL/$TESTFS)
+log_must zfs set recordsize=128k $TESTPOOL/$TESTFS
+
+log_must stride_dd -i /dev/zero -o $tmp_file -b $bs -c $blocks
+
+# Direct I/O writes
+log_must eval "fio --filename=$tmp_file --name=direct-write \
+ --rw=randwrite --size=$size --bs=$bs --direct=1 --numjobs=1 \
+ --ioengine=sync --fallocate=none --group_reporting --minimal \
+ --runtime=$runtime --time_based --norandommap &"
+
+# Direct I/O reads
+log_must eval "fio --filename=$tmp_file --name=direct-read \
+ --rw=randread --size=$size --bs=$bs --direct=1 --numjobs=1 \
+ --ioengine=sync --fallocate=none --group_reporting --minimal \
+ --runtime=$runtime --time_based --norandommap &"
+
+# mmap I/O writes
+log_must eval "fio --filename=$tmp_file --name=mmap-write \
+ --rw=randwrite --size=$size --bs=$bs --numjobs=1 \
+ --ioengine=mmap --fallocate=none --group_reporting --minimal \
+ --runtime=$runtime --time_based --norandommap &"
+
+# mmap I/O reads
+log_must eval "fio --filename=$tmp_file --name=mmap-read \
+ --rw=randread --size=$size --bs=$bs --numjobs=1 \
+ --ioengine=mmap --fallocate=none --group_reporting --minimal \
+ --runtime=$runtime --time_based --norandommap &"
+
+wait
+
+log_pass "Verfied mixed Direct I/O and mmap I/O"
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2023 by Triad National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify Direct I/O overwrite.
+#
+# STRATEGY:
+# 1. Create an empty file.
+# 2. Start a Direct I/O random write fio to the file.
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ zfs set recordsize=$rs $TESTPOOL/$TESTFS
+ log_must rm -f "$tmp_file"
+}
+
+log_assert "Verify Direct I/O overwrites"
+
+log_onexit cleanup
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+tmp_file=$mntpnt/file
+bs=$((128 * 1024))
+blocks=64
+size=$((bs * blocks))
+runtime=60
+
+rs=$(get_prop recordsize $TESTPOOL/$TESTFS)
+log_must zfs set recordsize=128k $TESTPOOL/$TESTFS
+
+log_must stride_dd -i /dev/zero -o $tmp_file -b $bs -c $blocks
+
+# Direct I/O overwrites
+log_must eval "fio --filename=$tmp_file --name=direct-write \
+ --rw=randwrite --size=$size --bs=$bs --direct=1 --numjobs=1 \
+ --ioengine=sync --fallocate=none --group_reporting --minimal \
+ --runtime=$runtime --time_based --norandommap"
+
+log_pass "Verfied Direct I/O overwrites"
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify the direct=always|disabled|standard property
+#
+# STRATEGY:
+# 1. Verify direct=always behavior
+# 2. Verify direct=disabled behavior
+# 3. Verify direct=standard behavior
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ zfs set direct=standard $TESTPOOL/$TESTFS
+ log_must rm -f $tmp_file
+}
+
+log_assert "Verify the direct=always|disabled|standard property"
+
+log_onexit cleanup
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+rs=$(get_prop recordsize $TESTPOOL/$TESTFS)
+
+tmp_file=$mntpnt/tmp_file
+page_size=$(getconf PAGESIZE)
+file_size=1048576
+count=8
+
+#
+# Check when "direct=always" any aligned IO is done as direct.
+# Note that the "-D" and "-d" flags are not set in the following calls to
+# stride_dd.
+#
+log_must zfs set direct=always $TESTPOOL/$TESTFS
+
+log_note "Aligned writes (buffered, then all direct)"
+check_write $TESTPOOL $tmp_file $rs $count 0 "" 1 $((count - 1))
+
+log_note "Aligned overwrites"
+check_write $TESTPOOL $tmp_file $rs $count 0 "" 0 $count
+
+log_note "Sub-recordsize unaligned overwrites"
+check_write $TESTPOOL $tmp_file $((rs / 2)) $((2 * count)) 0 "" $((2 * count)) 0
+
+log_note "Sub-page size aligned overwrites"
+check_write $TESTPOOL $tmp_file 512 $count 0 "" $count 0
+evict_blocks $TESTPOOL $tmp_file $file_size
+
+log_note "Aligned reads"
+check_read $TESTPOOL $tmp_file $rs $count 0 "" 0 $count
+
+log_note "Sub-recordsize unaligned reads"
+check_read $TESTPOOL $tmp_file $((rs / 2)) $((count * 2)) 0 "" 0 $((2 * count))
+
+log_note "Sub-page size aligned reads (one read then ARC hits)"
+check_read $TESTPOOL $tmp_file 512 $count 0 "" 1 0
+
+log_must rm -f $tmp_file
+
+
+#
+# Check when "direct=disabled" there are never any direct requests.
+# Note that the "-D" and "-d" flags are always set in the following calls to
+# stride_dd.
+#
+log_must zfs set direct=disabled $TESTPOOL/$TESTFS
+
+log_note "Aligned writes (all buffered with an extra for create)"
+check_write $TESTPOOL $tmp_file $rs $count 0 "-D" $count 0
+
+log_note "Aligned overwrites"
+check_write $TESTPOOL $tmp_file $rs $count 0 "-D" $count 0
+
+log_note "Aligned reads (all ARC hits)"
+check_read $TESTPOOL $tmp_file $rs $count 0 "-d" 0 0
+
+log_must rm -f $tmp_file
+
+
+#
+# Check when "direct=standard" only requested Direct I/O occur.
+#
+log_must zfs set direct=standard $TESTPOOL/$TESTFS
+
+log_note "Aligned writes/overwrites (buffered / direct)"
+check_write $TESTPOOL $tmp_file $rs $count 0 "" $count 0
+check_write $TESTPOOL $tmp_file $rs $count 0 "-D" 0 $count
+
+log_note "Aligned reads (buffered / direct)"
+evict_blocks $TESTPOOL $tmp_file $file_size
+check_read $TESTPOOL $tmp_file $rs $count 0 "" $count 0
+evict_blocks $TESTPOOL $tmp_file $file_size
+check_read $TESTPOOL $tmp_file $rs $count 0 "-d" 0 $count
+
+log_pass "Verify the direct=always|disabled|standard property"
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify mixed Direct I/O and buffered I/O. A workload of random
+# but correctly aligned direct read/writes is mixed with a
+# concurrent workload of entirely unaligned buffered read/writes.
+#
+# STRATEGY:
+# 1. Create an empty file.
+# 2. Start a background fio randomly issuing direct read/writes.
+# 3. Start a background fio randomly issuing buffered read/writes.
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ log_must rm -f "$tmp_file"
+}
+
+log_assert "Verify randomly sized mixed Direct I/O and buffered I/O"
+
+log_onexit cleanup
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+tmp_file=$mntpnt/file
+bs=$((1024 * 1024))
+blocks=32
+size=$((bs * blocks))
+runtime=10
+page_size=$(getconf PAGESIZE)
+
+log_must stride_dd -i /dev/zero -o $tmp_file -b $bs -c $blocks
+
+# Direct random read/write page-aligned IO of varying sizes with
+# occasional calls to fsync(2), mixed with...
+log_must eval "fio --filename=$tmp_file --name=direct-rwrand \
+ --rw=randrw --size=$size --offset_align=$(getconf PAGESIZE) \
+ --bsrange=$page_size-1m --direct=1 --fsync=32 --numjobs=2 \
+ --ioengine=sync --fallocate=none --verify=sha1 \
+ --group_reporting --minimal --runtime=$runtime --time_based &"
+
+# Buffered random read/write entirely unaligned IO of varying sizes
+# occasional calls to fsync(2).
+log_must eval "fio --filename=$tmp_file --name=buffered-write \
+ --rw=randrw --size=$size --offset_align=512 --bs_unaligned=1 \
+ --bsrange=$page_size-1m --direct=0 --fsync=32 --numjobs=2 \
+ --ioengine=sync --fallocate=none --verify=sha1 \
+ --group_reporting --minimal --runtime=$runtime --time_based &"
+
+wait
+
+log_pass "Verfied randomly sized mixed Direct I/O and buffered I/O"
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify different recordsizes are supported for Direct I/O.
+#
+# STRATEGY:
+# 1. Create a pool from each vdev type with varying recordsizes.
+# 2. Start sequential Direct I/O and verify with buffered I/O.
+# 3. Start mixed Direct I/O and verify with buffered I/O.
+#
+
+verify_runnable "global"
+
+log_assert "Verify different recordsizes are supported for Direct I/O."
+
+log_onexit dio_cleanup
+
+log_must truncate -s $MINVDEVSIZE $DIO_VDEVS
+
+for type in "" "mirror" "raidz" "draid"; do
+ for recsize in "1024" "4096" "128k"; do
+ create_pool $TESTPOOL1 $type $DIO_VDEVS
+ log_must eval "zfs create \
+ -o recordsize=$recsize -o compression=off \
+ $TESTPOOL1/$TESTFS1"
+
+ mntpnt=$(get_prop mountpoint $TESTPOOL1/$TESTFS1)
+
+ for bs in "4k" "128k"; do
+ for op in "rw" "randrw" "write"; do
+ dio_and_verify $op $DIO_FILESIZE $bs $mntpnt "sync"
+ done
+ done
+
+ destroy_pool $TESTPOOL1
+ done
+done
+
+log_pass "Verified different recordsizes are supported for Direct I/O."
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify failure for (un)aligned O_DIRECT
+#
+# STRATEGY:
+# 1. Create a multi-block file
+# 2. Perform (un)aligned write/read verify the result.
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ zfs set recordsize=$rs $TESTPOOL/$TESTFS
+ zfs set direct=standard $TESTPOOL/$TESTFS
+ log_must rm -f $tmp_file
+}
+
+log_onexit cleanup
+
+log_assert "Verify direct requests for (un)aligned access"
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+
+rs=$(get_prop recordsize $TESTPOOL/$TESTFS)
+log_must zfs set recordsize=128k $TESTPOOL/$TESTFS
+
+tmp_file=$mntpnt/tmp_file
+file_size=$((rs * 8))
+
+log_must stride_dd -i /dev/urandom -o $tmp_file -b $file_size -c 1
+
+log_must zfs set direct=standard $TESTPOOL/$TESTFS
+# sub-pagesize direct writes/read will always fail if direct=standard.
+log_mustnot stride_dd -i /dev/urandom -o $tmp_file -b 512 -c 8 -D
+log_mustnot stride_dd -i $tmp_file -o /dev/null -b 512 -c 8 -d
+
+log_must zfs set direct=always $TESTPOOL/$TESTFS
+# sub-pagesize direct writes/read will always pass if direct=always.
+log_must stride_dd -i /dev/urandom -o $tmp_file -b 512 -c 8
+log_must stride_dd -i $tmp_file -o /dev/null -b 512 -c 8
+
+log_must zfs set direct=disabled $TESTPOOL/$TESTFS
+# sub-pagesize direct writes/read will always pass if direct=disabled.
+log_must stride_dd -i /dev/urandom -o $tmp_file -b 512 -c 8 -D
+log_must stride_dd -i $tmp_file -o /dev/null -b 512 -c 8 -d
+
+log_pass "Verify direct requests for (un)aligned access"
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2022 by Triad National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify Direct I/O reads can read an entire file that is not
+# page-aligned in length. When a file is not page-aligned in total
+# length, as much that can be read using using O_DIRECT is done so and
+# the rest is read using the ARC. O_DIRECT requires page-size alignment.
+#
+# STRATEGY:
+# 1. Write a file that is page-aligned (buffered)
+# 2. Truncate the file to be 512 bytes less
+# 3. Export then import the Zpool flushing out the ARC
+# 4. Read back the file using O_DIRECT
+# 5. Verify the file is read back with both Direct I/O and buffered I/O
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ log_must rm -f "$filename"
+ log_must set recordsize=$rs $TESTPOOL/$TESTFS
+}
+
+log_assert "Verify Direct I/O reads can read an entire file that is not \
+ page-aligned"
+
+log_onexit cleanup
+
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+
+rs=$(get_prop recordsize $TESTPOOL/$TESTFS)
+log_must zfs set recordsize=128k $TESTPOOL/$TESTFS
+
+bs=$((128 * 1024)) # bs=recordsize (128k)
+filename="$mntpnt/testfile.iso"
+
+log_must stride_dd -i /dev/urandom -o $filename -b $bs -c 2
+# Truncating file so the total length is no longer page-size aligned
+log_must do_truncate_reduce $filename 512
+
+# Exporting the Zpool to make sure all future reads happen from the ARC
+log_must zpool export $TESTPOOL
+log_must zpool import $TESTPOOL
+
+# Reading the file back using Direct I/O
+prev_dio_read=$(get_iostats_stat $TESTPOOL direct_read_count)
+prev_arc_read=$(get_iostats_stat $TESTPOOL arc_read_count)
+log_must stride_dd -i $filename -o /dev/null -b $bs -e -d
+curr_dio_read=$(get_iostats_stat $TESTPOOL direct_read_count)
+curr_arc_read=$(get_iostats_stat $TESTPOOL arc_read_count)
+total_dio_read=$((curr_dio_read - prev_dio_read))
+total_arc_read=$((curr_arc_read - prev_arc_read))
+
+# We should see both Direct I/O reads an ARC read to read the entire file that
+# is not page-size aligned
+if [[ $total_dio_read -lt 2 ]] || [[ $total_arc_read -lt 1 ]]; then
+ log_fail "Expect 2 reads from Direct I/O and 1 from the ARC but \
+ Direct I/O: $total_dio_read ARC: $total_arc_read"
+fi
+
+log_pass "Verified Direct I/O read can read a none page-aligned length file"
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2022 by Triad National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify stable pages work for O_DIRECT writes.
+#
+# STRATEGY:
+# 1. Start a Direct I/O write workload while manipulating the user
+# buffer.
+# 2. Verify we can Read the contents of the file using buffered reads.
+# 3. Verify there is no checksum errors reported from zpool status.
+# 4. Repeat steps 1 and 2 for 3 iterations.
+# 5. Repeat 1-3 but with compression disabled.
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ log_must rm -f "$mntpnt/direct-write.iso"
+ check_dio_write_chksum_verify_failures $TESTPOOL "raidz" 0
+}
+
+log_assert "Verify stable pages work for Direct I/O writes."
+
+if is_linux; then
+ log_unsupported "Linux does not support stable pages for O_DIRECT \
+ writes"
+fi
+
+log_onexit cleanup
+
+ITERATIONS=3
+NUMBLOCKS=300
+BS=$((128 * 1024)) #128k
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+log_must zfs set recordsize=128k $TESTPOOL/$TESTFS
+
+for compress in "on" "off";
+do
+ log_must zfs set compression=$compress $TESTPOOL/$TESTFS
+
+ for i in $(seq 1 $ITERATIONS); do
+ log_note "Verifying stable pages for Direct I/O writes \
+ iteration $i of $ITERATIONS"
+
+ prev_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
+
+ # Manipulate the user's buffer while running O_DIRECT write
+ # workload with the buffer.
+ log_must manipulate_user_buffer -o "$mntpnt/direct-write.iso" \
+ -n $NUMBLOCKS -b $BS
+
+ # Reading back the contents of the file
+ log_must stride_dd -i $mntpnt/direct-write.iso -o /dev/null \
+ -b $BS -c $NUMBLOCKS
+
+ curr_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
+ total_dio_wr=$((curr_dio_wr - prev_dio_wr))
+
+ log_note "Making sure we have Direct I/O writes logged"
+ if [[ $total_dio_wr -lt 1 ]]; then
+ log_fail "No Direct I/O writes $total_dio_wr"
+ fi
+
+ # Making sure there are no data errors for the zpool
+ log_note "Making sure there are no checksum errors with the ZPool"
+ log_must check_pool_status $TESTPOOL "errors" \
+ "No known data errors"
+
+ log_must rm -f "$mntpnt/direct-write.iso"
+ done
+done
+
+log_pass "Verified stable pages work for Direct I/O writes."
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2022 by Triad National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+. $STF_SUITE/tests/functional/direct/dio.cfg
+. $STF_SUITE/tests/functional/direct/dio.kshlib
+
+#
+# DESCRIPTION:
+# Verify checksum verify works for Direct I/O writes.
+#
+# STRATEGY:
+# 1. Set the module parameter zfs_vdev_direct_write_verify to 0.
+# 2. Check that manipulating the user buffer while Direct I/O writes are
+# taking place does not cause any panics with compression turned on.
+# 3. Start a Direct I/O write workload while manipulating the user buffer
+# without compression.
+# 4. Verify there are Direct I/O write verify failures using
+# zpool status -d and checking for zevents. We also make sure there
+# are reported data errors when reading the file back.
+# 5. Repeat steps 3 and 4 for 3 iterations.
+# 6. Set zfs_vdev_direct_write_verify set to 1 and repeat 3.
+# 7. Verify there are Direct I/O write verify failures using
+# zpool status -d and checking for zevents. We also make sure there
+# there are no reported data errors when reading the file back because
+# with us checking every Direct I/O write and on checksum validation
+# failure those writes will not be committed to a VDEV.
+#
+
+verify_runnable "global"
+
+function cleanup
+{
+ # Clearing out DIO counts for Zpool
+ log_must zpool clear $TESTPOOL
+ # Clearing out dio_verify from event logs
+ log_must zpool events -c
+ log_must set_tunable32 VDEV_DIRECT_WR_VERIFY $DIO_WR_VERIFY_TUNABLE
+}
+
+log_assert "Verify checksum verify works for Direct I/O writes."
+
+if is_freebsd; then
+ log_unsupported "FreeBSD is capable of stable pages for O_DIRECT writes"
+fi
+
+log_onexit cleanup
+
+ITERATIONS=3
+NUMBLOCKS=300
+BS=$((128 * 1024)) # 128k
+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
+typeset DIO_WR_VERIFY_TUNABLE=$(get_tunable VDEV_DIRECT_WR_VERIFY)
+
+# Get a list of vdevs in our pool
+set -A array $(get_disklist_fullpath $TESTPOOL)
+
+# Get the first vdev
+firstvdev=${array[0]}
+
+log_must zfs set recordsize=128k $TESTPOOL/$TESTFS
+log_must set_tunable32 VDEV_DIRECT_WR_VERIFY 0
+
+# First we will verify there are no panics while manipulating the contents of
+# the user buffer during Direct I/O writes with compression. The contents
+# will always be copied out of the ABD and there should never be any ABD ASSERT
+# failures
+log_note "Verifying no panics for Direct I/O writes with compression"
+log_must zfs set compression=on $TESTPOOL/$TESTFS
+prev_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
+log_must manipulate_user_buffer -o "$mntpnt/direct-write.iso" -n $NUMBLOCKS \
+ -b $BS
+curr_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
+total_dio_wr=$((curr_dio_wr - prev_dio_wr))
+
+log_note "Making sure we have Direct I/O writes logged"
+if [[ $total_dio_wr -lt 1 ]]; then
+ log_fail "No Direct I/O writes $total_dio_wr"
+fi
+
+# Clearing out DIO counts for Zpool
+log_must zpool clear $TESTPOOL
+# Clearing out dio_verify from event logs
+log_must zpool events -c
+log_must rm -f "$mntpnt/direct-write.iso"
+
+# Next we will verify there are checksum errors for Direct I/O writes while
+# manipulating the contents of the user pages.
+log_must zfs set compression=off $TESTPOOL/$TESTFS
+
+for i in $(seq 1 $ITERATIONS); do
+ log_note "Verifying Direct I/O write checksums iteration \
+ $i of $ITERATIONS with zfs_vdev_direct_write_verify=0"
+
+ prev_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
+ log_must manipulate_user_buffer -o "$mntpnt/direct-write.iso" \
+ -n $NUMBLOCKS -b $BS
+
+ # Reading file back to verify checksum errors
+ filesize=$(get_file_size "$mntpnt/direct-write.iso")
+ num_blocks=$((filesize / BS))
+ log_mustnot stride_dd -i "$mntpnt/direct-write.iso" -o /dev/null -b $BS \
+ -c $num_blocks
+
+ # Getting new Direct I/O and ARC write counts.
+ curr_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
+ total_dio_wr=$((curr_dio_wr - prev_dio_wr))
+
+ # Verifying there are checksum errors
+ log_note "Making sure there are checksum errors for the ZPool"
+ cksum=$(zpool status -P -v $TESTPOOL | awk -v v="$firstvdev" '$0 ~ v \
+ {print $5}')
+ if [[ $cksum -eq 0 ]]; then
+ zpool status -P -v $TESTPOOL
+ log_fail "No checksum failures for ZPool $TESTPOOL"
+ fi
+
+ log_note "Making sure we have Direct I/O writes logged"
+ if [[ $total_dio_wr -lt 1 ]]; then
+ log_fail "No Direct I/O writes $total_dio_wr"
+ fi
+ log_note "Making sure we have no Direct I/O write checksum verifies \
+ with ZPool"
+ check_dio_write_chksum_verify_failures $TESTPOOL "raidz" 0
+
+ log_must rm -f "$mntpnt/direct-write.iso"
+done
+
+log_must zpool status -v $TESTPOOL
+log_must zpool sync $TESTPOOL
+
+
+
+# Finally we will verfiy that with checking every Direct I/O write we have no
+# errors at all.
+# Create the file before trying to manipulate the contents
+log_must file_write -o create -f "$mntpnt/direct-write.iso" -b $BS \
+ -c $NUMBLOCKS -w
+log_must set_tunable32 VDEV_DIRECT_WR_VERIFY 1
+
+for i in $(seq 1 $ITERATIONS); do
+ log_note "Verifying every Direct I/O write checksums iteration $i of \
+ $ITERATIONS with zfs_vdev_direct_write_verify=1"
+
+ prev_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
+ log_must manipulate_user_buffer -o "$mntpnt/direct-write.iso" \
+ -n $NUMBLOCKS -b $BS -e
+
+ # Reading file back to verify there no are checksum errors
+ filesize=$(get_file_size "$mntpnt/direct-write.iso")
+ num_blocks=$((filesize / BS))
+ log_must stride_dd -i "$mntpnt/direct-write.iso" -o /dev/null -b $BS \
+ -c $num_blocks
+
+ # Getting new Direct I/O and ARC Write counts.
+ curr_dio_wr=$(get_iostats_stat $TESTPOOL direct_write_count)
+ total_dio_wr=$((curr_dio_wr - prev_dio_wr))
+
+ log_note "Making sure there are no checksum errors with the ZPool"
+ log_must check_pool_status $TESTPOOL "errors" "No known data errors"
+
+ log_note "Making sure we have Direct I/O writes logged"
+ if [[ $total_dio_wr -lt 1 ]]; then
+ log_fail "No Direct I/O writes $total_dio_wr"
+ fi
+
+ log_note "Making sure we have Direct I/O write checksum verifies with ZPool"
+ check_dio_write_chksum_verify_failures "$TESTPOOL" "raidz" 1
+done
+
+log_must rm -f "$mntpnt/direct-write.iso"
+
+log_pass "Verified checksum verify works for Direct I/O writes."
--- /dev/null
+#!/bin/ksh -p
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or https://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
+#
+
+. $STF_SUITE/include/libtest.shlib
+verify_runnable "global"
+
+if tunable_exists DIO_ENABLED ; then
+ log_must save_tunable DIO_ENABLED
+ log_must set_tunable32 DIO_ENABLED 1
+fi
+
+default_raidz_setup_noexit "$DISKS"
+log_must zfs set compression=off $TESTPOOL/$TESTFS
+log_pass
. $STF_SUITE/include/libtest.shlib
verify_runnable "global"
-default_setup "$DISKS"
+default_raidz_setup "$DISKS"
log_must zfs set compression=on $TESTPOOL/$TESTFS
export PERF_COMPCHUNK=0
export BLOCKSIZE=128K
export SYNC_TYPE=0
-export DIRECT=1
+export DIRECT=0
fi
}
-function cmp_md5s {
- typeset file1=$1
- typeset file2=$2
-
- [ "$(md5digest $file1)" = "$(md5digest $file2)" ]
-}
-
#
# Detect if the given two filesystems have same sub-datasets
#
log_must dd if=/dev/zero of=/$TESTPOOL/$TESTFS/sync \
conv=fdatasync,fsync bs=1 count=1
+#
+# Create a small file for the O_DIRECT test before freezing the pool. This
+# allows us to overwrite it after the pool is frozen and avoid the case
+# where O_DIRECT is disabled because the first block must be grown.
+#
+log_must dd if=/dev/urandom of=/$TESTPOOL/$TESTFS/direct \
+ oflag=sync,direct bs=4k count=1
+
#
# 2. Freeze TESTFS
#
log_must dd if=/dev/urandom of=/$TESTPOOL/$TESTFS/large \
oflag=sync bs=128k count=64
+# TX_WRITE (O_DIRECT)
+log_must dd if=/dev/urandom of=/$TESTPOOL/$TESTFS/direct \
+ oflag=sync,direct bs=4k count=1
+
# Write zeros, which compress to holes, in the middle of a file
log_must dd if=/dev/urandom of=/$TESTPOOL/$TESTFS/holes.1 \
oflag=sync bs=128k count=8
export RUNTIME=30
export BLOCKSIZE=128K
export SYNC_TYPE=0
-export DIRECT=1
+export DIRECT=0
# Write to the pool.
log_must fio $FIO_SCRIPTS/mkfiles.fio
projects / mirror_zfs.git / commitdiff