Skip to contentSkip to conversation

aio_cancel_5-1: Rewrite test

PATCH In review Martin Doucha 3 participants 4 messages Jan 13 – Jan 14 1 message not in the archive

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 aio_cancel_5-1: Rewrite test

The test schedules multiple async writes into a file and then hopes that at least one will block long enough that aio_cancel() will fail to cancel it. Use a socket pair instead of a file to force async writes to block indefinitely. Then wait for one of the writes to actually block on full socket buffer. This fixes a race condition where aio_cancel() could be called while no write is actually in progress (before the first write, after the last one or between two writes) and the test would fail.

Also rewrite result checks to verify that all writes before the blocked one actually completed and all writes after the blocked one were cancelled.

Add cleanup helper function that will flush socket buffers, free allocated memory and close the sockets. Also make setup and cleanup simpler by statically allocating the aiocb structure array.

---

Race condition fix using the same socket approach as the earlier rewrite of aio_cancel_7-1. Tested on kernel v4.4 and v6.12.

 .../conformance/interfaces/aio_cancel/5-1.c   | 185 +++++++++++-------
 1 file changed, 119 insertions(+), 66 deletions(-)
testcases/open_posix_testsuite/conformance/interfaces/aio_cancel/5-1.c +119 -66
index 5ed4f6d42..559625b13 100644
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2004, Bull SA. All rights reserved.
+ * Copyright (c) 2025 SUSE LLC
  * Created by:  [email protected]
  * This file is licensed under the GPL license.  For the full content
  * of this license, see the COPYING file at the top level of this
@@ -13,7 +14,7 @@
  *
  * method:
  *
- *	queue a some aio_write() to a file descriptor
+ *	queue some aio_write() to a file descriptor
  *	cancel all operations for this file descriptor
  *	for all operations not canceled at end of operations
  *	verify that values in aiocb is the good ones
@@ -28,117 +29,169 @@
 #include <sys/types.h>
 #include <unistd.h>
 #include <sys/stat.h>
-#include <fcntl.h>
 #include <string.h>
 #include <errno.h>
 #include <stdlib.h>
+#include <time.h>
 #include <aio.h>
+#include <sys/socket.h>
 
 #include "posixtest.h"
-#include "tempfile.h"
 
 #define TNAME "aio_cancel/5-1.c"
 
