Kill of IO engine cancelation support

This was more of a thought experiment back in the day, but even for
an old interface like libaio on Linux, it does not support canceling
IOs at all. Neither does posixaio. And while cancel support could
get plumbed up to io_uring, since Linux doesn't support canceling
normal IO, then it will never do anything.

Hence it's utterly pointless to have a cancel ops in the IO engine,
and the backend attempts at first reaping done IO and then canceling
the rest is also then pointless.

Just replace the at-exit cancelation with waiting on pending IO.

Signed-off-by: Jens Axboe <[email protected]>

Author: axboe

backend.c

@@ -222,39 +222,6 @@ static bool check_min_rate(struct thread_data *td, struct timespec *now)
 	return ret;
 }
 
-/*
- * When job exits, we can cancel the in-flight IO if we are using async
- * io. Attempt to do so.
- */
-static void cleanup_pending_aio(struct thread_data *td)
-{
-	int r;
-
-	/*
-	 * get immediately available events, if any
-	 */
-	r = io_u_queued_complete(td, 0);
-
-	/*
-	 * now cancel remaining active events
-	 */
-	if (td->io_ops->cancel) {
-		struct io_u *io_u;
-		int i;
-
-		io_u_qiter(&td->io_u_all, io_u, i) {
-			if (io_u->flags & IO_U_F_FLIGHT) {
-				r = td->io_ops->cancel(td, io_u);
-				if (!r)
-					put_io_u(td, io_u);
-			}
-		}
-	}
-
-	if (td->cur_depth)
-		r = io_u_queued_complete(td, td->cur_depth);
-}
-
 /*
  * Helper to handle the final sync of a file. Works just like the normal
  * io path, just does everything sync.
@@ -614,8 +581,8 @@ static void do_verify(struct thread_data *td, uint64_t verify_bytes)
 {
 	struct fio_file *f;
 	struct io_u *io_u;
-	int ret, min_events;
 	unsigned int i;
+	int ret;
 
 	dprint(FD_VERIFY, "starting loop\n");
 
@@ -751,13 +718,8 @@ static void do_verify(struct thread_data *td, uint64_t verify_bytes)
 
 	check_update_rusage(td);
 
-	if (!td->error) {
-		min_events = td->cur_depth;
-
-		if (min_events)
-			ret = io_u_queued_complete(td, min_events);
-	} else
-		cleanup_pending_aio(td);
+	if (td->cur_depth)
+		ret = io_u_queued_complete(td, td->cur_depth);
 
 	td_set_runstate(td, TD_RUNNING);
 
@@ -1313,7 +1275,7 @@ static void do_io(struct thread_data *td, uint64_t *bytes_done)
 	} else {
 		if (td->o.io_submit_mode == IO_MODE_OFFLOAD)
 			workqueue_flush(&td->io_wq);
-		cleanup_pending_aio(td);
+		ret = io_u_queued_complete(td, td->cur_depth);
 	}
 
 	/*

engines/libaio.c

@@ -389,13 +389,6 @@ static int fio_libaio_commit(struct thread_data *td)
 	return ret;
 }
 
-static int fio_libaio_cancel(struct thread_data *td, struct io_u *io_u)
-{
-	struct libaio_data *ld = td->io_ops_data;
-
-	return io_cancel(ld->aio_ctx, &io_u->iocb, ld->aio_events);
-}
-
 static void fio_libaio_cleanup(struct thread_data *td)
 {
 	struct libaio_data *ld = td->io_ops_data;
@@ -470,7 +463,6 @@ FIO_STATIC struct ioengine_ops ioengine = {
 	.prep			= fio_libaio_prep,
 	.queue			= fio_libaio_queue,
 	.commit			= fio_libaio_commit,
-	.cancel			= fio_libaio_cancel,
 	.getevents		= fio_libaio_getevents,
 	.event			= fio_libaio_event,
 	.cleanup		= fio_libaio_cleanup,

engines/posixaio.c

@@ -27,18 +27,6 @@ static unsigned long long ts_utime_since_now(const struct timespec *start)
 	return utime_since(start, &now);
 }
 
-static int fio_posixaio_cancel(struct thread_data fio_unused *td,
-			       struct io_u *io_u)
-{
-	struct fio_file *f = io_u->file;
-	int r = aio_cancel(f->fd, &io_u->aiocb);
-
-	if (r == AIO_ALLDONE || r == AIO_CANCELED)
-		return 0;
-
-	return 1;
-}
-
 static int fio_posixaio_prep(struct thread_data fio_unused *td,
 			     struct io_u *io_u)
 {
@@ -212,7 +200,6 @@ static struct ioengine_ops ioengine = {
 	.init		= fio_posixaio_init,
 	.prep		= fio_posixaio_prep,
 	.queue		= fio_posixaio_queue,
-	.cancel		= fio_posixaio_cancel,
 	.getevents	= fio_posixaio_getevents,
 	.event		= fio_posixaio_event,
 	.cleanup	= fio_posixaio_cleanup,

engines/skeleton_external.c

@@ -71,15 +71,6 @@ static int fio_skeleton_getevents(struct thread_data *td, unsigned int min,
 	return 0;
 }
 
-/*
- * The ->cancel() hook attempts to cancel the io_u. Only relevant for
- * async io engines, and need not be supported.
- */
-static int fio_skeleton_cancel(struct thread_data *td, struct io_u *io_u)
-{
-	return 0;
-}
-
 /*
  * The ->queue() hook is responsible for initiating io on the io_u
  * being passed in. If the io engine is a synchronous one, io may complete
@@ -214,7 +205,6 @@ struct ioengine_ops ioengine = {
 	.init		= fio_skeleton_init,
 	.prep		= fio_skeleton_prep,
 	.queue		= fio_skeleton_queue,
-	.cancel		= fio_skeleton_cancel,
 	.getevents	= fio_skeleton_getevents,
 	.event		= fio_skeleton_event,
 	.cleanup	= fio_skeleton_cleanup,

engines/solarisaio.c

@@ -19,12 +19,6 @@ struct solarisaio_data {
 	unsigned int max_depth;
 };
 
-static int fio_solarisaio_cancel(struct thread_data fio_unused *td,
-			       struct io_u *io_u)
-{
-	return aiocancel(&io_u->resultp);
-}
-
 static int fio_solarisaio_prep(struct thread_data fio_unused *td,
 			    struct io_u *io_u)
 {
@@ -213,7 +207,6 @@ static struct ioengine_ops ioengine = {
 	.init		= fio_solarisaio_init,
 	.prep		= fio_solarisaio_prep,
 	.queue		= fio_solarisaio_queue,
-	.cancel		= fio_solarisaio_cancel,
 	.getevents	= fio_solarisaio_getevents,
 	.event		= fio_solarisaio_event,
 	.cleanup	= fio_solarisaio_cleanup,

ioengines.h

@@ -9,7 +9,7 @@
 #include "zbd_types.h"
 #include "dataplacement.h"
 
-#define FIO_IOOPS_VERSION	38
+#define FIO_IOOPS_VERSION	39
 
 #ifndef CONFIG_DYNAMIC_ENGINES
 #define FIO_STATIC	static
@@ -41,7 +41,6 @@ struct ioengine_ops {
 	int (*getevents)(struct thread_data *, unsigned int, unsigned int, const struct timespec *);
 	struct io_u *(*event)(struct thread_data *, int);
 	char *(*errdetails)(struct thread_data *, struct io_u *);
-	int (*cancel)(struct thread_data *, struct io_u *);
 	void (*cleanup)(struct thread_data *);
 	int (*open_file)(struct thread_data *, struct fio_file *);
 	int (*close_file)(struct thread_data *, struct fio_file *);