mirror of
https://git.rtems.org/rtems-libbsd/
synced 2025-07-24 09:32:05 +08:00
selectpollkqueue01: New test
This commit is contained in:
parent
e65783f249
commit
510946e699
12
Makefile
12
Makefile
@ -771,6 +771,18 @@ LIB_C_FILES += freebsd/usr.bin/netstat/pfkey.c
|
||||
LIB_C_FILES += freebsd/usr.bin/netstat/sctp.c
|
||||
LIB_C_FILES += freebsd/usr.bin/netstat/unix.c
|
||||
|
||||
TEST_SELECTPOLLKQUEUE01 = testsuite/selectpollkqueue01/selectpollkqueue01.exe
|
||||
TEST_SELECTPOLLKQUEUE01_O_FILES =
|
||||
TEST_SELECTPOLLKQUEUE01_D_FILES =
|
||||
TEST_SELECTPOLLKQUEUE01_O_FILES += testsuite/selectpollkqueue01/test_main.o
|
||||
TEST_SELECTPOLLKQUEUE01_D_FILES += testsuite/selectpollkqueue01/test_main.d
|
||||
$(TEST_SELECTPOLLKQUEUE01): $(TEST_SELECTPOLLKQUEUE01_O_FILES) $(LIB)
|
||||
$(LINK.c) -Wl,-Map,testsuite/selectpollkqueue01/selectpollkqueue01.map $^ -lm -lz -o $@
|
||||
TESTS += $(TEST_SELECTPOLLKQUEUE01)
|
||||
O_FILES += $(TEST_SELECTPOLLKQUEUE01_O_FILES)
|
||||
D_FILES += $(TEST_SELECTPOLLKQUEUE01_D_FILES)
|
||||
RUN_TESTS += $(TEST_SELECTPOLLKQUEUE01)
|
||||
|
||||
TEST_RWLOCK01 = testsuite/rwlock01/rwlock01.exe
|
||||
TEST_RWLOCK01_O_FILES =
|
||||
TEST_RWLOCK01_D_FILES =
|
||||
|
@ -2347,6 +2347,7 @@ in_cksum.addCPUDependentSourceFiles(
|
||||
)
|
||||
|
||||
tests = Module('tests')
|
||||
tests.addTest('selectpollkqueue01', ['test_main'])
|
||||
tests.addTest('rwlock01', ['test_main'])
|
||||
tests.addTest('sleep01', ['test_main'])
|
||||
tests.addTest('syscalls01', ['test_main'])
|
||||
|
997
testsuite/selectpollkqueue01/test_main.c
Normal file
997
testsuite/selectpollkqueue01/test_main.c
Normal file
@ -0,0 +1,997 @@
|
||||
/*
|
||||
* Copyright (c) 2013 embedded brains GmbH. All rights reserved.
|
||||
*
|
||||
* embedded brains GmbH
|
||||
* Dornierstr. 4
|
||||
* 82178 Puchheim
|
||||
* Germany
|
||||
* <rtems@embedded-brains.de>
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <rtems/bsd/sys/param.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/event.h>
|
||||
#include <sys/filio.h>
|
||||
#include <sys/select.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/time.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <netinet/in.h>
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <inttypes.h>
|
||||
#include <poll.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sysexits.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <machine/rtems-bsd-commands.h>
|
||||
|
||||
#include <rtems/libcsupport.h>
|
||||
#include <rtems/stackchk.h>
|
||||
#include <rtems.h>
|
||||
|
||||
#define TEST_NAME "LIBBSD SELECT AND POLL AND KQUEUE 1"
|
||||
|
||||
#define PRIO_MASTER 1
|
||||
|
||||
#define PRIO_WORKER 2
|
||||
|
||||
#define EVENT_READ RTEMS_EVENT_0
|
||||
|
||||
#define EVENT_WRITE RTEMS_EVENT_1
|
||||
|
||||
#define EVENT_CONNECT RTEMS_EVENT_2
|
||||
|
||||
#define EVENT_CLOSE RTEMS_EVENT_3
|
||||
|
||||
#define EVENT_SHUTDOWN RTEMS_EVENT_4
|
||||
|
||||
#define BUF_SIZE 4096
|
||||
|
||||
#define PORT 1234
|
||||
|
||||
#define TEST_UDATA ((void *) 0xcafe)
|
||||
|
||||
typedef struct {
|
||||
char buf[BUF_SIZE];
|
||||
const char *wbuf;
|
||||
char *rbuf;
|
||||
size_t rn;
|
||||
size_t wn;
|
||||
int lfd;
|
||||
int cfd;
|
||||
int afd;
|
||||
int rfd;
|
||||
int wfd;
|
||||
struct sockaddr_in caddr;
|
||||
rtems_id worker_task;
|
||||
} test_context;
|
||||
|
||||
static test_context test_instance = {
|
||||
.cfd = -1
|
||||
};
|
||||
|
||||
static const char msg[] = "This is a message. One two three.";
|
||||
|
||||
static void
|
||||
setup_lo0(void)
|
||||
{
|
||||
int exit_code;
|
||||
char *lo0[] = {
|
||||
"ifconfig",
|
||||
"lo0",
|
||||
"inet",
|
||||
"127.0.0.1",
|
||||
"netmask",
|
||||
"255.255.255.0",
|
||||
NULL
|
||||
};
|
||||
|
||||
exit_code = rtems_bsd_command_ifconfig(RTEMS_ARRAY_SIZE(lo0) - 1, lo0);
|
||||
assert(exit_code == EX_OK);
|
||||
}
|
||||
|
||||
static void
|
||||
set_self_prio(rtems_task_priority prio)
|
||||
{
|
||||
rtems_status_code sc;
|
||||
|
||||
sc = rtems_task_set_priority(RTEMS_SELF, prio, &prio);
|
||||
assert(sc == RTEMS_SUCCESSFUL);
|
||||
}
|
||||
|
||||
static void
|
||||
create_server_socket(test_context *ctx)
|
||||
{
|
||||
struct sockaddr_in saddr;
|
||||
int rv;
|
||||
int lfd;
|
||||
|
||||
lfd = socket(PF_INET, SOCK_STREAM, 0);
|
||||
assert(lfd >= 0);
|
||||
|
||||
memset(&saddr, 0, sizeof(saddr));
|
||||
saddr.sin_family = AF_INET;
|
||||
saddr.sin_port = htons(PORT);
|
||||
saddr.sin_addr.s_addr = htonl(INADDR_ANY);
|
||||
|
||||
rv = bind(lfd, (const struct sockaddr *) &saddr, sizeof(saddr));
|
||||
assert(rv == 0);
|
||||
|
||||
rv = listen(lfd, 1);
|
||||
assert(rv == 0);
|
||||
|
||||
ctx->lfd = lfd;
|
||||
}
|
||||
|
||||
static void
|
||||
create_client_addr(test_context *ctx)
|
||||
{
|
||||
struct sockaddr_in *caddr = &ctx->caddr;;
|
||||
int ok;
|
||||
|
||||
memset(caddr, 0, sizeof(*caddr));
|
||||
caddr->sin_family = AF_INET;
|
||||
caddr->sin_port = htons(PORT);
|
||||
ok = inet_aton("127.0.0.1", &caddr->sin_addr);
|
||||
assert(ok != 0);
|
||||
}
|
||||
|
||||
static void
|
||||
worker_task(rtems_task_argument arg)
|
||||
{
|
||||
test_context *ctx = (test_context *) arg;
|
||||
|
||||
while (true) {
|
||||
rtems_status_code sc;
|
||||
rtems_event_set events;
|
||||
ssize_t n;
|
||||
int rv;
|
||||
int cfd = ctx->cfd;
|
||||
|
||||
sc = rtems_event_receive(
|
||||
RTEMS_ALL_EVENTS,
|
||||
RTEMS_EVENT_ANY | RTEMS_WAIT,
|
||||
RTEMS_NO_TIMEOUT,
|
||||
&events
|
||||
);
|
||||
assert(sc == RTEMS_SUCCESSFUL);
|
||||
|
||||
if ((events & EVENT_READ) != 0) {
|
||||
puts("worker: read");
|
||||
|
||||
n = read(ctx->rfd, &ctx->rbuf[0], ctx->rn);
|
||||
assert(n == (ssize_t) ctx->rn);
|
||||
}
|
||||
|
||||
if ((events & EVENT_WRITE) != 0) {
|
||||
puts("worker: write");
|
||||
|
||||
n = write(ctx->wfd, &ctx->wbuf[0], ctx->wn);
|
||||
assert(n == (ssize_t) ctx->wn);
|
||||
}
|
||||
|
||||
if ((events & EVENT_CONNECT) != 0) {
|
||||
if (cfd >= 0) {
|
||||
puts("worker: close connect socket");
|
||||
|
||||
ctx->cfd = -1;
|
||||
|
||||
rv = close(cfd);
|
||||
assert(rv == 0);
|
||||
|
||||
cfd = -1;
|
||||
}
|
||||
|
||||
if (cfd < 0) {
|
||||
puts("worker: create new connect socket");
|
||||
|
||||
cfd = socket(PF_INET, SOCK_STREAM, 0);
|
||||
assert(cfd >= 0);
|
||||
|
||||
ctx->cfd = cfd;
|
||||
}
|
||||
|
||||
puts("worker: connect");
|
||||
|
||||
rv = connect(
|
||||
cfd,
|
||||
(const struct sockaddr *) &ctx->caddr,
|
||||
sizeof(ctx->caddr)
|
||||
);
|
||||
assert(rv == 0);
|
||||
}
|
||||
|
||||
if ((events & EVENT_CLOSE) != 0) {
|
||||
puts("worker: close");
|
||||
|
||||
ctx->cfd = -1;
|
||||
|
||||
rv = close(cfd);
|
||||
assert(rv == 0);
|
||||
}
|
||||
|
||||
if ((events & EVENT_SHUTDOWN) != 0) {
|
||||
puts("worker: shutdown");
|
||||
|
||||
rv = shutdown(cfd, SHUT_RDWR);
|
||||
assert(rv == 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
send_events(test_context *ctx, rtems_event_set events)
|
||||
{
|
||||
rtems_status_code sc;
|
||||
|
||||
sc = rtems_event_send(ctx->worker_task, events);
|
||||
assert(sc == RTEMS_SUCCESSFUL);
|
||||
}
|
||||
|
||||
static void
|
||||
start_worker(test_context *ctx)
|
||||
{
|
||||
rtems_status_code sc;
|
||||
|
||||
sc = rtems_task_create(
|
||||
rtems_build_name('W', 'O', 'R', 'K'),
|
||||
PRIO_WORKER,
|
||||
RTEMS_MINIMUM_STACK_SIZE,
|
||||
RTEMS_DEFAULT_MODES,
|
||||
RTEMS_DEFAULT_ATTRIBUTES,
|
||||
&ctx->worker_task
|
||||
);
|
||||
assert(sc == RTEMS_SUCCESSFUL);
|
||||
|
||||
sc = rtems_task_start(
|
||||
ctx->worker_task,
|
||||
worker_task,
|
||||
(rtems_task_argument) ctx
|
||||
);
|
||||
assert(sc == RTEMS_SUCCESSFUL);
|
||||
}
|
||||
|
||||
static void
|
||||
set_non_blocking(int fd, int enable)
|
||||
{
|
||||
int rv;
|
||||
|
||||
rv = ioctl(fd, FIONBIO, &enable);
|
||||
assert(rv == 0);
|
||||
}
|
||||
|
||||
static void
|
||||
test_select_timeout(test_context *ctx)
|
||||
{
|
||||
struct timeval timeout = {
|
||||
.tv_sec = 0,
|
||||
.tv_usec = 100000
|
||||
};
|
||||
int fd = ctx->lfd;
|
||||
int nfds = fd + 1;
|
||||
struct fd_set set;
|
||||
int rv;
|
||||
int i;
|
||||
|
||||
puts("test select timeout");
|
||||
|
||||
set_non_blocking(ctx->lfd, 0);
|
||||
|
||||
FD_ZERO(&set);
|
||||
FD_SET(fd, &set);
|
||||
|
||||
rv = select(nfds, &set, NULL, NULL, &timeout);
|
||||
assert(rv == 0);
|
||||
|
||||
for (i = 0; i < nfds; ++i) {
|
||||
assert(!FD_ISSET(i, &set));
|
||||
}
|
||||
|
||||
rv = select(nfds, NULL, &set, NULL, &timeout);
|
||||
assert(rv == 0);
|
||||
|
||||
for (i = 0; i < nfds; ++i) {
|
||||
assert(!FD_ISSET(i, &set));
|
||||
}
|
||||
|
||||
rv = select(nfds, NULL, NULL, &set, &timeout);
|
||||
assert(rv == 0);
|
||||
|
||||
for (i = 0; i < nfds; ++i) {
|
||||
assert(!FD_ISSET(i, &set));
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_select_connect(test_context *ctx)
|
||||
{
|
||||
int lfd = ctx->lfd;
|
||||
int afd = ctx->afd;
|
||||
int nfds = lfd + 1;
|
||||
struct fd_set set;
|
||||
int rv;
|
||||
int i;
|
||||
|
||||
puts("test select connect");
|
||||
|
||||
if (afd >= 0) {
|
||||
rv = close(afd);
|
||||
assert(rv == 0);
|
||||
}
|
||||
|
||||
send_events(ctx, EVENT_CONNECT);
|
||||
|
||||
set_non_blocking(lfd, 1);
|
||||
|
||||
errno = 0;
|
||||
afd = accept(lfd, NULL, NULL);
|
||||
assert(afd == -1);
|
||||
assert(errno == EAGAIN);
|
||||
|
||||
set_non_blocking(lfd, 0);
|
||||
|
||||
FD_ZERO(&set);
|
||||
FD_SET(lfd, &set);
|
||||
|
||||
rv = select(nfds, &set, NULL, NULL, NULL);
|
||||
assert(rv == 1);
|
||||
|
||||
for (i = 0; i < nfds; ++i) {
|
||||
bool is_set_expected = i == lfd;
|
||||
bool is_set = FD_ISSET(i, &set);
|
||||
|
||||
assert(is_set_expected == is_set);
|
||||
}
|
||||
|
||||
afd = accept(lfd, NULL, NULL);
|
||||
assert(afd >= 0);
|
||||
|
||||
ctx->afd = afd;
|
||||
}
|
||||
|
||||
static void
|
||||
test_select_read(test_context *ctx)
|
||||
{
|
||||
int afd = ctx->afd;
|
||||
int cfd = ctx->cfd;
|
||||
int nfds = afd + 1;
|
||||
struct fd_set set;
|
||||
int rv;
|
||||
int i;
|
||||
ssize_t n;
|
||||
|
||||
puts("test select read");
|
||||
|
||||
assert(afd >= 0);
|
||||
assert(cfd >= 0);
|
||||
|
||||
ctx->wfd = cfd;
|
||||
ctx->wbuf = &msg[0];
|
||||
ctx->wn = sizeof(msg);
|
||||
send_events(ctx, EVENT_WRITE);
|
||||
|
||||
set_non_blocking(afd, 1);
|
||||
|
||||
errno = 0;
|
||||
n = read(afd, &ctx->buf[0], sizeof(ctx->buf));
|
||||
assert(n == -1);
|
||||
assert(errno == EAGAIN);
|
||||
|
||||
FD_ZERO(&set);
|
||||
FD_SET(afd, &set);
|
||||
|
||||
rv = select(nfds, &set, NULL, NULL, NULL);
|
||||
assert(rv == 1);
|
||||
|
||||
for (i = 0; i < nfds; ++i) {
|
||||
bool is_set_expected = i == afd;
|
||||
bool is_set = FD_ISSET(i, &set);
|
||||
|
||||
assert(is_set_expected == is_set);
|
||||
}
|
||||
|
||||
n = read(afd, &ctx->buf[0], sizeof(ctx->buf));
|
||||
assert(n == (ssize_t) sizeof(msg));
|
||||
assert(memcmp(&msg[0], &ctx->buf[0], sizeof(msg)) == 0);
|
||||
}
|
||||
|
||||
static void
|
||||
test_select_write(test_context *ctx)
|
||||
{
|
||||
int afd = ctx->afd;
|
||||
int cfd = ctx->cfd;
|
||||
int nfds = afd + 1;
|
||||
struct fd_set set;
|
||||
int rv;
|
||||
int i;
|
||||
ssize_t n;
|
||||
|
||||
puts("test select write");
|
||||
|
||||
assert(afd >= 0);
|
||||
assert(cfd >= 0);
|
||||
|
||||
ctx->rfd = cfd;
|
||||
ctx->rbuf = &ctx->buf[0];
|
||||
ctx->rn = sizeof(ctx->buf);
|
||||
send_events(ctx, EVENT_READ);
|
||||
|
||||
set_non_blocking(afd, 1);
|
||||
|
||||
do {
|
||||
errno = 0;
|
||||
n = write(afd, &ctx->buf[0], sizeof(ctx->buf));
|
||||
if (n == -1) {
|
||||
assert(errno == EAGAIN);
|
||||
}
|
||||
} while (n > 0);
|
||||
|
||||
FD_ZERO(&set);
|
||||
FD_SET(afd, &set);
|
||||
|
||||
rv = select(nfds, NULL, &set, NULL, NULL);
|
||||
assert(rv == 1);
|
||||
|
||||
for (i = 0; i < nfds; ++i) {
|
||||
bool is_set_expected = i == afd;
|
||||
bool is_set = FD_ISSET(i, &set);
|
||||
|
||||
assert(is_set_expected == is_set);
|
||||
}
|
||||
|
||||
n = write(afd, &ctx->buf[0], 1);
|
||||
assert(n == 1);
|
||||
}
|
||||
|
||||
static void
|
||||
test_select_close(test_context *ctx)
|
||||
{
|
||||
int cfd = ctx->cfd;
|
||||
int nfds = cfd + 1;
|
||||
struct fd_set set;
|
||||
int rv;
|
||||
|
||||
puts("test select close");
|
||||
|
||||
assert(ctx->cfd >= 0);
|
||||
|
||||
send_events(ctx, EVENT_CLOSE);
|
||||
|
||||
assert(ctx->cfd >= 0);
|
||||
|
||||
FD_ZERO(&set);
|
||||
FD_SET(cfd, &set);
|
||||
|
||||
errno = 0;
|
||||
rv = select(nfds, NULL, NULL, &set, NULL);
|
||||
assert(rv == -1);
|
||||
assert(errno == EBADF);
|
||||
|
||||
assert(ctx->cfd == -1);
|
||||
}
|
||||
|
||||
static void
|
||||
test_poll_timeout(test_context *ctx)
|
||||
{
|
||||
static const short events[] = {
|
||||
POLLIN,
|
||||
POLLPRI,
|
||||
POLLOUT,
|
||||
POLLRDNORM,
|
||||
POLLWRNORM,
|
||||
POLLRDBAND,
|
||||
POLLWRBAND
|
||||
};
|
||||
|
||||
int timeout = 100;
|
||||
struct pollfd pfd = {
|
||||
.fd = ctx->lfd
|
||||
};
|
||||
size_t i;
|
||||
|
||||
puts("test poll timeout");
|
||||
|
||||
for (i = 0; i < nitems(events); ++i) {
|
||||
int rv;
|
||||
|
||||
pfd.events = events[i];
|
||||
pfd.revents = 0;
|
||||
|
||||
rv = poll(&pfd, 1, timeout);
|
||||
assert(rv == 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_poll_connect(test_context *ctx)
|
||||
{
|
||||
int lfd = ctx->lfd;
|
||||
int afd = ctx->afd;
|
||||
struct pollfd pfd = {
|
||||
.fd = lfd,
|
||||
.events = POLLIN
|
||||
};
|
||||
int timeout = -1;
|
||||
int rv;
|
||||
|
||||
puts("test poll connect");
|
||||
|
||||
if (afd >= 0) {
|
||||
rv = close(afd);
|
||||
assert(rv == 0);
|
||||
}
|
||||
|
||||
send_events(ctx, EVENT_CONNECT);
|
||||
|
||||
set_non_blocking(lfd, 1);
|
||||
|
||||
errno = 0;
|
||||
afd = accept(lfd, NULL, NULL);
|
||||
assert(afd == -1);
|
||||
assert(errno == EAGAIN);
|
||||
|
||||
set_non_blocking(lfd, 0);
|
||||
|
||||
rv = poll(&pfd, 1, timeout);
|
||||
assert(rv == 1);
|
||||
assert(pfd.revents == POLLIN);
|
||||
|
||||
afd = accept(lfd, NULL, NULL);
|
||||
assert(afd >= 0);
|
||||
|
||||
ctx->afd = afd;
|
||||
}
|
||||
|
||||
static void
|
||||
test_poll_read(test_context *ctx)
|
||||
{
|
||||
int afd = ctx->afd;
|
||||
int cfd = ctx->cfd;
|
||||
struct pollfd pfd = {
|
||||
.fd = afd,
|
||||
.events = POLLIN
|
||||
};
|
||||
int timeout = -1;
|
||||
int rv;
|
||||
ssize_t n;
|
||||
|
||||
puts("test poll read");
|
||||
|
||||
assert(afd >= 0);
|
||||
assert(cfd >= 0);
|
||||
|
||||
ctx->wfd = cfd;
|
||||
ctx->wbuf = &msg[0];
|
||||
ctx->wn = sizeof(msg);
|
||||
send_events(ctx, EVENT_WRITE);
|
||||
|
||||
set_non_blocking(afd, 1);
|
||||
|
||||
errno = 0;
|
||||
n = read(afd, &ctx->buf[0], sizeof(ctx->buf));
|
||||
assert(n == -1);
|
||||
assert(errno == EAGAIN);
|
||||
|
||||
rv = poll(&pfd, 1, timeout);
|
||||
assert(rv == 1);
|
||||
assert(pfd.revents == POLLIN);
|
||||
|
||||
n = read(afd, &ctx->buf[0], sizeof(ctx->buf));
|
||||
assert(n == (ssize_t) sizeof(msg));
|
||||
assert(memcmp(&msg[0], &ctx->buf[0], sizeof(msg)) == 0);
|
||||
}
|
||||
|
||||
static void
|
||||
test_poll_write(test_context *ctx)
|
||||
{
|
||||
int afd = ctx->afd;
|
||||
int cfd = ctx->cfd;
|
||||
struct pollfd pfd = {
|
||||
.fd = afd,
|
||||
.events = POLLOUT
|
||||
};
|
||||
int timeout = -1;
|
||||
int rv;
|
||||
ssize_t n;
|
||||
|
||||
puts("test poll write");
|
||||
|
||||
assert(afd >= 0);
|
||||
assert(cfd >= 0);
|
||||
|
||||
ctx->rfd = cfd;
|
||||
ctx->rbuf = &ctx->buf[0];
|
||||
ctx->rn = sizeof(ctx->buf);
|
||||
send_events(ctx, EVENT_READ);
|
||||
|
||||
set_non_blocking(afd, 1);
|
||||
|
||||
do {
|
||||
errno = 0;
|
||||
n = write(afd, &ctx->buf[0], sizeof(ctx->buf));
|
||||
if (n == -1) {
|
||||
assert(errno == EAGAIN);
|
||||
}
|
||||
} while (n > 0);
|
||||
|
||||
rv = poll(&pfd, 1, timeout);
|
||||
assert(rv == 1);
|
||||
assert(pfd.revents == POLLOUT);
|
||||
|
||||
n = write(afd, &ctx->buf[0], 1);
|
||||
assert(n == 1);
|
||||
}
|
||||
|
||||
static void
|
||||
test_poll_close(test_context *ctx)
|
||||
{
|
||||
int cfd = ctx->cfd;
|
||||
struct pollfd pfd = {
|
||||
.fd = cfd,
|
||||
.events = POLLRDBAND
|
||||
};
|
||||
int timeout = -1;
|
||||
int rv;
|
||||
|
||||
puts("test poll close");
|
||||
|
||||
assert(ctx->cfd >= 0);
|
||||
|
||||
send_events(ctx, EVENT_CLOSE);
|
||||
|
||||
assert(ctx->cfd >= 0);
|
||||
|
||||
rv = poll(&pfd, 1, timeout);
|
||||
assert(rv == 1);
|
||||
assert(pfd.revents == POLLNVAL);
|
||||
|
||||
assert(ctx->cfd == -1);
|
||||
}
|
||||
|
||||
static void
|
||||
test_kqueue_timer(bool do_resource_check)
|
||||
{
|
||||
rtems_resource_snapshot snapshot;
|
||||
int kq;
|
||||
int rv;
|
||||
struct kevent change;
|
||||
int i;
|
||||
|
||||
puts("test kqueue timer");
|
||||
|
||||
if (do_resource_check) {
|
||||
rtems_resource_snapshot_take(&snapshot);
|
||||
}
|
||||
|
||||
kq = kqueue();
|
||||
assert(kq >= 0);
|
||||
|
||||
EV_SET(&change, 0xbeef, EVFILT_TIMER, EV_ADD | EV_ENABLE, 0, 100,
|
||||
TEST_UDATA);
|
||||
|
||||
rv = kevent(kq, &change, 1, NULL, 0, NULL);
|
||||
assert(rv == 0);
|
||||
|
||||
for (i = 0; i < 5; ++i) {
|
||||
struct kevent event;
|
||||
|
||||
rv = kevent(kq, NULL, 0, &event, 1, NULL);
|
||||
assert(rv == 1);
|
||||
assert(event.ident == 0xbeef);
|
||||
assert(event.filter == EVFILT_TIMER);
|
||||
assert(event.flags == EV_CLEAR);
|
||||
assert(event.fflags == 0);
|
||||
assert(event.data == 1);
|
||||
assert(event.udata == TEST_UDATA);
|
||||
}
|
||||
|
||||
rv = close(kq);
|
||||
assert(rv == 0);
|
||||
|
||||
if (do_resource_check) {
|
||||
assert(rtems_resource_snapshot_check(&snapshot));
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_kqueue_connect(test_context *ctx)
|
||||
{
|
||||
int lfd = ctx->lfd;
|
||||
int afd = ctx->afd;
|
||||
int kq;
|
||||
struct kevent change;
|
||||
struct kevent event;
|
||||
const struct timespec *timeout = NULL;
|
||||
int rv;
|
||||
|
||||
puts("test kqueue connect");
|
||||
|
||||
if (afd >= 0) {
|
||||
rv = close(afd);
|
||||
assert(rv == 0);
|
||||
}
|
||||
|
||||
kq = kqueue();
|
||||
assert(kq >= 0);
|
||||
|
||||
EV_SET(&change, lfd, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0,
|
||||
TEST_UDATA);
|
||||
|
||||
rv = kevent(kq, &change, 1, NULL, 0, timeout);
|
||||
assert(rv == 0);
|
||||
|
||||
send_events(ctx, EVENT_CONNECT);
|
||||
|
||||
set_non_blocking(lfd, 1);
|
||||
|
||||
errno = 0;
|
||||
afd = accept(lfd, NULL, NULL);
|
||||
assert(afd == -1);
|
||||
assert(errno == EAGAIN);
|
||||
|
||||
set_non_blocking(lfd, 0);
|
||||
|
||||
rv = kevent(kq, NULL, 0, &event, 1, timeout);
|
||||
assert(rv == 1);
|
||||
assert(event.ident == lfd);
|
||||
assert(event.filter == EVFILT_READ);
|
||||
assert(event.flags == 0);
|
||||
assert(event.fflags == 0);
|
||||
assert(event.data == 1);
|
||||
assert(event.udata == TEST_UDATA);
|
||||
|
||||
afd = accept(lfd, NULL, NULL);
|
||||
assert(afd >= 0);
|
||||
|
||||
ctx->afd = afd;
|
||||
|
||||
rv = close(kq);
|
||||
assert(rv == 0);
|
||||
}
|
||||
|
||||
static void
|
||||
test_kqueue_read(test_context *ctx)
|
||||
{
|
||||
int afd = ctx->afd;
|
||||
int cfd = ctx->cfd;
|
||||
int kq;
|
||||
struct kevent change;
|
||||
struct kevent event;
|
||||
const struct timespec *timeout = NULL;
|
||||
int rv;
|
||||
ssize_t n;
|
||||
|
||||
puts("test kqueue read");
|
||||
|
||||
assert(afd >= 0);
|
||||
assert(cfd >= 0);
|
||||
|
||||
kq = kqueue();
|
||||
assert(kq >= 0);
|
||||
|
||||
EV_SET(&change, afd, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0,
|
||||
TEST_UDATA);
|
||||
|
||||
rv = kevent(kq, &change, 1, NULL, 0, timeout);
|
||||
assert(rv == 0);
|
||||
|
||||
ctx->wfd = cfd;
|
||||
ctx->wbuf = &msg[0];
|
||||
ctx->wn = sizeof(msg);
|
||||
send_events(ctx, EVENT_WRITE);
|
||||
|
||||
set_non_blocking(afd, 1);
|
||||
|
||||
errno = 0;
|
||||
n = read(afd, &ctx->buf[0], sizeof(ctx->buf));
|
||||
assert(n == -1);
|
||||
assert(errno == EAGAIN);
|
||||
|
||||
rv = kevent(kq, NULL, 0, &event, 1, timeout);
|
||||
assert(rv == 1);
|
||||
assert(event.ident == afd);
|
||||
assert(event.filter == EVFILT_READ);
|
||||
assert(event.flags == 0);
|
||||
assert(event.fflags == 0);
|
||||
assert(event.data == sizeof(msg));
|
||||
assert(event.udata == TEST_UDATA);
|
||||
|
||||
n = read(afd, &ctx->buf[0], sizeof(ctx->buf));
|
||||
assert(n == (ssize_t) sizeof(msg));
|
||||
assert(memcmp(&msg[0], &ctx->buf[0], sizeof(msg)) == 0);
|
||||
|
||||
rv = close(kq);
|
||||
assert(rv == 0);
|
||||
}
|
||||
|
||||
static void
|
||||
test_kqueue_write(test_context *ctx)
|
||||
{
|
||||
int afd = ctx->afd;
|
||||
int cfd = ctx->cfd;
|
||||
int kq;
|
||||
struct kevent change;
|
||||
struct kevent event;
|
||||
const struct timespec *timeout = NULL;
|
||||
int rv;
|
||||
ssize_t n;
|
||||
|
||||
puts("test kqueue write");
|
||||
|
||||
assert(afd >= 0);
|
||||
assert(cfd >= 0);
|
||||
|
||||
kq = kqueue();
|
||||
assert(kq >= 0);
|
||||
|
||||
EV_SET(&change, afd, EVFILT_WRITE, EV_ADD | EV_ENABLE, 0, 0,
|
||||
TEST_UDATA);
|
||||
|
||||
rv = kevent(kq, &change, 1, NULL, 0, timeout);
|
||||
assert(rv == 0);
|
||||
|
||||
ctx->rfd = cfd;
|
||||
ctx->rbuf = &ctx->buf[0];
|
||||
ctx->rn = sizeof(ctx->buf);
|
||||
send_events(ctx, EVENT_READ);
|
||||
|
||||
set_non_blocking(afd, 1);
|
||||
|
||||
do {
|
||||
errno = 0;
|
||||
n = write(afd, &ctx->buf[0], sizeof(ctx->buf));
|
||||
if (n == -1) {
|
||||
assert(errno == EAGAIN);
|
||||
}
|
||||
} while (n > 0);
|
||||
|
||||
rv = kevent(kq, NULL, 0, &event, 1, timeout);
|
||||
assert(rv == 1);
|
||||
assert(event.ident == afd);
|
||||
assert(event.filter == EVFILT_WRITE);
|
||||
assert(event.flags == 0);
|
||||
assert(event.fflags == 0);
|
||||
assert(event.data == 18432);
|
||||
assert(event.udata == TEST_UDATA);
|
||||
|
||||
n = write(afd, &ctx->buf[0], 1);
|
||||
assert(n == 1);
|
||||
|
||||
rv = close(kq);
|
||||
assert(rv == 0);
|
||||
}
|
||||
|
||||
static void
|
||||
test_kqueue_close(test_context *ctx)
|
||||
{
|
||||
int cfd = ctx->cfd;
|
||||
int kq;
|
||||
struct kevent change;
|
||||
struct kevent event;
|
||||
const struct timespec *timeout = NULL;
|
||||
int rv;
|
||||
ssize_t n;
|
||||
mode_t canrecv = S_IRUSR | S_IRGRP | S_IROTH;
|
||||
mode_t cansend = S_IWUSR | S_IWGRP | S_IWOTH;
|
||||
struct stat st;
|
||||
|
||||
puts("test kqueue close");
|
||||
|
||||
assert(ctx->cfd >= 0);
|
||||
|
||||
kq = kqueue();
|
||||
assert(kq >= 0);
|
||||
|
||||
EV_SET(&change, cfd, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0,
|
||||
TEST_UDATA);
|
||||
|
||||
rv = kevent(kq, &change, 1, NULL, 0, timeout);
|
||||
assert(rv == 0);
|
||||
|
||||
set_non_blocking(cfd, 1);
|
||||
|
||||
do {
|
||||
errno = 0;
|
||||
n = read(cfd, &ctx->buf[0], sizeof(ctx->buf));
|
||||
if (n == -1) {
|
||||
assert(errno == EAGAIN);
|
||||
}
|
||||
} while (n > 0);
|
||||
|
||||
/*
|
||||
* It is not allowed to close file descriptors still in use by
|
||||
* kevent(). On FreeBSD the file descriptor reference counting would
|
||||
* prevent this also.
|
||||
*/
|
||||
send_events(ctx, EVENT_SHUTDOWN);
|
||||
|
||||
rv = fstat(cfd, &st);
|
||||
assert(rv == 0);
|
||||
assert(st.st_mode == (S_IFSOCK | canrecv | cansend));
|
||||
|
||||
rv = kevent(kq, NULL, 0, &event, 1, timeout);
|
||||
assert(rv == 1);
|
||||
assert(event.ident == cfd);
|
||||
assert(event.filter == EVFILT_READ);
|
||||
assert(event.flags == EV_EOF);
|
||||
assert(event.fflags == 0);
|
||||
assert(event.data == 0);
|
||||
assert(event.udata == TEST_UDATA);
|
||||
|
||||
/*
|
||||
* The master task wakes up during the shutdown() operation. So we do
|
||||
* not see the full shutdown.
|
||||
*/
|
||||
rv = fstat(cfd, &st);
|
||||
assert(rv == 0);
|
||||
assert(st.st_mode == (S_IFSOCK | cansend));
|
||||
|
||||
rv = close(kq);
|
||||
assert(rv == 0);
|
||||
}
|
||||
|
||||
static void
|
||||
test_main(void)
|
||||
{
|
||||
test_context *ctx = &test_instance;
|
||||
|
||||
setup_lo0();
|
||||
set_self_prio(PRIO_MASTER);
|
||||
start_worker(ctx);
|
||||
create_server_socket(ctx);
|
||||
create_client_addr(ctx);
|
||||
|
||||
test_select_timeout(ctx);
|
||||
test_select_connect(ctx);
|
||||
test_select_read(ctx);
|
||||
test_select_write(ctx);
|
||||
test_select_close(ctx);
|
||||
|
||||
test_poll_timeout(ctx);
|
||||
test_poll_connect(ctx);
|
||||
test_poll_read(ctx);
|
||||
test_poll_write(ctx);
|
||||
test_poll_close(ctx);
|
||||
|
||||
test_kqueue_timer(false);
|
||||
test_kqueue_timer(true);
|
||||
test_kqueue_connect(ctx);
|
||||
test_kqueue_read(ctx);
|
||||
test_kqueue_write(ctx);
|
||||
test_kqueue_close(ctx);
|
||||
|
||||
rtems_stack_checker_report_usage_with_plugin(NULL,
|
||||
rtems_printf_plugin);
|
||||
|
||||
puts("*** END OF " TEST_NAME " TEST ***");
|
||||
exit(0);
|
||||
}
|
||||
|
||||
#include <rtems/bsd/test/default-init.h>
|
Loading…
x
Reference in New Issue
Block a user