static void setup_every_copy()
{
close(newdirfd);
rmobj(TEST_DIR2, NULL);
SUCCEED_OR_DIE(mkdir, "mkdir(%s, %o) failed: %s", TEST_DIR2, 0700);
newdirfd = SUCCEED_OR_DIE(open, "open(%s, 0x%x) failed: %s", TEST_DIR2, O_DIRECTORY);
}
static void mysymlinkat_test(struct test_struct *desc)
{
int fd;
TEST(mysymlinkat(desc->oldfn, *desc->newfd, desc->newfn));
/* check return code */
if (TEST_ERRNO == desc->expected_errno) {
if (TEST_RETURN == 0 && desc->referencefn1 != NULL) {
int tnum = rand(), vnum = ~tnum;
int len;
fd = SUCCEED_OR_DIE(open,
"open(%s, 0x%x) failed: %s",
desc->referencefn1, O_RDWR);
if ((len =
write(fd, &tnum,
sizeof(tnum))) != sizeof(tnum))
tst_brkm(TBROK, cleanup,
"write() failed: expected %zu, returned %d; error: %s",
sizeof(tnum), len,
strerror(errno));
SUCCEED_OR_DIE(close, "close(%d) failed: %s",
fd);
fd = SUCCEED_OR_DIE(open,
"open(%s, 0x%x) failed: %s",
desc->referencefn2,
O_RDONLY);
if ((len =
read(fd, &vnum,
sizeof(vnum))) != sizeof(tnum))
tst_brkm(TBROK, cleanup,
"read() failed: expected %zu, returned %d; error: %s",
sizeof(vnum), len,
strerror(errno));
SUCCEED_OR_DIE(close, "close(%d) failed: %s",
fd);
if (tnum == vnum)
tst_resm(TPASS, "Test passed");
else
tst_resm(TFAIL,
"The link file's content isn't as same as the original file's "
"although symlinkat returned 0");
} else {
tst_resm(TPASS,
"symlinkat() returned the expected errno %d: %s",
TEST_ERRNO, strerror(TEST_ERRNO));
}
} else {
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL,
TEST_RETURN ==
0 ? "symlinkat() surprisingly succeeded" :
"symlinkat() Failed, errno=%d : %s", TEST_ERRNO,
strerror(TEST_ERRNO));
}
}
void test_unmasked_matching_noinfo(swi_func sigwaitinfo, int signo)
{
sigset_t sigs;
pid_t child;
SUCCEED_OR_DIE(sigemptyset, "sigemptyset failed", &sigs);
SUCCEED_OR_DIE(sigaddset, "sigaddset failed", &sigs, signo);
/* Run a child that will wake us up */
child=create_sig_proc(100000, signo, UINT_MAX);
TEST(sigwaitinfo(&sigs, NULL, NULL));
REPORT_SUCCESS(signo, 0);
kill(child, SIGTERM);
}
void test_bad_address3(swi_func sigwaitinfo, int signo)
{
sigset_t sigs;
SUCCEED_OR_DIE(sigemptyset, "sigemptyset failed", &sigs);
TEST(sigwaitinfo(&sigs, NULL, (void*)1));
REPORT_SUCCESS(-1, EFAULT);
}
/***************************************************************
* setup() - performs all ONE TIME setup for this test.
***************************************************************/
static void setup(void)
{
char *tmp;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
SUCCEED_OR_DIE(mkdir, "mkdir(%s, %o) failed: %s", TEST_DIR1, 0700);
SUCCEED_OR_DIE(mkdir, "mkdir(%s, %o) failed: %s", TEST_DIR3, 0700);
olddirfd =
SUCCEED_OR_DIE(open, "open(%s, 0x%x) failed: %s", TEST_DIR1,
O_DIRECTORY);
deldirfd =
SUCCEED_OR_DIE(open, "open(%s, 0x%x) failed: %s", TEST_DIR3,
O_DIRECTORY);
SUCCEED_OR_DIE(rmdir, "rmdir(%s) failed: %s", TEST_DIR3);
SUCCEED_OR_DIE(close, "close(%d) failed: %s",
SUCCEED_OR_DIE(open, "open(%s, 0x%x, %o) failed: %s",
TEST_DIR1 "/" TEST_FILE1,
O_CREAT | O_EXCL, 0600));
/* gratuitous memory leak here */
tmp = strdup(dpathname);
snprintf(dpathname, sizeof(dpathname), tmp, get_current_dir_name());
TEST_PAUSE;
}
void test_bad_address(swi_func sigwaitinfo, int signo)
{
sigset_t sigs, oldmask;
pid_t child;
SUCCEED_OR_DIE(sigemptyset, "sigemptyset failed", &sigs);
SUCCEED_OR_DIE(sigaddset, "sigaddset failed", &sigs, signo);
/* let's not get interrupted by our dying child */
SUCCEED_OR_DIE(sigaddset, "sigaddset failed", &sigs, SIGCHLD);
SUCCEED_OR_DIE(sigprocmask, "sigprocmask failed", SIG_SETMASK, &sigs, &oldmask);
/* don't wait on a SIGCHLD */
SUCCEED_OR_DIE(sigdelset, "sigaddset failed", &sigs, SIGCHLD);
/* Run a child that will wake us up */
child=create_sig_proc(0, signo, 1);
TEST(sigwaitinfo(&sigs, (void*)1, NULL));
REPORT_SUCCESS(-1, EFAULT);
SUCCEED_OR_DIE(sigprocmask, "sigprocmask failed", SIG_SETMASK, &oldmask, &oldmask);
kill(child, SIGTERM);
}
void test_masked_matching_noinfo(swi_func sigwaitinfo, int signo)
{
sigset_t sigs, oldmask;
pid_t child;
SUCCEED_OR_DIE(sigemptyset, "sigemptyset failed", &sigs);
SUCCEED_OR_DIE(sigaddset, "sigaddset failed", &sigs, signo);
/* let's not get interrupted by our dying child */
SUCCEED_OR_DIE(sigaddset, "sigaddset failed", &sigs, SIGCHLD);
SUCCEED_OR_DIE(sigprocmask, "sigprocmask failed", SIG_SETMASK, &sigs, &oldmask);
/* don't wait on a SIGCHLD */
SUCCEED_OR_DIE(sigdelset, "sigaddset failed", &sigs, SIGCHLD);
/* Run a child that will wake us up */
child=create_sig_proc(0, signo, 1);
TEST(sigwaitinfo(&sigs, NULL, NULL));
REPORT_SUCCESS(signo, 0);
SUCCEED_OR_DIE(sigprocmask, "restoring original signal mask failed", SIG_SETMASK, &oldmask, &oldmask);
Tst_count--;
if(sigismember(&oldmask, signo))
tst_resm(TPASS, "sigwaitinfo restored the original mask");
else
tst_resm(TFAIL, "sigwaitinfo failed to restore the original mask");
}
void test_timeout(swi_func sigwaitinfo, int signo)
{
sigset_t sigs;
siginfo_t si;
pid_t child;
struct timespec ts = {.tv_sec = 1 };
SUCCEED_OR_DIE(sigemptyset, "sigemptyset failed", &sigs);
/* Run a child that will wake us up */
child = create_sig_proc(100000, signo, UINT_MAX);
TEST(sigwaitinfo(&sigs, &si, &ts));
REPORT_SUCCESS(-1, EAGAIN);
kill(child, SIGTERM);
}
/* Note: sigwait-ing for a signal that is not blocked is unspecified
* by POSIX; but works for non-ignored signals under Linux
*/
void test_unmasked_matching(swi_func sigwaitinfo, int signo)
{
sigset_t sigs;
siginfo_t si;
pid_t child;
SUCCEED_OR_DIE(sigemptyset, "sigemptyset failed", &sigs);
SUCCEED_OR_DIE(sigaddset, "sigaddset failed", &sigs, signo);
/* Run a child that will wake us up */
child = create_sig_proc(100000, signo, UINT_MAX);
TEST(sigwaitinfo(&sigs, &si, NULL));
REPORT_SUCCESS_COND(signo, 0, si.si_pid == child
&& si.si_code == SI_USER
&& si.si_signo == signo, "Struct siginfo mismatch");
kill(child, SIGTERM);
}
void test_empty_set(swi_func sigwaitinfo, int signo)
{
sigset_t sigs;
siginfo_t si;
pid_t child;
SUCCEED_OR_DIE(sigemptyset, "sigemptyset failed", &sigs);
/* Run a child that will wake us up */
child=create_sig_proc(100000, signo, UINT_MAX);
TEST(sigwaitinfo(&sigs, &si, NULL));
REPORT_SUCCESS(-1, EINTR);
kill(child, SIGTERM);
}
void test_masked_matching_rt(swi_func sigwaitinfo, int signo)
{
sigset_t sigs, oldmask;
siginfo_t si;
pid_t child[2];
signo = SIGRTMIN + 1;
SUCCEED_OR_DIE(sigemptyset, "sigemptyset failed", &sigs);
SUCCEED_OR_DIE(sigaddset, "sigaddset failed", &sigs, signo);
SUCCEED_OR_DIE(sigaddset, "sigaddset failed", &sigs, signo + 1);
/* let's not get interrupted by our dying child */
SUCCEED_OR_DIE(sigaddset, "sigaddset failed", &sigs, SIGCHLD);
SUCCEED_OR_DIE(sigprocmask, "sigprocmask failed", SIG_SETMASK, &sigs,
&oldmask);
/* don't wait on a SIGCHLD */
SUCCEED_OR_DIE(sigdelset, "sigdelset failed", &sigs, SIGCHLD);
/* Run a child that will wake us up */
child[0] = create_sig_proc(0, signo, 1);
child[1] = create_sig_proc(0, signo + 1, 1);
TEST(sigwaitinfo(&sigs, &si, NULL));
REPORT_SUCCESS_COND(signo, 0, si.si_pid == child[0]
&& si.si_code == SI_USER
&& si.si_signo == signo, "Struct siginfo mismatch");
/* eat the other signal */
Tst_count--;
TEST(sigwaitinfo(&sigs, &si, NULL));
REPORT_SUCCESS_COND(signo + 1, 0, si.si_pid == child[1]
&& si.si_code == SI_USER
&& si.si_signo == signo + 1,
"Struct siginfo mismatch");
SUCCEED_OR_DIE(sigprocmask, "restoring original signal mask failed",
SIG_SETMASK, &oldmask, &oldmask);
Tst_count--;
if (sigismember(&oldmask, signo))
tst_resm(TPASS, "sigwaitinfo restored the original mask");
else
tst_resm(TFAIL,
"sigwaitinfo failed to restore the original mask");
}
void setup(void)
{
char *cwd;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
cwd = get_current_dir_name();
if (cwd == NULL)
tst_brkm(TFAIL | TERRNO, cleanup,
"Failed to get current working directory");
else {
SUCCEED_OR_DIE(mkdir, "mkdir(%s, %o) failed", TEST_DIR1, 0700);
SUCCEED_OR_DIE(mkdir, "mkdir(%s, %o) failed", TEST_DIR3, 0700);
olddirfd = SUCCEED_OR_DIE(open, "open(%s, 0x%x) failed",
TEST_DIR1, O_DIRECTORY);
deldirfd = SUCCEED_OR_DIE(open, "open(%s, 0x%x) failed",
TEST_DIR3, O_DIRECTORY);
SUCCEED_OR_DIE(rmdir, "rmdir(%s) failed", TEST_DIR3);
SUCCEED_OR_DIE(close, "close(%d) failed",
SUCCEED_OR_DIE(open, "open(%s, 0x%x, %o) "
"failed",
TEST_DIR1 "/" TEST_FILE1,
O_CREAT | O_EXCL, 0600));
SUCCEED_OR_DIE(mkfifo, "mkfifo(%s, %o) failed",
TEST_DIR1 "/" TEST_FIFO, 0600);
snprintf(dpathname, sizeof(dpathname), DPATHNAME_FMT, cwd);
snprintf(spathname, sizeof(spathname), SPATHNAME_FMT, cwd);
free(cwd);
TEST_PAUSE;
}
}
