int main(int argc, char *argv[])
{
char buf[sizeof(teststr)];
int master, slave, ret;
char *slavename;
task_waiter_t t;
pid_t pid;
test_init(argc, argv);
master = open("/dev/ptmx", O_RDWR);
if (master == -1) {
err("open(%s) failed", "/dev/ptmx");
return 1;
}
grantpt(master);
unlockpt(master);
slavename = ptsname(master);
slave = open(slavename, O_RDWR);
if (slave == -1) {
err("open(%s) failed", slavename);
return 1;
}
task_waiter_init(&t);
pid = test_fork();
if (pid == 0) {
int new_master, ret;
new_master = dup(master);
if (new_master < 0) {
err("can't dup master\n");
exit_shot_parent(1);
}
task_waiter_complete_current(&t);
ret = write(new_master, teststr, sizeof(teststr) - 1);
if (ret != sizeof(teststr) - 1) {
err("write(new_master) failed");
exit_shot_parent(1);
}
task_waiter_wait4(&t, 1);
close(new_master);
exit(0);
} else if (pid < 0) {
err("test_fork failed: %m\n");
exit(1);
}
task_waiter_wait4(&t, pid);
close(master);
test_daemon();
test_waitsig();
signal(SIGHUP, SIG_IGN);
task_waiter_complete(&t, 1);
ret = read(slave, buf, sizeof(teststr) - 1);
if (ret != sizeof(teststr) - 1) {
err("read(slave) failed");
return 1;
}
if (strncmp(teststr, buf, sizeof(teststr) - 1)) {
fail("data mismatch");
return 1;
}
close(slave);
pass();
return 0;
}
int main(int argc, char **argv)
{
char buf[BUF_SIZE];
int fd, fd_s;
struct aiocb aiocb;
int status;
pid_t pid;
int ret, res;
const struct aiocb *aioary[1];
task_waiter_t child_waiter;
test_init(argc, argv);
task_waiter_init(&child_waiter);
if ((fd_s = tcp_init_server(AF_INET, &port)) < 0) {
pr_err("initializing server failed\n");
return 1;
}
pid = test_fork();
if (pid < 0) {
pr_perror("fork failed");
return 1;
}
if (pid == 0) {
/*
* Chiled is client of TCP connection
*/
close(fd_s);
fd = tcp_init_client(AF_INET, "127.0.0.1", port);
if (fd < 0)
return 1;
memset(&aiocb, 0, sizeof(struct aiocb));
aiocb.aio_fildes = fd;
aiocb.aio_buf = buf;
aiocb.aio_nbytes = BUF_SIZE;
ret = aio_read(&aiocb);
if (ret < 0) {
pr_perror("aio_read failed");
return 1;
}
task_waiter_complete_current(&child_waiter);
/* Wait for request completion */
aioary[0] = &aiocb;
ret = aio_error(&aiocb);
#ifdef DEBUG
test_msg(".");
#endif
res = 0;
again:
if (aio_suspend(aioary, 1, NULL) < 0 && errno != EINTR) {
pr_perror("aio_suspend failed");
res = 1;
}
ret = aio_error(&aiocb);
if (!res && ret == EINPROGRESS) {
#ifdef DEBUG
test_msg("restart aio_suspend\n");
#endif
goto again;
}
if (ret != 0) {
pr_err("Error at aio_error(): %s\n", strerror(ret));
res = 1;
}
if (aio_return(&aiocb) != BUF_SIZE) {
pr_perror("Error at aio_return()");
res = 1;
}
close(fd);
return res;
}
/*
* parent is server of TCP connection
*/
fd = tcp_accept_server(fd_s);
close(fd_s);
if (fd < 0) {
pr_err("can't accept client connection\n");
goto error;
}
task_waiter_wait4(&child_waiter, pid);
test_daemon();
test_waitsig();
if (write(fd, buf, BUF_SIZE) < BUF_SIZE) {
pr_perror("can't write");
goto error;
}
close(fd);
if (wait(&status) < 0) {
pr_perror("wait failed");
goto error;
}
if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
pr_err("child failed with exit code %d\n", WEXITSTATUS(status));
return 1;
}
pass();
return 0;
error:
kill(pid, SIGKILL);
wait(&status);
return -1;
}
int main(int argc, char **argv)
{
task_waiter_t t;
pid_t pid;
test_init(argc, argv);
mkdir(dirname, 0755);
if (mount("zdtm", dirname, "tmpfs", 0, NULL)) {
pr_perror("mount");
return 1;
}
if (chdir(dirname)) {
pr_perror("chdir");
return 1;
}
mkdir("1", 0755);
mkdir("2", 0755);
if (mount("1", "1", NULL, MS_BIND, NULL)) {
pr_perror("mount");
return 1;
}
if (mount(NULL, "1", NULL, MS_PRIVATE, NULL)) {
pr_perror("mount");
return 1;
}
if (mount("zdtm", "2", "tmpfs", 0, NULL)) {
pr_perror("mount");
return 1;
}
mkdir("1/a", 0755);
mkdir("2/a", 0755);
if (mount("1/a", "1/a", NULL, MS_BIND, NULL)) {
pr_perror("mount");
return 1;
}
if (mount(NULL, "1/a", NULL, MS_SHARED, NULL)) {
pr_perror("mount");
return 1;
}
if (mount("1/a", "2/a", NULL, MS_BIND, NULL)) {
pr_perror("mount");
return 1;
}
mkdir("1/a/c", 0755);
if (mount("zdtm", "1/a/c", "tmpfs", 0, NULL)) {
pr_perror("mount");
return 1;
}
if (mount("2", "1", NULL, MS_MOVE, NULL)) {
pr_perror("mount");
return 1;
}
task_waiter_init(&t);
pid = fork();
if (pid < 0)
return -1;
if (pid == 0) {
if (unshare(CLONE_NEWNS))
return 1;
task_waiter_complete_current(&t);
test_waitsig();
return 0;
}
task_waiter_wait4(&t, pid);
test_daemon();
test_waitsig();
kill(pid, SIGTERM);
wait(NULL);
pass();
return 0;
}
int main(int argc, char ** argv)
{
int fdm, fds, status;
task_waiter_t t;
char *slavename;
pid_t pid;
test_init(argc, argv);
task_waiter_init(&t);
fdm = open("/dev/ptmx", O_RDWR);
if (fdm == -1) {
pr_perror("Can't open a master pseudoterminal");
return 1;
}
grantpt(fdm);
unlockpt(fdm);
slavename = ptsname(fdm);
pid = test_fork();
if (pid < 0) {
pr_perror("fork() failed");
return 1;
}
if (pid == 0) {
close(fdm);
signal(SIGHUP, sighup_handler);
if (setsid() == -1)
return 1;
/* set up a controlling terminal */
fds = open(slavename, O_RDWR);
if (fds == -1) {
pr_perror("Can't open a slave pseudoterminal %s", slavename);
return 1;
}
if (ioctl(fdm, TIOCSCTTY, 1) < 0) {
pr_perror("Can't setup a controlling terminal");
return 1;
}
close(fds);
task_waiter_complete_current(&t);
test_waitsig();
if (sighup)
return 0;
return 1;
}
task_waiter_wait4(&t, pid);
test_daemon();
test_waitsig();
close(fdm);
if (kill(pid, SIGTERM) == -1) {
pr_perror("kill failed");
return 1;
}
pid = waitpid(pid, &status, 0);
if (pid < 0)
return 1;
if (WIFEXITED(status)) {
if (WEXITSTATUS(status)) {
fail("The child returned %d", WEXITSTATUS(status));
return 1;
}
} else {
test_msg("The child has been killed by %d\n", WTERMSIG(status));
return 1;
}
pass();
return 0;
}
