Adding Direct IO Support

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 <[email protected]>
Reviewed-by: Alexander Motin <[email protected]>
Reviewed-by: Tony Hutter <[email protected]>
Signed-off-by: Brian Atkinson <[email protected]>
Co-authored-by: Mark Maybee <[email protected]>
Co-authored-by: Matt Macy <[email protected]>
Co-authored-by: Brian Behlendorf <[email protected]>
Closes #10018 

4 files changed, 458 insertions, 54 deletions

diff --git a/tests/zfs-tests/cmd/.gitignore b/tests/zfs-tests/cmd/.gitignore
index 0ed0a69eb..e9e3b8f73 100644
--- a/tests/zfs-tests/cmd/.gitignore
+++ b/tests/zfs-tests/cmd/.gitignore
@@ -16,6 +16,7 @@
 /getversion
 /largest_file
 /libzfs_input_check
+/manipulate_user_buffer
 /mkbusy
 /mkfile
 /mkfiles
diff --git a/tests/zfs-tests/cmd/Makefile.am b/tests/zfs-tests/cmd/Makefile.am
index a8df06c2e..5250e72f9 100644
--- a/tests/zfs-tests/cmd/Makefile.am
+++ b/tests/zfs-tests/cmd/Makefile.am
@@ -60,6 +60,8 @@ scripts_zfs_tests_bin_PROGRAMS += %D%/libzfs_input_check
 	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)
diff --git a/tests/zfs-tests/cmd/manipulate_user_buffer.c b/tests/zfs-tests/cmd/manipulate_user_buffer.c
new file mode 100644
index 000000000..714f42200
--- /dev/null
+++ b/tests/zfs-tests/cmd/manipulate_user_buffer.c
@@ -0,0 +1,272 @@
+/*
+ * 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);
+}
diff --git a/tests/zfs-tests/cmd/stride_dd.c b/tests/zfs-tests/cmd/stride_dd.c
index a20b26131..e1e45794c 100644
--- a/tests/zfs-tests/cmd/stride_dd.c
+++ b/tests/zfs-tests/cmd/stride_dd.c
@@ -21,12 +21,19 @@
 #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);
@@ -36,8 +43,10 @@ static 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"
@@ -45,16 +54,47 @@ usage(void)
 	    "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[])
 {
@@ -62,12 +102,17 @@ 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;
@@ -76,6 +121,18 @@ parse_options(int argc, char *argv[])
 				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;
@@ -92,6 +149,18 @@ parse_options(int argc, char *argv[])
 				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);
@@ -111,65 +180,60 @@ parse_options(int argc, char *argv[])
 		}
 	}
 
-	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");
 			} else {
@@ -205,6 +269,71 @@ main(int argc, char *argv[])
 			}
 		}
 	}
+}
+
+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);