Recent changes (master)

[Jens Axboe <axboe@kernel.dk>]

The following changes since commit e55138eed3296b642229271b0dcec492ec776702:

  Merge branch 'evelu-enghelp' of https://github.com/ErwanAliasr1/fio into master (2020-09-09 10:48:27 -0600)

are available in the Git repository at:

  git://git.kernel.dk/fio.git master

for you to fetch changes up to 695611a9d4cd554d44d8b2ec5da2811061950a2e:

  Allow offload with FAKEIO engines (2020-09-11 09:58:15 -0600)

----------------------------------------------------------------
Jens Axboe (3):
      engines/io_uring: mark as not compatible with io_submit_mode=offload
      Disable io_submit_mode=offload with async engines
      Allow offload with FAKEIO engines

 HOWTO              |  3 ++-
 engines/io_uring.c |  6 ++++++
 fio.1              |  2 +-
 ioengines.c        | 14 ++++++++++++--
 4 files changed, 21 insertions(+), 4 deletions(-)

---

Diff of recent changes:

diff --git a/HOWTO b/HOWTO
index d8586723..2d8c7a02 100644
--- a/HOWTO
+++ b/HOWTO
@@ -2474,7 +2474,8 @@ I/O depth
 	can increase latencies. The benefit is that fio can manage submission rates
 	independently of the device completion rates. This avoids skewed latency
 	reporting if I/O gets backed up on the device side (the coordinated omission
-	problem).
+	problem). Note that this option cannot reliably be used with async IO
+	engines.
 
 
 I/O rate
diff --git a/engines/io_uring.c b/engines/io_uring.c
index e2b5e6ee..69f48859 100644
--- a/engines/io_uring.c
+++ b/engines/io_uring.c
@@ -724,6 +724,12 @@ static int fio_ioring_init(struct thread_data *td)
 	struct ioring_data *ld;
 	struct thread_options *to = &td->o;
 
+	if (to->io_submit_mode == IO_MODE_OFFLOAD) {
+		log_err("fio: io_submit_mode=offload is not compatible (or "
+			"useful) with io_uring\n");
+		return 1;
+	}
+
 	/* sqthread submission requires registered files */
 	if (o->sqpoll_thread)
 		o->registerfiles = 1;
diff --git a/fio.1 b/fio.1
index 74509bbd..a881277c 100644
--- a/fio.1
+++ b/fio.1
@@ -2215,7 +2215,7 @@ has a bit of extra overhead, especially for lower queue depth I/O where it
 can increase latencies. The benefit is that fio can manage submission rates
 independently of the device completion rates. This avoids skewed latency
 reporting if I/O gets backed up on the device side (the coordinated omission
-problem).
+problem). Note that this option cannot reliably be used with async IO engines.
 .SS "I/O rate"
 .TP
 .BI thinktime \fR=\fPtime
diff --git a/ioengines.c b/ioengines.c
index 476df58d..d3be8026 100644
--- a/ioengines.c
+++ b/ioengines.c
@@ -22,7 +22,7 @@
 
 static FLIST_HEAD(engine_list);
 
-static bool check_engine_ops(struct ioengine_ops *ops)
+static bool check_engine_ops(struct thread_data *td, struct ioengine_ops *ops)
 {
 	if (ops->version != FIO_IOOPS_VERSION) {
 		log_err("bad ioops version %d (want %d)\n", ops->version,
@@ -41,6 +41,16 @@ static bool check_engine_ops(struct ioengine_ops *ops)
 	if (ops->flags & FIO_SYNCIO)
 		return false;
 
+	/*
+	 * async engines aren't reliable with offload
+	 */
+	if ((td->o.io_submit_mode == IO_MODE_OFFLOAD) &&
+	    !(ops->flags & FIO_FAKEIO)) {
+		log_err("%s: can't be used with offloaded submit. Use a sync "
+			"engine\n", ops->name);
+		return true;
+	}
+
 	if (!ops->event || !ops->getevents) {
 		log_err("%s: no event/getevents handler\n", ops->name);
 		return true;
@@ -193,7 +203,7 @@ struct ioengine_ops *load_ioengine(struct thread_data *td)
 	/*
 	 * Check that the required methods are there.
 	 */
-	if (check_engine_ops(ops))
+	if (check_engine_ops(td, ops))
 		return NULL;
 
 	return ops;