static void sig_handler(int signal, siginfo_t *info, void *data)
{
uint32_t crc;
test_msg("signo=%d si_code=%x\n", signal, info->si_code);
if (test_go()) {
pr_perror("The signal is received before unlocking");
return;
}
switch (signal) {
case SIGCHLD:
if ((info->si_code & CLD_EXITED) &&
(info->si_pid == child) &&
(info->si_status == 5))
numsig++;
else {
fail("Wrong siginfo");
exit(1);
}
return;
}
if (TESTSIG == signal || THREADSIG == signal) {
siginfo_t *src;
if (signal == TESTSIG) {
src = &share_infos[share_nr];
share_nr++;
} else if (getpid() == syscall(SYS_gettid)) {
src = &self_infos[self_nr];
self_nr++;
} else {
src = &thread_infos[thread_nr];
thread_nr++;
}
crc = ~0;
if (datachk((uint8_t *) &info->_sifields,
sizeof(siginfo_t) - offsetof(siginfo_t, _sifields), &crc)) {
fail("CRC mismatch\n");
return;
}
if (memcmp(info, src, sizeof(siginfo_t))) {
fail("Source and received info are differ\n");
return;
}
numsig++;
return;
}
pr_perror("Unexpected signal");
exit(1);
}
int main(int argc, char *argv[])
{
int i;
test_init(argc, argv);
fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (fd<0){
pr_perror("socket");
goto out;
}
// setup local address & bind using
// this address
bzero(&la, sizeof(la));
la.nl_family = AF_NETLINK;
la.nl_pid = getpid();
if (bind(fd, (struct sockaddr*) &la, sizeof(la))){
pr_perror("bind failed");
goto out;
}
//Preperation:
form_request_del();
send_request();
recv_reply();
test_daemon();
while (test_go()){
for (i=0; i < CMD_NUM; i++){
cmd[i]();
if (send_request() < 0){
fail("send_request failed");
goto out;
};
if (recv_reply() < 0){
fail("RTNETLINK answers: %m");
goto out;
};
#ifdef DEBUG
if (read_reply() < 0){
fail("read_reply failed");
goto out;
}
#endif
}
}
pass();
out:
return 0;
}
void run_go(int argc, char **argv)
{
if(argc < 4){
fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
return;
}
char *cfg = argv[3];
char *weights = (argc > 4) ? argv[4] : 0;
int multi = find_arg(argc, argv, "-multi");
if(0==strcmp(argv[2], "train")) train_go(cfg, weights);
else if(0==strcmp(argv[2], "test")) test_go(cfg, weights, multi);
}
int main(int argc, char **argv)
{
void *mem;
int i, fail = 0;
unsigned rover = 1;
unsigned backup[MEM_PAGES] = {};
srand(time(NULL));
test_init(argc, argv);
mem = mmap(NULL, MEM_PAGES * PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, 0, 0);
if (mem == MAP_FAILED)
return 1;
test_msg("mem %p backup %p\n", mem, backup);
test_daemon();
while (test_go()) {
unsigned pfn;
struct timespec req = { .tv_sec = 0, .tv_nsec = 100000, };
pfn = random() % MEM_PAGES;
*(unsigned *)(mem + pfn * PAGE_SIZE) = rover;
backup[pfn] = rover;
test_msg("t %u %u\n", pfn, rover);
rover++;
nanosleep(&req, NULL);
}
test_waitsig();
test_msg("final rover %u\n", rover);
for (i = 0; i < MEM_PAGES; i++)
if (backup[i] != *(unsigned *)(mem + i * PAGE_SIZE)) {
test_msg("Page %u differs want %u has %u\n", i,
backup[i], *(unsigned *)(mem + i * PAGE_SIZE));
fail = 1;
} else
test_msg("Page %u matches %u\n", i, backup[i]);
if (fail)
fail("Memory corruption\n");
else
pass();
return 0;
}
int main(int argc, char **argv)
{
unsigned long data;
long delta;
int fd, fail = NR_FAILS, to_pass = NR_FAILS;
struct timeval start, end;
test_init(argc, argv);
fd = open("/dev/rtc", O_RDWR);
if (fd < 0) {
pr_perror("open");
return 1;
}
if (ioctl(fd, RTC_IRQP_SET, TEST_HZ) == -1) {
pr_perror("RTC_IRQP_SET");
return 1;
}
if (ioctl(fd, RTC_PIE_ON, 0) == -1) {
pr_perror("RTC_PIE_ON");
return 1;
}
test_daemon();
gettimeofday(&start, NULL);
start.tv_usec += start.tv_sec * 1000000;
while (test_go() || to_pass--) {
if (read(fd, &data, sizeof(unsigned long)) == -1)
return 1;
gettimeofday(&end, NULL);
end.tv_usec += end.tv_sec * 1000000;
delta = end.tv_usec - start.tv_usec;
if (labs(delta - 1000000 / TEST_HZ ) > 100000) {
pr_perror("delta = %ld", delta);
fail--;
if (fail == 0)
return 1;
}
start = end;
}
pass();
return 0;
}
void run_go(int argc, char **argv)
{
//boards_go();
if(argc < 4){
fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
return;
}
char *cfg = argv[3];
char *weights = (argc > 4) ? argv[4] : 0;
char *c2 = (argc > 5) ? argv[5] : 0;
char *w2 = (argc > 6) ? argv[6] : 0;
int multi = find_arg(argc, argv, "-multi");
if(0==strcmp(argv[2], "train")) train_go(cfg, weights);
else if(0==strcmp(argv[2], "valid")) valid_go(cfg, weights, multi);
else if(0==strcmp(argv[2], "self")) self_go(cfg, weights, c2, w2, multi);
else if(0==strcmp(argv[2], "test")) test_go(cfg, weights, multi);
else if(0==strcmp(argv[2], "engine")) engine_go(cfg, weights, multi);
}
int main(int argc, char ** argv)
{
char *mem, *org, *m;
int count;
test_init(argc, argv);
/* we presume that malloc returns not page aliged address */
mem = malloc(PAGE_SIZE * N_PAGES);
org = malloc(PAGE_SIZE);
if (!mem || !org) {
fail("malloc failed\n");
exit(1);
}
memset(mem, 0x42, PAGE_SIZE * N_PAGES);
memset(org, 0x42, PAGE_SIZE);
test_daemon();
while (test_go()) {
for (count = 0; count < N_PAGES; count += 2) {
m = mem + (count * PAGE_SIZE) + 128;
*m = count;
}
for (count = 0; count < N_PAGES; count++) {
m = mem+(count*PAGE_SIZE);
org[128] = (count % 2 == 0) ? count : 0x42;
if (memcmp(org, m, PAGE_SIZE)) {
fail("memory corruption\n");
return 1;
}
}
sleep(1);
}
pass();
return 0;
}
static int child(key_t key)
{
int sem, shm, ret, res = 0;
uint8_t *mem;
uint32_t crc;
sem = semget(key, 1, 0777);
if (sem == -1)
return -1;
shm = shmget(key, shmem_size, 0777);
if (shm == -1)
return -2;
mem = shmat(shm, NULL, 0);
if (mem == (uint8_t *)-1)
return -3;
while (test_go()) {
ret = semop(sem, &lock, 1);
if (ret) {
if (errno == EINTR)
continue;
fail("Error in semop lock");
res = errno;
break;
}
crc = INIT_CRC;
datagen(mem, shmem_size, &crc);
while ((ret = semop(sem, &unlock, 1)) && (errno == EINTR));
if (ret) {
fail("Error in semop unlock");
res = errno;
break;
}
}
shmdt(mem);
return res;
}
int main(int argc, char **argv)
{
int fd, fd_s, ctl_fd;
pid_t extpid;
int pfd[2];
int sk_bsize;
int ret, snd, snd_size, rcv_size = 0, rcv_buf_size;
#ifdef ZDTM_TCP_LOCAL
test_init(argc, argv);
#endif
if (pipe(pfd)) {
pr_perror("pipe() failed");
return 1;
}
extpid = fork();
if (extpid < 0) {
pr_perror("fork() failed");
return 1;
} else if (extpid == 0) {
int size;
char c;
#ifndef ZDTM_TCP_LOCAL
test_ext_init(argc, argv);
#endif
close(pfd[1]);
read_safe(pfd[0], &port, sizeof(port));
fd = tcp_init_client(ZDTM_FAMILY, "127.0.0.1", port);
if (fd < 0)
return 1;
ctl_fd = tcp_init_client(ZDTM_FAMILY, "127.0.0.1", port);
if (fd < 0)
return 1;
snd_size = fill_sock_buf(fd);
if (snd_size <= 0)
return 1;
write_safe(ctl_fd, &snd_size, sizeof(snd_size));
read_safe(ctl_fd, &rcv_buf_size, sizeof(rcv_buf_size));
while (1) {
/* heart beat */
read_safe(ctl_fd, &ret, sizeof(ret));
if (ret < 0)
break;
rcv_buf_size += ret;
snd = fill_sock_buf(fd);
if (snd < 0)
return -1;
snd_size += snd;
if (rcv_buf_size / 2) {
ret = clean_sk_buf(fd, rcv_buf_size / 2);
if (ret <= 0)
return 1;
} else
ret = 0;
rcv_buf_size -= ret;
rcv_size += ret;
write_safe(ctl_fd, &snd, sizeof(snd));
}
read_safe(ctl_fd, &ret, sizeof(ret));
rcv_buf_size += ret;
write_safe(ctl_fd, &snd_size, sizeof(snd_size));
if (read(ctl_fd, &c, 1) != 0) {
pr_perror("read");
return 1;
}
if (shutdown(fd, SHUT_WR) == -1) {
pr_perror("shutdown");
return 1;
}
size = clean_sk_buf(fd, 0);
if (size < 0)
return 1;
if (size != rcv_buf_size) {
fail("the received buffer contains only %d bytes (%d)\n", size, rcv_buf_size);
}
rcv_size += size;
write_safe(ctl_fd, &rcv_size, sizeof(rcv_size));
close(fd);
return 0;
}
#ifndef ZDTM_TCP_LOCAL
test_init(argc, argv);
#endif
if ((fd_s = tcp_init_server(ZDTM_FAMILY, &port)) < 0) {
pr_perror("initializing server failed");
return 1;
}
close(pfd[0]);
write_safe(pfd[1], &port, sizeof(port));
close(pfd[1]);
/*
* parent is server of TCP connection
*/
fd = tcp_accept_server(fd_s);
if (fd < 0) {
pr_perror("can't accept client connection %m");
return 1;
}
ctl_fd = tcp_accept_server(fd_s);
if (ctl_fd < 0) {
pr_perror("can't accept client connection %m");
return 1;
}
sk_bsize = TCP_MAX_BUF;
if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF,
&sk_bsize, sizeof(sk_bsize)) == -1) {
pr_perror("Can't set snd buf");
return 1;
}
sk_bsize = TCP_MAX_BUF;
if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF,
&sk_bsize, sizeof(sk_bsize)) == -1) {
pr_perror("Can't set snd buf");
return 1;
}
snd_size = fill_sock_buf(fd);
if (snd_size <= 0)
return 1;
read_safe(ctl_fd, &rcv_buf_size, sizeof(rcv_buf_size));
write_safe(ctl_fd, &snd_size, sizeof(snd_size));
test_daemon();
snd = 0;
while (test_go()) {
/* heart beat */
if (rcv_buf_size / 2) {
ret = clean_sk_buf(fd, rcv_buf_size / 2);
if (ret <= 0)
return 1;
} else
ret = 0;
rcv_size += ret;
rcv_buf_size -= ret;
write_safe(ctl_fd, &snd, sizeof(snd));
read_safe(ctl_fd, &ret, sizeof(ret));
rcv_buf_size += ret;
snd = fill_sock_buf(fd);
if (snd < 0)
return -1;
snd_size += snd;
}
ret = -1;
write_safe(ctl_fd, &ret, sizeof(ret));
write_safe(ctl_fd, &snd, sizeof(ret));
read_safe(ctl_fd, &snd, sizeof(snd));
if (shutdown(ctl_fd, SHUT_WR) == -1) {
pr_perror("shutdown");
return 1;
}
if (shutdown(fd, SHUT_WR) == -1) {
pr_perror("shutdown");
return 1;
}
ret = clean_sk_buf(fd, 0);
if (ret != rcv_buf_size) {
fail("the received buffer contains only %d bytes (%d)\n", ret, rcv_buf_size);
}
rcv_size += ret;
if (snd != rcv_size) {
fail("The child sent %d bytes, but the parent received %d bytes\n", rcv_buf_size, rcv_size);
return 1;
}
read_safe(ctl_fd, &ret, sizeof(ret));
if (ret != snd_size) {
fail("The parent sent %d bytes, but the child received %d bytes\n", snd_size, ret);
return 1;
}
pass();
return 0;
}
int main(int argc, char **argv)
{
int ret = 0;
int readfd, writefd;
mode_t mode = S_IFIFO | 0600;
char path[PROCS_DEF][BUF_SIZE];
pid_t pid;
int i;
uint8_t buf[0x100000];
int chret;
char *file_path;
test_init(argc, argv);
for (i = 0; i < PROCS_DEF; i++) {
file_path = path[i];
if (snprintf(file_path, BUF_SIZE, "%s-%02d", filename, i) >= BUF_SIZE) {
pr_perror("filename %s is too long", filename);
exit(1);
}
if (mkfifo(file_path, mode)) {
pr_perror("can't make fifo \"%s\"", file_path);
exit(1);
}
}
pid = test_fork();
if (pid < 0) {
pr_perror("Can't fork");
kill(0, SIGKILL);
exit(1);
}
if (pid == 0) {
file_path = path[0];
readfd = open(file_path, O_RDONLY);
if (readfd < 0) {
pr_perror("open(%s, O_RDONLY) Failed", file_path);
ret = errno;
return ret;
}
file_path = path[1];
writefd = open(file_path, O_WRONLY);
if (writefd < 0) {
pr_perror("open(%s, O_WRONLY) Failed", file_path);
ret = errno;
return ret;
}
if (pipe_in2out(readfd, writefd, buf, sizeof(buf)) < 0)
/* pass errno as exit code to the parent */
if (test_go() /* signal NOT delivered */ ||
(errno != EINTR && errno != EPIPE))
ret = errno;
close(readfd);
close(writefd);
exit(ret);
}
file_path = path[0];
writefd = open(file_path, O_WRONLY);
if (writefd < 0) {
pr_perror("open(%s, O_WRONLY) Failed", file_path);
kill(pid, SIGKILL);
return 1;
}
file_path = path[1];
readfd = open(file_path, O_RDONLY);
if (readfd < 0) {
pr_perror("open(%s, O_RDONLY) Failed", file_path);
kill(pid, SIGKILL);
return 1;
}
test_daemon();
while (test_go()) {
int len, rlen = 0, wlen;
uint8_t rbuf[sizeof(buf)], *p;
datagen(buf, sizeof(buf), NULL);
wlen = write(writefd, buf, sizeof(buf));
if (wlen < 0) {
if (errno == EINTR)
continue;
else {
fail("write failed: %m\n");
ret = 1;
break;
}
}
for (p = rbuf, len = wlen; len > 0; p += rlen, len -= rlen) {
rlen = read(readfd, p, len);
if (rlen <= 0)
break;
}
if (rlen < 0 && errno == EINTR)
continue;
if (len > 0) {
fail("read failed: %m\n");
ret = 1;
break;
}
if (memcmp(buf, rbuf, wlen)) {
fail("data mismatch\n");
ret = 1;
break;
}
}
close(writefd);
test_waitsig();
wait(&chret);
chret = WEXITSTATUS(chret);
if (chret) {
fail("child exited with non-zero code %d (%s)\n",
chret, strerror(chret));
return 1;
}
if (!ret)
pass();
close(readfd);
for (i = 0; i < PROCS_DEF; i++)
unlink(path[i]);
return 0;
}
static int test_fn(int argc, char **argv)
{
key_t key;
int sem, shm, pid1, pid2;
int fail_count = 0;
uint8_t *mem;
uint32_t crc;
int ret;
key = ftok(argv[0], 822155650);
if (key == -1) {
pr_perror("Can't make key");
goto out;
}
sem = semget(key, 1, 0777 | IPC_CREAT | IPC_EXCL);
if (sem == -1) {
pr_perror("Can't get sem");
goto out;
}
if (semctl(sem, 0, SETVAL, 1) == -1) {
pr_perror("Can't init sem");
fail_count++;
goto out_sem;
}
shm = shmget(key, shmem_size, 0777 | IPC_CREAT | IPC_EXCL);
if (shm == -1) {
pr_perror("Can't get shm");
fail_count++;
goto out_sem;
}
mem = shmat(shm, NULL, 0);
if (mem == (void *)-1) {
pr_perror("Can't attach shm");
fail_count++;
goto out_shm;
}
poison_area((int *)mem);
pid1 = test_fork();
if (pid1 == -1) {
pr_perror("Can't fork 1st time");
goto out_shdt;
} else if (pid1 == 0)
exit(child(key));
pid2 = test_fork();
if (pid2 == -1) {
pr_perror("Can't fork 2nd time");
fail_count++;
goto out_child;
} else if (pid2 == 0)
exit(child(key));
test_daemon();
while (test_go()) {
ret = semop(sem, &lock, 1);
if (ret) {
if (errno == EINTR)
continue;
fail_count++;
fail("Error in semop lock");
break;
}
if (mem[0] != POISON) {
crc = INIT_CRC;
if (datachk(mem, shmem_size, &crc)) {
fail_count++;
fail("Semaphore protection is broken or "
"shmem pages are messed");
semop(sem, &unlock, 1);
break;
}
poison_area((int *)mem);
}
while ((ret = semop(sem, &unlock, 1)) && (errno == EINTR));
if (ret) {
fail_count++;
fail("Error in semop unlock");
break;
}
}
test_waitsig();
kill(pid2, SIGTERM);
waitpid(pid2, &ret, 0);
if (!WIFEXITED(ret)) {
fail_count++;
pr_perror("Child 2 was killed");
} else if (WEXITSTATUS(ret)) {
fail_count++;
pr_perror("Child 2 couldn't inititalise");
}
out_child:
kill(pid1, SIGTERM);
waitpid(pid1, &ret, 0);
if (!WIFEXITED(ret)) {
fail_count++;
pr_perror("Child 1 was killed");
} else if (WEXITSTATUS(ret)) {
fail_count++;
pr_perror("Child 1 couldn't inititalise");
}
out_shdt:
shmdt(mem);
out_shm:
shmctl(shm, IPC_RMID, NULL);
out_sem:
semctl(sem, 1, IPC_RMID);
if (fail_count == 0)
pass();
out:
return 0;
}
int main(int argc, char **argv)
{
unsigned char buf[BUF_SIZE];
int fd, fd_s;
pid_t extpid;
uint32_t crc;
int pfd[2];
int val;
socklen_t optlen;
if (pipe(pfd)) {
err("pipe() failed");
return 1;
}
extpid = fork();
if (extpid < 0) {
err("fork() failed");
return 1;
} else if (extpid == 0) {
test_ext_init(argc, argv);
close(pfd[1]);
if (read(pfd[0], &port, sizeof(port)) != sizeof(port)) {
err("Can't read port\n");
return 1;
}
fd = tcp_init_client(ZDTM_FAMILY, "localhost", port);
if (fd < 0)
return 1;
#ifdef STREAM
while (1) {
if (read_data(fd, buf, BUF_SIZE)) {
err("read less then have to");
return 1;
}
if (datachk(buf, BUF_SIZE, &crc))
return 2;
datagen(buf, BUF_SIZE, &crc);
if (write_data(fd, buf, BUF_SIZE)) {
err("can't write");
return 1;
}
}
#else
if (read_data(fd, buf, BUF_SIZE)) {
err("read less then have to");
return 1;
}
if (datachk(buf, BUF_SIZE, &crc))
return 2;
datagen(buf, BUF_SIZE, &crc);
if (write_data(fd, buf, BUF_SIZE)) {
err("can't write");
return 1;
}
#endif
return 0;
}
test_init(argc, argv);
if ((fd_s = tcp_init_server(ZDTM_FAMILY, &port)) < 0) {
err("initializing server failed");
return 1;
}
close(pfd[0]);
if (write(pfd[1], &port, sizeof(port)) != sizeof(port)) {
err("Can't send port");
return 1;
}
close(pfd[1]);
/*
* parent is server of TCP connection
*/
fd = tcp_accept_server(fd_s);
if (fd < 0) {
err("can't accept client connection %m");
return 1;
}
val = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val))) {
err("setsockopt");
return 1;
}
test_daemon();
#ifdef STREAM
while (test_go()) {
datagen(buf, BUF_SIZE, &crc);
if (write_data(fd, buf, BUF_SIZE)) {
err("can't write");
return 1;
}
if (read_data(fd, buf, BUF_SIZE)) {
err("read less then have to");
return 1;
}
if (datachk(buf, BUF_SIZE, &crc))
return 2;
}
kill(extpid, SIGKILL);
#else
test_waitsig();
datagen(buf, BUF_SIZE, &crc);
if (write_data(fd, buf, BUF_SIZE)) {
err("can't write");
return 1;
}
if (read_data(fd, buf, BUF_SIZE)) {
err("read less then have to");
return 1;
}
if (datachk(buf, BUF_SIZE, &crc))
return 2;
#endif
optlen = sizeof(val);
if (getsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, &optlen)) {
err("getsockopt");
return 1;
}
if (val != 1) {
fail("SO_REUSEADDR are not set for %d\n", fd);
return 1;
}
pass();
return 0;
}
int main(int argc, char **argv)
{
int pid, wpid, status;
int p[2];
test_init(argc, argv);
if (pipe(p)) {
err("pipe");
return -1;
}
if (write(p[1], children, sizeof(children)) != sizeof(children)) {
err("write");
return -1;
}
test_daemon();
while (test_go()) {
char c = 0;
int ret;
ret = read(p[0], &children, sizeof(children));
if (ret <= 0) {
err("read");
return 1;
}
for (; ret > 0; ret--) {
pid = fork();
if (pid < 0) {
fail("Can't fork");
goto out;
}
if (pid == 0) {
#ifdef FORK2
usleep(10000);
#endif
if (write(p[1], &c, 1) != 1) {
err("write");
return 1;
}
exit(0);
}
}
while (1) {
wpid = waitpid(-1, &status, WNOHANG);
if (wpid < 0) {
if (errno == ECHILD)
break;
err("waitpid");
return -1;
}
if (wpid == 0)
break;
if (!WIFEXITED(status)) {
fail("Task %d didn't exit", wpid);
goto out;
}
if (WEXITSTATUS(status) != 0) {
fail("Task %d exited with wrong code", wpid);
goto out;
}
}
}
pass();
out:
return 0;
}
int main(int argc, char **argv)
{
test_init(argc, argv);
char buf[BUF_SIZE];
int fd;
struct aiocb aiocb;
const struct aiocb *aioary[1];
char tmpfname[256]="/tmp/file_aio.XXXXXX";
int ret;
fd = mkstemp(tmpfname);
if (fd == -1) {
err("Error at open(): %s", strerror(errno));
exit(1);
}
unlink(tmpfname);
if (write(fd, buf, BUF_SIZE) != BUF_SIZE) {
err("Error at write(): %s",
strerror(errno));
exit(1);
}
test_daemon();
while (test_go()) {
memset(&aiocb, 0, sizeof(struct aiocb));
aiocb.aio_offset = 0;
aiocb.aio_fildes = fd;
aiocb.aio_buf = buf;
aiocb.aio_nbytes = BUF_SIZE;
ret = aio_read(&aiocb);
if (ret < 0) {
if ((errno == EINTR) && (!test_go()))
break;
err("aio_read failed %m");
return 1;
}
if (ret < 0) {
err("aio_read failed %s\n", strerror(errno));
exit(1);
}
/* Wait for request completion */
aioary[0] = &aiocb;
again:
ret = aio_suspend(aioary, 1, NULL);
if (ret < 0) {
if ((errno == EINTR) && (! test_go()))
break;
if (errno != EINTR) {
err("aio_suspend failed %m");
return 1;
}
}
ret = aio_error(&aiocb);
if (ret == EINPROGRESS) {
#ifdef DEBUG
test_msg("restart aio_suspend\n");
#endif
goto again;
}
if (ret != 0) {
err("Error at aio_error() %s", strerror(ret));
return 1;
}
ret = aio_return(&aiocb);
if (ret < 0) {
if ((errno == EINTR) && (!test_go()))
break;
err("aio_return failed %m");
return 1;
}
if (ret != BUF_SIZE) {
err("Error at aio_return()\n");
exit(1);
}
}
close(fd);
pass();
return 0;
}
int main(int argc, char **argv)
{
int ret = 0;
int readfd, writefd;
mode_t mode = S_IFIFO | 0644;
char path[PROCS_DEF][BUF_SIZE];
pid_t pid;
int i;
uint8_t buf[0x100000];
char *file_path;
test_init(argc, argv);
for (i = 0; i < PROCS_DEF; i++) {
file_path = path[i];
if (snprintf(file_path, BUF_SIZE, "%s-%02d", filename, i) >= BUF_SIZE) {
err("filename %s is too long\n", filename);
exit(1);
}
if (mkfifo(file_path, mode)) {
err("can't make fifo \"%s\": %m\n", file_path);
exit(1);
}
}
if (signal(SIGCHLD, inc_num_exited) == SIG_ERR) {
err("can't set SIGCHLD handler: %m\n");
exit(1);
}
for (i = 1; i < num_procs; i++) { /* i = 0 - parent */
pid = test_fork();
if (pid < 0) {
err("Can't fork: %m\n");
kill(0, SIGKILL);
exit(1);
}
if (pid == 0) {
file_path = path[i - 1];
readfd = open(file_path, O_RDONLY);
if (readfd < 0) {
err("open(%s, O_RDONLY) Failed: %m\n",
file_path);
ret = errno;
return ret;
}
file_path = path[i];
writefd = open(file_path, O_WRONLY);
if (writefd < 0) {
err("open(%s, O_WRONLY) Failed: %m\n",
file_path);
ret = errno;
return ret;
}
signal(SIGPIPE, SIG_IGN);
if (pipe_in2out(readfd, writefd, buf, sizeof(buf)) < 0)
/* pass errno as exit code to the parent */
if (test_go() /* signal NOT delivered */ ||
(errno != EINTR && errno != EPIPE))
ret = errno;
close(readfd);
close(writefd);
exit(ret);
}
pids[i] = pid;
}
file_path = path[0];
writefd = open(file_path, O_WRONLY);
if (writefd < 0) {
err("open(%s, O_WRONLY) Failed: %m\n", file_path);
kill(0, SIGKILL);
exit(1);
}
file_path = path[i - 1];
readfd = open(file_path, O_RDONLY);
if (readfd < 0) {
err("open(%s, O_RDONLY) Failed: %m\n", file_path);
kill(0, SIGKILL);
exit(1);
}
if (num_exited) {
err("Some children died unexpectedly\n");
kill(0, SIGKILL);
exit(1);
}
test_daemon();
while (test_go()) {
int len, rlen = 0, wlen;
uint8_t rbuf[sizeof(buf)], *p;
datagen(buf, sizeof(buf), NULL);
wlen = write(writefd, buf, sizeof(buf));
if (wlen < 0) {
if (errno == EINTR)
continue;
else {
fail("write failed: %m\n");
ret = 1;
break;
}
}
for (p = rbuf, len = wlen; len > 0; p += rlen, len -= rlen) {
rlen = read(readfd, p, len);
if (rlen <= 0)
break;
}
if (rlen < 0 && errno == EINTR)
continue;
if (len > 0) {
fail("read failed: %m\n");
ret = 1;
break;
}
if (memcmp(buf, rbuf, wlen)) {
fail("data mismatch\n");
ret = 1;
break;
}
}
close(writefd);
test_waitsig(); /* even if failed, wait for migration to complete */
if (kill(0, SIGTERM)) {
fail("failed to send SIGTERM to my process group: %m\n");
return 1; /* shouldn't wait() in this case */
}
close(readfd);
for (i = 1; i < num_procs; i++) { /* i = 0 - parent */
int chret;
if (waitpid(pids[i], &chret, 0) < 0) {
fail("waitpid error: %m\n");
ret = 1;
continue;
}
chret = WEXITSTATUS(chret);
if (chret) {
fail("child %d exited with non-zero code %d (%s)\n",
i, chret, strerror(chret));
ret = 1;
continue;
}
}
if (!ret)
pass();
for (i = 0; i < PROCS_DEF; i++)
unlink(path[i]);
return 0;
}
int main(int argc, char ** argv)
{
int pipe1[2];
int pipe2[2];
int ret;
pid_t pid;
char buf[sizeof(TEST_STRING)];
test_init(argc, argv);
ret = pipe(pipe1);
if (ret)
return 1;
ret = pipe(pipe2);
if (ret)
return 1;
pid = test_fork();
if (pid < 0) {
err("Can't fork");
exit(1);
} else if (pid == 0) {
if (dup2(pipe1[1], 11) == -1 || dup2(pipe2[0], 12) == -1) {
err("dup2 failed");
return 1;
}
} else {
if (dup2(pipe1[0], 12) == -1 || dup2(pipe2[1], 11) == -1) {
err("dup2 failed");
goto err;
}
}
close(pipe2[0]);
close(pipe2[1]);
close(pipe1[0]);
close(pipe1[1]);
if (pid > 0) {
int status;
test_daemon();
while (test_go())
;
ret = read(12, buf, sizeof(TEST_STRING));
if (ret != sizeof(TEST_STRING)) {
err("read failed: %d", ret);
goto err;
}
ret = write(11, TEST_STRING, sizeof(TEST_STRING));
if (ret != sizeof(TEST_STRING)) {
err("write failed: %d", ret);
goto err;
}
close(11);
ret = read(12, buf, sizeof(TEST_STRING));
if (ret != sizeof(TEST_STRING)) {
err("read failed: %d", ret);
goto err;
}
if (strcmp(TEST_STRING, buf)) {
err("data curruption");
goto err;
}
ret = wait(&status);
if (ret == -1 || !WIFEXITED(status) || WEXITSTATUS(status)) {
kill(pid, SIGKILL);
goto err;
}
pass();
} else {
ret = write(11, TEST_STRING, sizeof(TEST_STRING));
if (ret != sizeof(TEST_STRING)) {
err("write failed: %d", ret);
return 1;
}
ret = read(12, buf, sizeof(TEST_STRING));
if (ret != sizeof(TEST_STRING)) {
err("read failed: %d", ret);
return 1;
}
ret = write(11, TEST_STRING, sizeof(TEST_STRING));
if (ret != sizeof(TEST_STRING)) {
err("write failed: %d", ret);
return 1;
}
close(11);
if (strcmp(TEST_STRING, buf)) {
err("data curruption");
return 1;
}
}
return 0;
err:
err("FAIL");
return 1;
}
int main(int argc, char **argv)
{
int ret = 0;
pid_t pid;
int i;
uint8_t buf[0x100000];
int socks[PROCS_MAX * 2];
int in, out;
test_init(argc, argv);
if (num_procs > PROCS_MAX) {
err("%d processes is too many: max = %d\n", num_procs, PROCS_MAX);
exit(1);
}
for (i = 0; i < num_procs; i++)
if (socketpair(AF_LOCAL, SOCK_STREAM, 0, socks + i * 2)) {
err("Can't create socks: %m\n");
exit(1);
}
if (signal(SIGCHLD, inc_num_exited) == SIG_ERR) {
err("can't set SIGCHLD handler: %m\n");
exit(1);
}
for (i = 1; i < num_procs; i++) { /* i = 0 - parent */
pid = test_fork();
if (pid < 0) {
err("Can't fork: %m\n");
kill(0, SIGKILL);
exit(1);
}
if (pid == 0) {
int j;
in = i * 2;
out = in - 1;
for (j = 0; j < num_procs * 2; j++)
if (j != in && j != out)
close(socks[j]);
signal(SIGPIPE, SIG_IGN);
if (pipe_in2out(socks[in], socks[out], buf, sizeof(buf)) < 0)
/* pass errno as exit code to the parent */
if (test_go() /* signal NOT delivered */ ||
(errno != EINTR && errno != EPIPE
&& errno != ECONNRESET))
ret = errno;
test_waitsig(); /* even if failed, wait for migration to complete */
close(socks[in]);
close(socks[out]);
exit(ret);
}
}
for (i = 1; i < num_procs * 2 - 1; i++)
close(socks[i]);
in = socks[0];
out = socks[num_procs * 2 - 1];
/* don't block on writing, _do_ block on reading */
if (set_nonblock(out,1) < 0) {
err("setting O_NONBLOCK failed: %m");
exit(1);
}
if (num_exited) {
err("Some children died unexpectedly\n");
kill(0, SIGKILL);
exit(1);
}
test_daemon();
while (test_go()) {
int len, rlen = 0, wlen;
uint8_t rbuf[sizeof(buf)], *p;
datagen(buf, sizeof(buf), NULL);
wlen = write(out, buf, sizeof(buf));
if (wlen < 0) {
if (errno == EINTR)
continue;
else {
fail("write failed: %m\n", i);
ret = 1;
break;
}
}
for (p = rbuf, len = wlen; len > 0; p += rlen, len -= rlen) {
rlen = read(in, p, len);
if (rlen <= 0)
break;
}
if (rlen < 0 && errno == EINTR)
continue;
if (len > 0) {
fail("read failed: %m\n");
ret = 1;
break;
}
if (memcmp(buf, rbuf, wlen)) {
fail("data mismatch\n");
ret = 1;
break;
}
}
test_waitsig(); /* even if failed, wait for migration to complete */
/* We expect that write(2) in child may return error only after signal
* has been received. Thus, send signal before closing parent fds.
*/
if (kill(0, SIGTERM)) {
fail("failed to send SIGTERM to my process group: %m\n");
goto out; /* shouldn't wait() in this case */
}
if (close(out))
fail("Failed to close parent fd 'out': %m\n");
/* If last child in the chain (from whom we read data) receives signal
* after parent has finished reading but before calling write(2), this
* child can block forever. To avoid this, close 'in' fd.
*/
if (close(in))
fail("failed to close parent fd 'in': %m\n");
for (i = 1; i < num_procs; i++) { /* i = 0 - parent */
int chret;
if (wait(&chret) < 0) {
fail("can't wait for a child: %m\n");
ret = 1;
continue;
}
chret = WEXITSTATUS(chret);
if (chret) {
fail("child %d exited with non-zero code %d (%s)\n",
i, chret, strerror(chret));
ret = 1;
continue;
}
}
if (!ret)
pass();
out:
return 0;
}
int main(int argc, char **argv)
{
int ret = 0;
pid_t pid;
int i;
uint8_t buf[0x100000];
int pipes[PROCS_MAX * 2];
int in, out;
test_init(argc, argv);
if (num_procs > PROCS_MAX) {
err("%d processes is too many: max = %d\n", num_procs, PROCS_MAX);
exit(1);
}
for (i = 0; i < num_procs; i++)
if (pipe(pipes + i * 2)) {
err("Can't create pipes: %m\n");
exit(1);
}
if (signal(SIGCHLD, inc_num_exited) == SIG_ERR) {
err("can't set SIGCHLD handler: %m\n");
exit(1);
}
for (i = 1; i < num_procs; i++) { /* i = 0 - parent */
pid = test_fork();
if (pid < 0) {
err("Can't fork: %m\n");
kill(0, SIGKILL);
exit(1);
}
if (pid == 0) {
int j;
in = i * 2;
out = in - 1;
for (j = 0; j < num_procs * 2; j++)
if (j != in && j != out)
close(pipes[j]);
signal(SIGPIPE, SIG_IGN);
if (pipe_in2out(pipes[in], pipes[out], buf, sizeof(buf)) < 0)
/* pass errno as exit code to the parent */
if (test_go() /* signal NOT delivered */ ||
(errno != EINTR && errno != EPIPE))
ret = errno;
test_waitsig(); /* even if failed, wait for migration to complete */
close(pipes[in]);
close(pipes[out]);
exit(ret);
}
}
for (i = 1; i < num_procs * 2 - 1; i++)
close(pipes[i]);
in = pipes[0];
out = pipes[num_procs * 2 - 1];
/* don't block on writing, _do_ block on reading */
if (set_nonblock(out,1) < 0) {
err("setting O_NONBLOCK failed: %m");
exit(1);
}
if (num_exited) {
err("Some children died unexpectedly\n");
kill(0, SIGKILL);
exit(1);
}
test_daemon();
while (test_go()) {
int len, rlen = 0, wlen;
uint8_t rbuf[sizeof(buf)], *p;
datagen(buf, sizeof(buf), NULL);
wlen = write(out, buf, sizeof(buf));
if (wlen < 0) {
if (errno == EINTR)
continue;
else {
fail("write failed: %m\n", i);
ret = 1;
break;
}
}
for (p = rbuf, len = wlen; len > 0; p += rlen, len -= rlen) {
rlen = read(in, p, len);
if (rlen <= 0)
break;
}
if (rlen < 0 && errno == EINTR)
continue;
if (len > 0) {
fail("read failed: %m\n");
ret = 1;
break;
}
if (memcmp(buf, rbuf, wlen)) {
fail("data mismatch\n");
ret = 1;
break;
}
}
close(out);
test_waitsig(); /* even if failed, wait for migration to complete */
if (kill(0, SIGTERM)) {
fail("failed to send SIGTERM to my process group: %m\n");
goto out; /* shouldn't wait() in this case */
}
for (i = 1; i < num_procs; i++) { /* i = 0 - parent */
int chret;
if (wait(&chret) < 0) {
fail("can't wait for a child: %m\n");
ret = 1;
continue;
}
chret = WEXITSTATUS(chret);
if (chret) {
fail("child %d exited with non-zero code %d (%s)\n",
i, chret, strerror(chret));
ret = 1;
continue;
}
}
if (!ret)
pass();
out:
close(in);
return 0;
}
int main(int argc, char **argv)
{
int ret = 0;
pid_t pid;
int i;
uint8_t buf[PIPE_BUF * 100];
int pipes[2];
test_init(argc, argv);
if (num_procs > PROCS_MAX) {
pr_err("%d processes is too many: max = %d\n", num_procs, PROCS_MAX);
exit(1);
}
if (pipe(pipes)) {
pr_perror("Can't create pipes");
exit(1);
}
if (signal(SIGCHLD, inc_num_exited) == SIG_ERR) {
pr_perror("can't set SIGCHLD handler");
exit(1);
}
for (i = 1; i < num_procs; i++) { /* i = 0 - parent */
pid = test_fork();
if (pid < 0) {
pr_perror("can't fork");
kill(0, SIGKILL);
exit(1);
}
if (pid == 0) {
close(pipes[1]);
while (test_go()) {
int rlen = read(pipes[0], buf, sizeof(buf));
if (rlen == 0)
break;
else if (rlen < 0) {
ret = errno; /* pass errno as exit code to the parent */
break;
}
for (i = 0; i < rlen && buf[i] == SND_CHR; i++)
;
if (i < rlen) {
ret = EILSEQ;
break;
}
}
test_waitsig(); /* even if failed, wait for migration to complete */
close(pipes[0]);
exit(ret);
}
}
close(pipes[0]);
if (num_exited) {
pr_err("Some children died unexpectedly\n");
kill(0, SIGKILL);
exit(1);
}
test_daemon();
memset(buf, SND_CHR, sizeof(buf));
while(test_go())
if (write(pipes[1], buf, sizeof(buf)) < 0 &&
(errno != EINTR || test_go())) { /* only SIGTERM may stop us */
fail("write failed: %m\n");
ret = 1;
break;
}
close(pipes[1]);
test_waitsig(); /* even if failed, wait for migration to complete */
if (kill(0, SIGTERM)) {
fail("failed to send SIGTERM to my process group: %m\n");
goto out; /* shouldn't wait() in this case */
}
for (i = 1; i < num_procs; i++) { /* i = 0 - parent */
int chret;
if (wait(&chret) < 0) {
fail("can't wait for a child: %m\n");
ret = 1;
continue;
}
chret = WEXITSTATUS(chret);
if (chret) {
fail("child exited with non-zero code %d (%s)\n",
chret, strerror(chret));
ret = 1;
continue;
}
}
if (!ret)
pass();
out:
return 0;
}