-#define BUF_NB		128
-#define BUF_SIZE	1024
+#define BUF_NB		8
+#define BLOCKED_TASK	2
+
+static int fds[2];
+static struct aiocb aiocb[BUF_NB];
+
+static void cleanup(void)
+{
+	int i, ret;
+
+	for (i = 0; i < BUF_NB; i++) {
+		if (!aiocb[i].aio_buf)
+			break;
+
+		ret = aio_error(&aiocb[i]);
+
+		/* flush written data from the socket */
+		if (ret == 0 || ret == EINPROGRESS) {
+			read(fds[1], (void *)aiocb[i].aio_buf,
+				aiocb[i].aio_nbytes);
+		}
+
+		free((void *)aiocb[i].aio_buf);
+	}
+
+	close(fds[0]);
+	close(fds[1]);
+}
 
 int main(void)
 {
-	char tmpfname[PATH_MAX];
-	int fd;
-	struct aiocb *aiocb[BUF_NB];
 	char *buf[BUF_NB];
 	int i;
-	int in_progress;
-	static int check_one;
+	int ret;
+	int bufsize;
+	int exp_ret;
+	socklen_t argsize = sizeof(bufsize);
+	const struct timespec sleep_ts = { .tv_sec = 0, .tv_nsec = 10000000 };
 
 	if (sysconf(_SC_ASYNCHRONOUS_IO) < 200112L)
 		return PTS_UNSUPPORTED;
 
-	PTS_GET_TMP_FILENAME(tmpfname, "pts_aio_cancel_5_1");
-	unlink(tmpfname);
-	fd = open(tmpfname, O_CREAT | O_RDWR | O_EXCL, S_IRUSR | S_IWUSR);
-	if (fd == -1) {
-		printf(TNAME " Error at open(): %s\n", strerror(errno));
+	ret = socketpair(AF_UNIX, SOCK_DGRAM, 0, fds);
+	if (ret == -1) {
+		printf(TNAME " Error creating sockets(): %s\n",
+			strerror(errno));
+		return PTS_UNRESOLVED;
+	}
+
+	ret = getsockopt(fds[0], SOL_SOCKET, SO_SNDBUF, &bufsize, &argsize);
+	if (ret == -1) {
+		printf(TNAME " Error reading socket buffer size: %s\n",
+			strerror(errno));
+		cleanup();
 		return PTS_UNRESOLVED;
 	}
 
-	unlink(tmpfname);
+	/* Socket buffer size is twice the maximum message size */
+	bufsize /= 2;
 
 	/* create AIO req */
-
 	for (i = 0; i < BUF_NB; i++) {
-		aiocb[i] = calloc(1, sizeof(struct aiocb));
-		if (aiocb[i] == NULL) {
-			printf(TNAME " Error at malloc(): %s\n",
-			       strerror(errno));
-			return PTS_UNRESOLVED;
-		}
-		buf[i] = malloc(BUF_SIZE);
+		buf[i] = malloc(bufsize);
 		if (buf[i] == NULL) {
 			printf(TNAME " Error at malloc(): %s\n",
-			       strerror(errno));
+				strerror(errno));
+			cleanup();
 			return PTS_UNRESOLVED;
 		}
-		aiocb[i]->aio_fildes = fd;
-		aiocb[i]->aio_buf = buf[i];
-		aiocb[i]->aio_nbytes = BUF_SIZE;
-		aiocb[i]->aio_offset = 0;
-		aiocb[i]->aio_sigevent.sigev_notify = SIGEV_NONE;
+		aiocb[i].aio_fildes = fds[0];
+		aiocb[i].aio_buf = buf[i];
+		aiocb[i].aio_nbytes = bufsize;
+		aiocb[i].aio_offset = 0;
+		aiocb[i].aio_sigevent.sigev_notify = SIGEV_NONE;
 
-		if (aio_write(aiocb[i]) == -1) {
+		if (aio_write(&aiocb[i]) == -1) {
 			printf(TNAME " loop %d: Error at aio_write(): %s\n",
-			       i, strerror(errno));
+				i, strerror(errno));
+			cleanup();
 			return PTS_FAIL;
 		}
 	}
 
-	/* try to cancel all
-	 * we hope to have enough time to cancel at least one
-	 */
+	/* wait for write #2 to start and get blocked by full socket buffer */
+	for (i = 0; i < 1000; i++) {
+		ret = aio_error(&aiocb[BLOCKED_TASK - 1]);
+		nanosleep(&sleep_ts, NULL);
 
-	if (aio_cancel(fd, NULL) == -1) {
+		if (ret <= 0)
+			break;
+	}
+
+	if (ret) {
+		printf(TNAME " Task #%d failed to complete: %s\n",
+			BLOCKED_TASK - 1, strerror(ret == -1 ? errno : ret));
+		cleanup();
+		return PTS_FAIL;
+	}
+
+	/* try to cancel all */
+	ret = aio_cancel(fds[0], NULL);
+	if (ret == -1) {
 		printf(TNAME " Error at aio_cancel(): %s\n", strerror(errno));
+		cleanup();
 		return PTS_FAIL;
 	}
 
-	close(fd);
+	if (ret != AIO_NOTCANCELED) {
+		printf(TNAME " Unexpected aio_cancel() return value: %s\n",
+			strerror(ret));
+		cleanup();
+		return PTS_FAIL;
+	}
 
-	check_one = 0;
-	do {
-		in_progress = 0;
-		for (i = 0; i < BUF_NB; i++) {
-			int ret;
+	for (i = 0, exp_ret = 0; i < BUF_NB; i++) {
+		ret = (aio_error(&aiocb[i]));
 
-			ret = (aio_error(aiocb[i]));
+		if (i == BLOCKED_TASK) {
+			if (ret != EINPROGRESS) {
+				printf(TNAME " Bad task #%d result: %s "
+					"(expected EINPROGRESS)\n",
+					i, strerror(ret));
+				cleanup();
+				return PTS_FAIL;
+			}
 
-			if (ret == -1) {
-				printf(TNAME " Error at aio_error(): %s\n",
-				       strerror(errno));
+			/* check iocb is not modified */
+			if ((aiocb[i].aio_fildes != fds[0]) ||
+				(aiocb[i].aio_buf != buf[i]) ||
+				(aiocb[i].aio_nbytes != (size_t)bufsize) ||
+				(aiocb[i].aio_offset != 0) ||
+				(aiocb[i].aio_sigevent.sigev_notify !=
+				SIGEV_NONE)) {
+
+				printf(TNAME " aiocbp modified\n");
+				cleanup();
 				return PTS_FAIL;
-			} else if ((ret == EINPROGRESS) || (ret == 0)) {
-				if (ret == EINPROGRESS)
-					in_progress = 1;
-
-				check_one = 1;
-
-				/* check iocb is not modified */
-
-				if ((aiocb[i]->aio_fildes != fd) ||
-				    (aiocb[i]->aio_buf != buf[i]) ||
-				    (aiocb[i]->aio_nbytes != BUF_SIZE) ||
-				    (aiocb[i]->aio_offset != 0) ||
-				    (aiocb[i]->aio_sigevent.sigev_notify !=
-				     SIGEV_NONE)) {
-					printf(TNAME " aiocbp modified\n");
-					return PTS_FAIL;
-				}
 			}
+
+			exp_ret = ECANCELED;
+			continue;
 		}
-	} while (in_progress);
 
-	if (!check_one)
-		return PTS_UNRESOLVED;
+		if (ret != exp_ret) {
+			printf(TNAME " Bad task #%d result: %s (expected %s)\n",
+				i, strerror(ret), strerror(exp_ret));
+			cleanup();
+			return PTS_FAIL;
+		}
+	}
 
+	cleanup();
+	printf("Test PASSED\n");
 	return PTS_PASS;
 }
Signature · 5 lines
2.51.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
Acked-by Andrea Cervesato on v1 1/1
#1 lore raw

Hi!

That "we hope to have enough time to cancel at least one" sentence in the previous test version should have raised more than one question..

Thanks for fixing it, I don't see any critical error.

Signature · 7 lines
Andrea Cervesato
SUSE QE Automation Engineer Linux
[email protected]


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
Reviewed-by on v1 1/1
#2 lore raw
In reply to Martin Doucha

Hi Martin,

Quoted 8 lines

The test schedules multiple async writes into a file and then hopes that at least one will block long enough that aio_cancel() will fail to cancel it. Use a socket pair instead of a file to force async writes to block indefinitely. Then wait for one of the writes to actually block on full socket buffer. This fixes a race condition where aio_cancel() could be called while no write is actually in progress (before the first write, after the last one or between two writes) and the test would fail.

Quoted 6 lines

Also rewrite result checks to verify that all writes before the blocked one actually completed and all writes after the blocked one were cancelled.

Add cleanup helper function that will flush socket buffers, free allocated memory and close the sockets. Also make setup and cleanup simpler by statically allocating the aiocb structure array.

+1, thank you. Similar way as your fix for aio_cancel_7-1 in 220f579cd6. I wonder if some other needs to be fixed this way.

...

Quoted 4 lines

* method:
*
- * queue a some aio_write() to a file descriptor
+ * queue some aio_write() to a file descriptor

We now use socket. Maybe update docs?

Code itself LGTM.

Kind regards,
Petr

Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp

A message that is not in the archive (sent off-list or not yet received): [email protected]

#4 lore raw
Quoted 11 lines · Petr Vorel
Quoted 5 lines
Quoted 4 lines

* method:

   *

- * queue a some aio_write() to a file descriptor
+ * queue some aio_write() to a file descriptor

We now use socket. Maybe update docs?

Hi,
even though I've switched the test from file to a socket pair, the file descriptor is still a file descriptor. The test description is good enough as is.

Fair enough, I'm sorry to overlook it.
Merged, thank you!

Kind regards,
Petr

Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp