Page MenuHomeFreeBSD
Files F147395557

D11468.id30377.diff
No OneTemporary
Actions

D11468.id30377.diff
View Options

Index: tests/sys/aio/Makefile
===================================================================
--- tests/sys/aio/Makefile
+++ tests/sys/aio/Makefile
@@ -7,7 +7,7 @@
PLAIN_TESTS_C+= aio_kqueue_test
PLAIN_TESTS_C+= lio_kqueue_test
-LIBADD.aio_test+= util
+LIBADD.aio_test+= util rt
CFLAGS+= -I${.CURDIR:H:H}
Index: tests/sys/aio/aio_test.c
===================================================================
--- tests/sys/aio/aio_test.c
+++ tests/sys/aio/aio_test.c
@@ -89,7 +89,8 @@
void *ac_cleanup_arg;
};
-static int aio_timedout;
+static int aio_timedout = 0;
+static sig_atomic_t signaled = 0;
/*
* Each test run specifies a timeout in seconds. Use the somewhat obsoleted
@@ -202,7 +203,69 @@
}
}
+static void
+sigusr1_handler(int sig __unused) {
+ signaled = 1;
+}
+
+static void
+thr_handler(union sigval sv __unused) {
+ signaled = 1;
+}
+
static ssize_t
+poll_signaled(struct aiocb *aio)
+{
+ int error;
+
+ while (signaled == 0 && !aio_timedout)
+ usleep(25000);
+ signaled = 0; /* Reset the signal handler */
+ error = aio_error(aio);
+ switch (error) {
+ case EINPROGRESS:
+ errno = EINTR;
+ return (-1);
+ case 0:
+ return (aio_return(aio));
+ default:
+ return (error);
+ }
+}
+
+/*
+ * Setup a signal handler for signal delivery tests
+ * This isn't thread safe, but it's ok since ATF runs each testcase in a
+ * separate process
+ */
+static struct sigevent*
+setup_signal()
+{
+ static struct sigevent sev;
+
+ sev.sigev_notify = SIGEV_SIGNAL;
+ sev.sigev_signo = SIGUSR1;
+ ATF_REQUIRE(SIG_ERR != signal(SIGUSR1, sigusr1_handler));
+ return(&sev);
+}
+
+/*
+ * Setup a thread for thread delivery tests
+ * This isn't thread safe, but it's ok since ATF runs each testcase in a
+ * separate process
+ */
+static struct sigevent*
+setup_thread()
+{
+ static struct sigevent sev;
+
+ sev.sigev_notify = SIGEV_THREAD;
+ sev.sigev_notify_function = thr_handler;
+ sev.sigev_notify_attributes = NULL;
+ return(&sev);
+}
+
+static ssize_t
suspend(struct aiocb *aio)
{
const struct aiocb *const iocbs[] = {aio};
@@ -248,7 +311,7 @@
* file descriptor.
*/
static void
-aio_write_test(struct aio_context *ac, completion comp)
+aio_write_test(struct aio_context *ac, completion comp, struct sigevent *sev)
{
struct aiocb aio;
ssize_t len;
@@ -258,6 +321,8 @@
aio.aio_nbytes = ac->ac_buflen;
aio.aio_fildes = ac->ac_write_fd;
aio.aio_offset = 0;
+ if (sev)
+ aio.aio_sigevent = *sev;
aio_timeout_start(ac->ac_seconds);
@@ -297,7 +362,7 @@
* provided file descriptor.
*/
static void
-aio_read_test(struct aio_context *ac, completion comp)
+aio_read_test(struct aio_context *ac, completion comp, struct sigevent *sev)
{
struct aiocb aio;
ssize_t len;
@@ -308,6 +373,8 @@
aio.aio_nbytes = ac->ac_buflen;
aio.aio_fildes = ac->ac_read_fd;
aio.aio_offset = 0;
+ if (sev)
+ aio.aio_sigevent = *sev;
aio_timeout_start(ac->ac_seconds);
@@ -376,7 +443,7 @@
}
static void
-aio_file_test(completion comp)
+aio_file_test(completion comp, struct sigevent *sev)
{
struct aio_file_arg arg;
struct aio_context ac;
@@ -392,8 +459,8 @@
aio_context_init(&ac, fd, fd, FILE_LEN,
FILE_TIMEOUT, aio_file_cleanup, &arg);
- aio_write_test(&ac, comp);
- aio_read_test(&ac, comp);
+ aio_write_test(&ac, comp, sev);
+ aio_read_test(&ac, comp, sev);
aio_file_cleanup(&arg);
}
@@ -401,19 +468,31 @@
ATF_TC_WITHOUT_HEAD(file_poll);
ATF_TC_BODY(file_poll, tc)
{
- aio_file_test(poll);
+ aio_file_test(poll, NULL);
}
+ATF_TC_WITHOUT_HEAD(file_signal);
+ATF_TC_BODY(file_signal, tc)
+{
+ aio_file_test(poll_signaled, setup_signal());
+}
+
ATF_TC_WITHOUT_HEAD(file_suspend);
ATF_TC_BODY(file_suspend, tc)
{
- aio_file_test(suspend);
+ aio_file_test(suspend, NULL);
}
+ATF_TC_WITHOUT_HEAD(file_thread);
+ATF_TC_BODY(file_thread, tc)
+{
+ aio_file_test(poll_signaled, setup_thread());
+}
+
ATF_TC_WITHOUT_HEAD(file_waitcomplete);
ATF_TC_BODY(file_waitcomplete, tc)
{
- aio_file_test(waitcomplete);
+ aio_file_test(waitcomplete, NULL);
}
#define FIFO_LEN 256
@@ -438,7 +517,7 @@
}
static void
-aio_fifo_test(completion comp)
+aio_fifo_test(completion comp, struct sigevent *sev)
{
int error, read_fd = -1, write_fd = -1;
struct aio_fifo_arg arg;
@@ -474,8 +553,8 @@
aio_context_init(&ac, read_fd, write_fd, FIFO_LEN,
FIFO_TIMEOUT, aio_fifo_cleanup, &arg);
- aio_write_test(&ac, comp);
- aio_read_test(&ac, comp);
+ aio_write_test(&ac, comp, sev);
+ aio_read_test(&ac, comp, sev);
aio_fifo_cleanup(&arg);
}
@@ -483,19 +562,31 @@
ATF_TC_WITHOUT_HEAD(fifo_poll);
ATF_TC_BODY(fifo_poll, tc)
{
- aio_fifo_test(poll);
+ aio_fifo_test(poll, NULL);
}
+ATF_TC_WITHOUT_HEAD(fifo_signal);
+ATF_TC_BODY(fifo_signal, tc)
+{
+ aio_fifo_test(poll_signaled, setup_signal());
+}
+
ATF_TC_WITHOUT_HEAD(fifo_suspend);
ATF_TC_BODY(fifo_suspend, tc)
{
- aio_fifo_test(waitcomplete);
+ aio_fifo_test(suspend, NULL);
}
+ATF_TC_WITHOUT_HEAD(fifo_thread);
+ATF_TC_BODY(fifo_thread, tc)
+{
+ aio_fifo_test(poll_signaled, setup_thread());
+}
+
ATF_TC_WITHOUT_HEAD(fifo_waitcomplete);
ATF_TC_BODY(fifo_waitcomplete, tc)
{
- aio_fifo_test(waitcomplete);
+ aio_fifo_test(waitcomplete, NULL);
}
struct aio_unix_socketpair_arg {
@@ -515,7 +606,7 @@
#define UNIX_SOCKETPAIR_LEN 256
#define UNIX_SOCKETPAIR_TIMEOUT 30
static void
-aio_unix_socketpair_test(completion comp)
+aio_unix_socketpair_test(completion comp, struct sigevent *sev)
{
struct aio_unix_socketpair_arg arg;
struct aio_context ac;
@@ -534,12 +625,12 @@
aio_unix_socketpair_cleanup, &arg);
ATF_REQUIRE_MSG(getrusage(RUSAGE_SELF, &ru_before) != -1,
"getrusage failed: %s", strerror(errno));
- aio_write_test(&ac, comp);
+ aio_write_test(&ac, comp, sev);
ATF_REQUIRE_MSG(getrusage(RUSAGE_SELF, &ru_after) != -1,
"getrusage failed: %s", strerror(errno));
ATF_REQUIRE(ru_after.ru_msgsnd == ru_before.ru_msgsnd + 1);
ru_before = ru_after;
- aio_read_test(&ac, comp);
+ aio_read_test(&ac, comp, sev);
ATF_REQUIRE_MSG(getrusage(RUSAGE_SELF, &ru_after) != -1,
"getrusage failed: %s", strerror(errno));
ATF_REQUIRE(ru_after.ru_msgrcv == ru_before.ru_msgrcv + 1);
@@ -550,19 +641,31 @@
ATF_TC_WITHOUT_HEAD(socket_poll);
ATF_TC_BODY(socket_poll, tc)
{
- aio_unix_socketpair_test(poll);
+ aio_unix_socketpair_test(poll, NULL);
}
+ATF_TC_WITHOUT_HEAD(socket_signal);
+ATF_TC_BODY(socket_signal, tc)
+{
+ aio_unix_socketpair_test(poll_signaled, setup_signal());
+}
+
ATF_TC_WITHOUT_HEAD(socket_suspend);
ATF_TC_BODY(socket_suspend, tc)
{
- aio_unix_socketpair_test(suspend);
+ aio_unix_socketpair_test(suspend, NULL);
}
+ATF_TC_WITHOUT_HEAD(socket_thread);
+ATF_TC_BODY(socket_thread, tc)
+{
+ aio_unix_socketpair_test(poll_signaled, setup_thread());
+}
+
ATF_TC_WITHOUT_HEAD(socket_waitcomplete);
ATF_TC_BODY(socket_waitcomplete, tc)
{
- aio_unix_socketpair_test(waitcomplete);
+ aio_unix_socketpair_test(waitcomplete, NULL);
}
struct aio_pty_arg {
@@ -583,7 +686,7 @@
#define PTY_LEN 256
#define PTY_TIMEOUT 30
static void
-aio_pty_test(completion comp)
+aio_pty_test(completion comp, struct sigevent *sev)
{
struct aio_pty_arg arg;
struct aio_context ac;
@@ -616,8 +719,8 @@
aio_context_init(&ac, read_fd, write_fd, PTY_LEN,
PTY_TIMEOUT, aio_pty_cleanup, &arg);
- aio_write_test(&ac, comp);
- aio_read_test(&ac, comp);
+ aio_write_test(&ac, comp, sev);
+ aio_read_test(&ac, comp, sev);
aio_pty_cleanup(&arg);
}
@@ -625,19 +728,31 @@
ATF_TC_WITHOUT_HEAD(pty_poll);
ATF_TC_BODY(pty_poll, tc)
{
- aio_pty_test(poll);
+ aio_pty_test(poll, NULL);
}
+ATF_TC_WITHOUT_HEAD(pty_signal);
+ATF_TC_BODY(pty_signal, tc)
+{
+ aio_pty_test(poll_signaled, setup_signal());
+}
+
ATF_TC_WITHOUT_HEAD(pty_suspend);
ATF_TC_BODY(pty_suspend, tc)
{
- aio_pty_test(suspend);
+ aio_pty_test(suspend, NULL);
}
+ATF_TC_WITHOUT_HEAD(pty_thread);
+ATF_TC_BODY(pty_thread, tc)
+{
+ aio_pty_test(poll_signaled, setup_thread());
+}
+
ATF_TC_WITHOUT_HEAD(pty_waitcomplete);
ATF_TC_BODY(pty_waitcomplete, tc)
{
- aio_pty_test(waitcomplete);
+ aio_pty_test(waitcomplete, NULL);
}
static void
@@ -652,7 +767,7 @@
#define PIPE_LEN 256
#define PIPE_TIMEOUT 30
static void
-aio_pipe_test(completion comp)
+aio_pipe_test(completion comp, struct sigevent *sev)
{
struct aio_context ac;
int pipes[2];
@@ -665,8 +780,8 @@
aio_context_init(&ac, pipes[0], pipes[1], PIPE_LEN,
PIPE_TIMEOUT, aio_pipe_cleanup, pipes);
- aio_write_test(&ac, comp);
- aio_read_test(&ac, comp);
+ aio_write_test(&ac, comp, sev);
+ aio_read_test(&ac, comp, sev);
aio_pipe_cleanup(pipes);
}
@@ -674,19 +789,31 @@
ATF_TC_WITHOUT_HEAD(pipe_poll);
ATF_TC_BODY(pipe_poll, tc)
{
- aio_pipe_test(poll);
+ aio_pipe_test(poll, NULL);
}
+ATF_TC_WITHOUT_HEAD(pipe_signal);
+ATF_TC_BODY(pipe_signal, tc)
+{
+ aio_pipe_test(poll_signaled, setup_signal());
+}
+
ATF_TC_WITHOUT_HEAD(pipe_suspend);
ATF_TC_BODY(pipe_suspend, tc)
{
- aio_pipe_test(suspend);
+ aio_pipe_test(suspend, NULL);
}
+ATF_TC_WITHOUT_HEAD(pipe_thread);
+ATF_TC_BODY(pipe_thread, tc)
+{
+ aio_pipe_test(poll_signaled, setup_thread());
+}
+
ATF_TC_WITHOUT_HEAD(pipe_waitcomplete);
ATF_TC_BODY(pipe_waitcomplete, tc)
{
- aio_pipe_test(waitcomplete);
+ aio_pipe_test(waitcomplete, NULL);
}
struct aio_md_arg {
@@ -726,7 +853,7 @@
#define MD_LEN GLOBAL_MAX
#define MD_TIMEOUT 30
static void
-aio_md_test(completion comp)
+aio_md_test(completion comp, struct sigevent *sev)
{
int error, fd, mdctl_fd, unit;
char pathname[PATH_MAX];
@@ -767,8 +894,8 @@
aio_context_init(&ac, fd, fd, MD_LEN, MD_TIMEOUT,
aio_md_cleanup, &arg);
- aio_write_test(&ac, comp);
- aio_read_test(&ac, comp);
+ aio_write_test(&ac, comp, sev);
+ aio_read_test(&ac, comp, sev);
aio_md_cleanup(&arg);
}
@@ -781,9 +908,20 @@
}
ATF_TC_BODY(md_poll, tc)
{
- aio_md_test(poll);
+ aio_md_test(poll, NULL);
}
+ATF_TC(md_signal);
+ATF_TC_HEAD(md_signal, tc)
+{
+
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(md_signal, tc)
+{
+ aio_md_test(poll_signaled, setup_signal());
+}
+
ATF_TC(md_suspend);
ATF_TC_HEAD(md_suspend, tc)
{
@@ -792,9 +930,20 @@
}
ATF_TC_BODY(md_suspend, tc)
{
- aio_md_test(suspend);
+ aio_md_test(suspend, NULL);
}
+ATF_TC(md_thread);
+ATF_TC_HEAD(md_thread, tc)
+{
+
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(md_thread, tc)
+{
+ aio_md_test(poll_signaled, setup_thread());
+}
+
ATF_TC(md_waitcomplete);
ATF_TC_HEAD(md_waitcomplete, tc)
{
@@ -803,7 +952,7 @@
}
ATF_TC_BODY(md_waitcomplete, tc)
{
- aio_md_test(waitcomplete);
+ aio_md_test(waitcomplete, NULL);
}
ATF_TC_WITHOUT_HEAD(aio_large_read_test);
@@ -1152,28 +1301,40 @@
{
ATF_TP_ADD_TC(tp, file_poll);
+ ATF_TP_ADD_TC(tp, file_signal);
ATF_TP_ADD_TC(tp, file_suspend);
+ ATF_TP_ADD_TC(tp, file_thread);
ATF_TP_ADD_TC(tp, file_waitcomplete);
ATF_TP_ADD_TC(tp, fifo_poll);
+ ATF_TP_ADD_TC(tp, fifo_signal);
ATF_TP_ADD_TC(tp, fifo_suspend);
+ ATF_TP_ADD_TC(tp, fifo_thread);
ATF_TP_ADD_TC(tp, fifo_waitcomplete);
ATF_TP_ADD_TC(tp, socket_poll);
+ ATF_TP_ADD_TC(tp, socket_signal);
ATF_TP_ADD_TC(tp, socket_suspend);
+ ATF_TP_ADD_TC(tp, socket_thread);
ATF_TP_ADD_TC(tp, socket_waitcomplete);
ATF_TP_ADD_TC(tp, pty_poll);
+ ATF_TP_ADD_TC(tp, pty_signal);
ATF_TP_ADD_TC(tp, pty_suspend);
+ ATF_TP_ADD_TC(tp, pty_thread);
ATF_TP_ADD_TC(tp, pty_waitcomplete);
ATF_TP_ADD_TC(tp, pipe_poll);
+ ATF_TP_ADD_TC(tp, pipe_signal);
ATF_TP_ADD_TC(tp, pipe_suspend);
+ ATF_TP_ADD_TC(tp, pipe_thread);
ATF_TP_ADD_TC(tp, pipe_waitcomplete);
ATF_TP_ADD_TC(tp, md_poll);
+ ATF_TP_ADD_TC(tp, md_signal);
ATF_TP_ADD_TC(tp, md_suspend);
+ ATF_TP_ADD_TC(tp, md_thread);
ATF_TP_ADD_TC(tp, md_waitcomplete);
+ ATF_TP_ADD_TC(tp, aio_fsync_test);
ATF_TP_ADD_TC(tp, aio_large_read_test);
ATF_TP_ADD_TC(tp, aio_socket_two_reads);
ATF_TP_ADD_TC(tp, aio_socket_blocking_short_write);
ATF_TP_ADD_TC(tp, aio_socket_short_write_cancel);
- ATF_TP_ADD_TC(tp, aio_fsync_test);
return (atf_no_error());
}

File Metadata

Mime Type
text/plain
Expires
Wed, Mar 11, 3:22 PM (2 h, 25 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
29542693
Default Alt Text
D11468.id30377.diff (11 KB)

Event Timeline