int main(int ac, char **av)
{
int lc;
int incr;
uintptr_t nbrkpt; /* new brk point value */
uintptr_t cur_brk_val; /* current size returned by sbrk */
uintptr_t aft_brk_val; /* current size returned by sbrk */
tst_parse_opts(ac, av, NULL, NULL);
setup();
/*
* Attempt to control how fast we get to test max size.
* Every MAX_SIZE_LC'th lc will be fastest test will reach max size.
*/
incr = (Max_brk_byte_size - Beg_brk_val) / (MAX_SIZE_LC / 2);
if ((incr * 2) < 4096) /* make sure that process will grow */
incr += 4096 / 2;
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
/*
* Determine new value to give brk
* Every even lc value, grow by 2 incr and
* every odd lc value, strink by one incr.
* If lc is equal to 3, no change, special case.
*/
cur_brk_val = (uintptr_t)sbrk(0);
if (lc == 3) {
nbrkpt = cur_brk_val; /* no change, special one time case */
} else if ((lc % 2) == 0) {
/*
* grow
*/
nbrkpt = cur_brk_val + (2 * incr);
if (nbrkpt > Max_brk_byte_size)
nbrkpt = Beg_brk_val; /* start over */
} else {
/*
* shrink
*/
nbrkpt = cur_brk_val - incr;
}
/****
printf("cur_brk_val = %d, nbrkpt = %d, incr = %d, lc = %d\n",
cur_brk_val, nbrkpt, incr, lc);
****/
TEST(brk((char *)nbrkpt));
if (TEST_RETURN == -1) {
aft_brk_val = (uintptr_t)sbrk(0);
tst_resm(TFAIL | TTERRNO,
"brk(%"PRIuPTR") failed (size before %"PRIuPTR", after %"PRIuPTR")",
nbrkpt, cur_brk_val, aft_brk_val);
} else {
aft_brk_val = (uintptr_t)sbrk(0);
if (aft_brk_val == nbrkpt) {
tst_resm(TPASS,
"brk(%"PRIuPTR") returned %"PRIuPTR", new size verified by sbrk",
nbrkpt, TEST_RETURN);
} else {
tst_resm(TFAIL,
"brk(%"PRIuPTR") returned %"PRIuPTR", sbrk before %"PRIuPTR", after %"PRIuPTR"",
nbrkpt, TEST_RETURN,
cur_brk_val, aft_brk_val);
}
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
int rval;
pid_t pid, pid1;
int status;
/*
* parse standard options
*/
tst_parse_opts(ac, av, NULL, NULL);
/*
* perform global setup for test
*/
setup();
/*
* check looping state if -i option given
*/
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
/* Initialize the test directories name */
sprintf(tstdir1, "tstdir1.%d", getpid());
if ((pid = FORK_OR_VFORK()) < 0) {
tst_brkm(TBROK, cleanup, "fork #1 failed");
}
if (pid == 0) { /* first child */
rval = setreuid(nobody_uid, nobody_uid);
if (rval < 0) {
tst_resm(TFAIL, "setreuid failed to "
"to set the real uid to %d and "
"effective uid to %d",
nobody_uid, nobody_uid);
perror("setreuid");
exit(1);
}
/* create the parent directory with 0700 permits */
if (mkdir(tstdir1, PERMS) == -1) {
tst_resm(TFAIL, "mkdir(%s, %#o) Failed",
tstdir1, PERMS);
exit(1);
}
/* create tstdir1 succeeded */
exit(0);
}
wait(&status);
if (WEXITSTATUS(status) != 0) {
tst_brkm(TFAIL, cleanup,
"Test to check mkdir EACCES failed"
"in create parent directory");
}
sprintf(tstdir2, "%s/tst", tstdir1);
if ((pid1 = FORK_OR_VFORK()) < 0) {
tst_brkm(TBROK, cleanup, "fork #2 failed");
}
if (pid1 == 0) { /* second child */
rval = setreuid(bin_uid, bin_uid);
if (rval < 0) {
tst_resm(TFAIL, "setreuid failed to "
"to set the real uid to %d and "
"effective uid to %d",
bin_uid, bin_uid);
perror("setreuid");
exit(1);
}
if (mkdir(tstdir2, PERMS) != -1) {
tst_resm(TFAIL, "mkdir(%s, %#o) unexpected "
"succeeded", tstdir2, PERMS);
exit(1);
}
if (errno != EACCES) {
tst_resm(TFAIL, "Expected EACCES got %d",
errno);
exit(1);
}
/* PASS */
exit(0);
}
waitpid(pid1, &status, 0);
if (WEXITSTATUS(status) == 0) {
tst_resm(TPASS, "Test to attempt to creat a directory "
"in a directory having no permissions "
"SUCCEEDED in setting errno to EACCES");
} else {
tst_resm(TFAIL, "Test to attempt to creat a directory "
"in a directory having no permissions FAILED");
cleanup();
}
}
/*
* cleanup and exit
*/
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
int Hflag = 0;
int sflag = 0;
int huge_pagesize = 0;
option_t options[] = {
{"H:", &Hflag, &Hopt},
{"s:", &sflag, &nr_opt},
{NULL, NULL, NULL}
};
tst_parse_opts(ac, av, options, &help);
if (!Hflag) {
tst_tmpdir();
Hopt = tst_get_tmpdir();
}
if (sflag)
hugepages = SAFE_STRTOL(NULL, nr_opt, 0, LONG_MAX);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* Creat a temporary file used for huge mapping */
fildes = open(TEMPFILE, O_RDWR | O_CREAT, 0666);
if (fildes < 0)
tst_brkm(TFAIL | TERRNO, cleanup, "open %s failed",
TEMPFILE);
tst_count = 0;
/* Note the number of free huge pages BEFORE testing */
freepages = read_meminfo("HugePages_Free:");
beforetest = freepages;
/* Note the size of huge page size BEFORE testing */
huge_pagesize = read_meminfo("Hugepagesize:");
tst_resm(TINFO, "Size of huge pages is %d KB", huge_pagesize);
#if __WORDSIZE == 32
tst_resm(TINFO, "Total amount of free huge pages is %d",
freepages);
tst_resm(TINFO, "Max number allowed for 1 mmap file in"
" 32-bits is 128");
if (freepages > 128)
freepages = 128;
#endif
mapsize = (long long)freepages *huge_pagesize * 1024;
addr = mmap(NULL, mapsize, PROT_READ | PROT_WRITE,
MAP_SHARED, fildes, 0);
sleep(2);
if (addr == MAP_FAILED) {
tst_resm(TFAIL | TERRNO, "mmap() Failed on %s",
TEMPFILE);
close(fildes);
continue;
} else {
tst_resm(TPASS,
"Succeeded mapping file using %ld pages",
freepages);
/* force to allocate page and change HugePages_Free */
*(int *)addr = 0;
}
/*
* Make sure the number of free huge pages
* AFTER testing decreased
*/
aftertest = read_meminfo("HugePages_Free:");
hugepagesmapped = beforetest - aftertest;
if (hugepagesmapped < 1)
tst_resm(TWARN, "Number of HUGEPAGES_FREE stayed the"
" same. Okay if multiple copies running due"
" to test collision.");
/* Clean up things in case we are looping */
/* Unmap the mapped memory */
if (munmap(addr, mapsize) != 0)
tst_brkm(TFAIL | TERRNO, NULL, "munmap failed");
close(fildes);
}
cleanup();
tst_exit();
}
/***********************************************************************
* Main
***********************************************************************/
int main(int ac, char **av)
{
int lc;
int cnt;
int nfiles, fd;
char fname[255];
DIR *test_dir;
struct dirent *dptr;
tst_parse_opts(ac, av, options, &help);
if (Nflag) {
if (sscanf(Nfilearg, "%i", &Nfiles) != 1) {
tst_brkm(TBROK, NULL, "--N option arg is not a number");
}
}
/***************************************************************
* perform global setup for test
***************************************************************/
/* Next you should run a setup routine to make sure your environment is
* sane.
*/
setup();
/***************************************************************
* check looping state
***************************************************************/
/* TEST_LOOPING() is a macro that will make sure the test continues
* looping according to the standard command line args.
*/
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
if (Nfiles)
nfiles = Nfiles;
else
/* min of 10 links and max of a 100 links */
nfiles = (lc % 90) + 10;
/* create a bunch of files to look at */
for (cnt = 0; cnt < nfiles; cnt++) {
sprintf(fname, "%s%d", Basename, cnt);
if ((fd = open(fname, O_RDWR | O_CREAT, 0700)) == -1) {
tst_brkm(TBROK, cleanup,
"open(%s, O_RDWR|O_CREAT,0700) Failed, errno=%d : %s",
fname, errno, strerror(errno));
} else if (write(fd, "hello\n", 6) < 0) {
tst_brkm(TBROK, cleanup,
"write(%s, \"hello\\n\", 6) Failed, errno=%d : %s",
fname, errno, strerror(errno));
} else if (close(fd) < 0) {
tst_resm(TWARN,
"close(%s) Failed, errno=%d : %s",
fname, errno, strerror(errno));
}
}
if ((test_dir = opendir(".")) == NULL) {
tst_resm(TFAIL, "opendir(\".\") Failed, errno=%d : %s",
errno, strerror(errno));
} else {
/* count the entries we find to see if any are missing */
cnt = 0;
errno = 0;
while ((dptr = readdir(test_dir)) != 0) {
if (strcmp(dptr->d_name, ".")
&& strcmp(dptr->d_name, ".."))
cnt++;
}
if (errno != 0) {
tst_resm(TFAIL,
"readir(test_dir) Failed on try %d, errno=%d : %s",
cnt + 1, errno, strerror(errno));
}
if (cnt == nfiles) {
tst_resm(TPASS,
"found all %d that were created",
nfiles);
} else if (cnt > nfiles) {
tst_resm(TFAIL,
"found more files than were created");
tst_resm(TINFO, "created: %d, found: %d",
nfiles, cnt);
} else {
tst_resm(TFAIL,
"found less files than were created");
tst_resm(TINFO, "created: %d, found: %d",
nfiles, cnt);
}
}
/* Here we clean up after the test case so we can do another iteration.
*/
for (cnt = 0; cnt < nfiles; cnt++) {
sprintf(fname, "%s%d", Basename, cnt);
if (unlink(fname) == -1) {
tst_resm(TWARN,
"unlink(%s) Failed, errno=%d : %s",
Fname, errno, strerror(errno));
}
}
}
/***************************************************************
* cleanup and exit
***************************************************************/
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
int i;
int fork_ret, status;
int written; /* no of chars read and written */
tst_parse_opts(ac, av, NULL, NULL);
#ifdef UCLINUX
maybe_run_child(&do_child_uclinux, "ddddd", &fd[0], &fd[1], &kidid,
&ncperchild, &szcharbuf);
#endif
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset tst_count in case we are looping */
tst_count = 0;
TEST(pipe(fd));
if (TEST_RETURN != 0) {
tst_resm(TFAIL, "pipe creation failed");
continue;
}
written = write(fd[1], wrbuf, szcharbuf);
if (written != szcharbuf) {
tst_brkm(TBROK, cleanup, "write to pipe failed");
}
refork:
++kidid;
fork_ret = FORK_OR_VFORK();
if (fork_ret < 0) {
tst_brkm(TBROK, cleanup, "fork() failed");
}
if ((fork_ret != 0) && (fork_ret != -1) && (kidid < numchild)) {
goto refork;
}
if (fork_ret == 0) { /* child */
#ifdef UCLINUX
if (self_exec(av[0], "ddddd", fd[0], fd[1], kidid,
ncperchild, szcharbuf) < 0) {
tst_brkm(TBROK, cleanup, "self_exec failed");
}
#else
do_child();
#endif
}
/* parent */
sleep(5);
tst_resm(TINFO, "There are %d children to wait for", kidid);
for (i = 1; i <= kidid; ++i) {
wait(&status);
if (status == 0) {
tst_resm(TPASS, "child %d exitted successfully",
i);
} else {
tst_resm(TFAIL, "child %d exitted with bad "
"status", i);
}
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
struct stat stat_buf; /* struct buffer to hold file info. */
int lc;
long type;
time_t modf_time, access_time;
time_t pres_time; /* file modification/access/present time */
tst_parse_opts(ac, av, NULL, NULL);
setup();
switch ((type = tst_fs_type(cleanup, "."))) {
case TST_NFS_MAGIC:
if (tst_kvercmp(2, 6, 18) < 0)
tst_brkm(TCONF, cleanup, "Cannot do utime on a file"
" on %s filesystem before 2.6.18",
tst_fs_type_name(type));
break;
case TST_V9FS_MAGIC:
tst_brkm(TCONF, cleanup,
"Cannot do utime on a file on %s filesystem",
tst_fs_type_name(type));
break;
}
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
/*
* Invoke utime(2) to set TEMP_FILE access and
* modification times to the current time.
*/
TEST(utime(TEMP_FILE, NULL));
if (TEST_RETURN == -1) {
tst_resm(TFAIL|TTERRNO, "utime(%s) failed", TEMP_FILE);
} else {
/*
* Sleep for a second so that mod time and
* access times will be different from the
* current time
*/
sleep(2);
/*
* Get the current time now, after calling
* utime(2)
*/
pres_time = time(NULL);
/*
* Get the modification and access times of
* temporary file using stat(2).
*/
SAFE_STAT(cleanup, TEMP_FILE, &stat_buf);
modf_time = stat_buf.st_mtime;
access_time = stat_buf.st_atime;
/* Now do the actual verification */
if (modf_time <= curr_time ||
modf_time >= pres_time ||
access_time <= curr_time ||
access_time >= pres_time) {
tst_resm(TFAIL, "%s access and "
"modification times not set",
TEMP_FILE);
} else {
tst_resm(TPASS, "Functionality of "
"utime(%s, NULL) successful",
TEMP_FILE);
}
}
tst_count++;
}
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
int end_signum = -1;
int signum;
int start_signum = -1;
int status;
pid_t child;
tst_parse_opts(argc, argv, NULL, NULL);
if (start_signum == -1) {
start_signum = 0;
}
if (end_signum == -1) {
end_signum = SIGRTMAX;
}
for (signum = start_signum; signum <= end_signum; signum++) {
if (signum >= __SIGRTMIN && signum < SIGRTMIN)
continue;
switch (child = fork()) {
case -1:
tst_brkm(TBROK | TERRNO, NULL, "fork() failed");
case 0:
if (ptrace(PTRACE_TRACEME, 0, NULL, NULL) != -1) {
tst_resm(TINFO, "[child] Sending kill(.., %d)",
signum);
if (kill(getpid(), signum) < 0) {
tst_resm(TINFO | TERRNO,
"[child] kill(.., %d) failed.",
signum);
}
} else {
/*
* This won't increment the TST_COUNT var.
* properly, but it'll show up as a failure
* nonetheless.
*/
tst_resm(TFAIL | TERRNO,
"Failed to ptrace(PTRACE_TRACEME, ...) "
"properly");
}
/* Shouldn't get here if signum == 0. */
exit((signum == 0 ? 0 : 2));
break;
default:
waitpid(child, &status, 0);
switch (signum) {
case 0:
if (WIFEXITED(status)
&& WEXITSTATUS(status) == 0) {
tst_resm(TPASS,
"kill(.., 0) exited "
"with 0, as expected.");
} else {
tst_resm(TFAIL,
"kill(.., 0) didn't exit "
"with 0.");
}
break;
case SIGKILL:
if (WIFSIGNALED(status)) {
/* SIGKILL must be uncatchable. */
if (WTERMSIG(status) == SIGKILL) {
tst_resm(TPASS,
"Killed with SIGKILL, "
"as expected.");
} else {
tst_resm(TPASS,
"Didn't die with "
"SIGKILL (?!) ");
}
} else if (WIFEXITED(status)) {
tst_resm(TFAIL,
"Exited unexpectedly instead "
"of dying with SIGKILL.");
} else if (WIFSTOPPED(status)) {
tst_resm(TFAIL,
"Stopped instead of dying "
"with SIGKILL.");
}
break;
/* All other processes should be stopped. */
default:
if (WIFSTOPPED(status)) {
tst_resm(TPASS, "Stopped as expected");
} else {
tst_resm(TFAIL, "Didn't stop as "
"expected.");
if (kill(child, 0)) {
tst_resm(TINFO,
"Is still alive!?");
} else if (WIFEXITED(status)) {
tst_resm(TINFO,
"Exited normally");
} else if (WIFSIGNALED(status)) {
tst_resm(TINFO,
"Was signaled with "
"signum=%d",
WTERMSIG(status));
}
}
break;
}
}
/* Make sure the child dies a quick and painless death ... */
kill(child, 9);
}
tst_exit();
}
int main(int ac, char **av)
{
struct stat stat_buf; /* stat(2) struct contents */
int lc, i;
off_t file_length2; /* test file length */
off_t file_length1; /* test file length */
int rbytes; /* bytes read from testfile */
int read_len = 0; /* total no. of bytes read from testfile */
int err_flag = 0; /* error indicator flag */
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
/*
* Call truncate(2) to truncate a test file to a
* specified length (TRUNC_LEN1).
*/
TEST(truncate(TESTFILE, TRUNC_LEN1));
if (TEST_RETURN == -1) {
tst_resm(TFAIL,
"truncate(%s, %d) Failed, errno=%d : %s",
TESTFILE, TRUNC_LEN1, TEST_ERRNO,
strerror(TEST_ERRNO));
} else {
/*
* Get the testfile information using
* stat(2).
*/
if (stat(TESTFILE, &stat_buf) < 0) {
tst_brkm(TFAIL, cleanup, "stat(2) of "
"%s failed after 1st truncate, "
"error:%d", TESTFILE, errno);
}
file_length1 = stat_buf.st_size;
/*
* Set the file pointer of testfile to the
* beginning of the file.
*/
if (lseek(fd, 0, SEEK_SET) < 0) {
tst_brkm(TFAIL, cleanup, "lseek(2) on "
"%s failed after 1st truncate, "
"error:%d", TESTFILE, errno);
}
/* Read the testfile from the beginning. */
while ((rbytes = read(fd, tst_buff,
sizeof(tst_buff))) > 0) {
read_len += rbytes;
}
/*
* Execute truncate(2) again to truncate
* testfile to a size TRUNC_LEN2.
*/
TEST(truncate(TESTFILE, TRUNC_LEN2));
if (TEST_RETURN == -1) {
tst_resm(TFAIL, "truncate of %s to "
"size %d Failed, errno=%d : %s",
TESTFILE, TRUNC_LEN2,
TEST_ERRNO,
strerror(TEST_ERRNO));
}
/*
* Get the testfile information using
* stat(2)
*/
if (stat(TESTFILE, &stat_buf) < 0) {
tst_brkm(TFAIL, cleanup, "stat(2) of "
"%s failed after 2nd truncate, "
"error:%d", TESTFILE, errno);
}
file_length2 = stat_buf.st_size;
/*
* Set the file pointer of testfile to the
* offset TRUNC_LEN1 of testfile.
*/
if (lseek(fd, TRUNC_LEN1, SEEK_SET) < 0) {
tst_brkm(TFAIL, cleanup, "lseek(2) on "
"%s failed after 2nd truncate, "
"error:%d", TESTFILE, errno);
}
/* Read the testfile contents till EOF */
while ((rbytes = read(fd, tst_buff,
sizeof(tst_buff))) > 0) {
for (i = 0; i < rbytes; i++) {
if (tst_buff[i] != 0) {
err_flag++;
}
}
}
/*
* Check for expected size of testfile after
* issuing truncate(2) on it.
*/
if ((file_length1 != TRUNC_LEN1) ||
(file_length2 != TRUNC_LEN2) ||
(read_len != TRUNC_LEN1) ||
(err_flag != 0)) {
tst_resm(TFAIL, "Functionality of "
"truncate(2) on %s Failed",
TESTFILE);
} else {
tst_resm(TPASS,
"Functionality of truncate(2) "
"on %s successful", TESTFILE);
}
}
tst_count++; /* incr. TEST_LOOP counter */
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc, i;
int len, stop;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
/*
* generate events
*/
fd = SAFE_OPEN(cleanup, fname, O_RDWR);
for (i = 0; i < max_events; i++) {
SAFE_LSEEK(cleanup, fd, 0, SEEK_SET);
SAFE_READ(cleanup, 1, fd, buf, BUF_SIZE);
SAFE_LSEEK(cleanup, fd, 0, SEEK_SET);
SAFE_WRITE(cleanup, 1, fd, buf, BUF_SIZE);
}
SAFE_CLOSE(cleanup, fd);
stop = 0;
while (!stop) {
/*
* get list on events
*/
len = read(fd_notify, event_buf, EVENT_BUF_LEN);
if (len < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"read(%d, buf, %zu) failed",
fd_notify, EVENT_BUF_LEN);
}
/*
* check events
*/
i = 0;
while (i < len) {
struct inotify_event *event;
event = (struct inotify_event *)&event_buf[i];
if (event->mask != IN_ACCESS &&
event->mask != IN_MODIFY &&
event->mask != IN_OPEN &&
event->mask != IN_Q_OVERFLOW) {
tst_resm(TFAIL,
"get event: wd=%d mask=%x "
"cookie=%u (expected 0) len=%u",
event->wd, event->mask,
event->cookie, event->len);
stop = 1;
break;
}
if (event->mask == IN_Q_OVERFLOW) {
if (event->len != 0 ||
event->cookie != 0 ||
event->wd != -1) {
tst_resm(TFAIL,
"invalid overflow event: "
"wd=%d mask=%x "
"cookie=%u len=%u",
event->wd, event->mask,
event->cookie,
event->len);
stop = 1;
break;
}
if ((int)(i + EVENT_SIZE) != len) {
tst_resm(TFAIL,
"overflow event is not last");
stop = 1;
break;
}
tst_resm(TPASS, "get event: wd=%d "
"mask=%x cookie=%u len=%u",
event->wd, event->mask,
event->cookie, event->len);
stop = 1;
break;
}
i += EVENT_SIZE + event->len;
}
}
}
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
int lc;
char wbuf[BUFSIZ], rbuf[BUFSIZ];
int fd;
tst_parse_opts(argc, argv, NULL, NULL);
/* global setup */
setup();
/* The following loop checks looping state if -i option given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset tst_count in case we are looping */
tst_count = 0;
//block1:
tst_resm(TINFO, "Enter Block 1: test to check if write "
"corrupts the file when write fails");
fd = creat(filename, 0644);
if (fd < 0) {
tst_resm(TBROK, "creating a new file failed");
cleanup();
}
(void)memset(wbuf, '0', 100);
if (write(fd, wbuf, 100) == -1) {
tst_resm(TFAIL, "failed to write to %s", filename);
cleanup();
}
if (write(fd, bad_addr, 100) != -1) {
tst_resm(TFAIL, "write(2) failed to fail");
cleanup();
}
close(fd);
if ((fd = open(filename, O_RDONLY)) == -1) {
tst_resm(TBROK, "open(2) failed, errno: %d", errno);
cleanup();
}
if (read(fd, rbuf, 100) == -1) {
tst_resm(TBROK, "read(2) failed, errno: %d", errno);
cleanup();
}
if (memcmp(wbuf, rbuf, 100) == 0) {
tst_resm(TPASS, "failure of write(2) didnot corrupt "
"the file");
} else {
tst_resm(TFAIL, "failure of write(2) corrupted the "
"file");
}
tst_resm(TINFO, "Exit block 1");
close(fd);
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
struct stat stat_buf; /* stat(2) struct contents */
int lc;
int ind; /* counter variable for chmod(2) tests */
int mode; /* file mode permission */
TST_TOTAL = sizeof(Modes) / sizeof(int);
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (ind = 0; ind < TST_TOTAL; ind++) {
mode = Modes[ind];
/*
* Call fchmod(2) with different mode permission
* bits to set it for "testfile".
*/
TEST(fchmod(fd, mode));
if (TEST_RETURN == -1) {
tst_resm(TFAIL, "fchmod(%d, %#o) Failed, "
"errno=%d : %s", fd, mode, TEST_ERRNO,
strerror(TEST_ERRNO));
continue;
}
/*
* Get the testfile information using
* fstat(2).
*/
if (fstat(fd, &stat_buf) < 0) {
tst_brkm(TFAIL, cleanup,
"fstat(2) of "
"%s failed, errno:%d",
TESTFILE, TEST_ERRNO);
}
stat_buf.st_mode &= ~S_IFREG;
/*
* Check for expected mode permissions
* on testfile.
*/
if (stat_buf.st_mode == mode) {
tst_resm(TPASS,
"Functionality of "
"fchmod(%d, %#o) successful",
fd, mode);
} else {
tst_resm(TFAIL, "%s: Incorrect modes "
"0%03o, Expected 0%03o",
TESTFILE, stat_buf.st_mode,
mode);
}
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
pid_t pid1;
int lc;
int rval;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); ++lc) {
tst_count = 0;
for (testno = 0; testno < TST_TOTAL; ++testno) {
pid1 = fork(); //call to fork()
if (pid1 == -1) {
tst_brkm(TFAIL | TERRNO, cleanup,
"fork failed");
} else if (pid1 == 0) {
switch (unshare(CLONE_FILES)) {
case 0:
printf("unshare with CLONE_FILES call "
"succeeded\n");
rval = 0;
break;
case -1:
if (errno == ENOSYS)
rval = 1;
else {
perror("unshare failed");
rval = 2;
}
}
exit(rval);
} else {
SAFE_WAIT(cleanup, &rval);
if (rval != 0 && WIFEXITED(rval)) {
switch (WEXITSTATUS(rval)) {
case 1:
tst_brkm(TCONF, cleanup,
"unshare not supported in "
"kernel");
break;
default:
tst_brkm(TFAIL, cleanup,
"unshare failed");
}
}
}
pid1 = fork();
if (pid1 == -1) {
tst_brkm(TFAIL | TERRNO, cleanup,
"fork failed");
} else if (pid1 == 0) {
switch (unshare(CLONE_FS)) {
case 0:
printf("unshare with CLONE_FS call "
"succeeded\n");
rval = 0;
break;
case -1:
if (errno == ENOSYS)
rval = 1;
else {
perror("unshare failed");
rval = 2;
}
}
exit(rval);
} else {
SAFE_WAIT(cleanup, &rval);
if (rval != 0 && WIFEXITED(rval)) {
switch (WEXITSTATUS(rval)) {
case 1:
tst_brkm(TCONF, cleanup,
"unshare not supported in "
"kernel");
break;
default:
tst_brkm(TFAIL, cleanup,
"unshare failed");
}
}
}
pid1 = fork();
if (pid1 == -1) {
tst_brkm(TFAIL | TERRNO, cleanup,
"fork() failed.");
} else if (pid1 == 0) {
switch (unshare(CLONE_NEWNS)) {
case 0:
printf("unshare call with CLONE_NEWNS "
"succeeded\n");
rval = 0;
break;
case -1:
if (errno == ENOSYS)
rval = 1;
else {
perror("unshare failed");
rval = 2;
}
}
exit(rval);
} else {
SAFE_WAIT(cleanup, &rval);
if (rval != 0 && WIFEXITED(rval)) {
switch (WEXITSTATUS(rval)) {
case 1:
tst_brkm(TCONF, cleanup,
"unshare not supported in "
"kernel");
break;
default:
tst_brkm(TFAIL, cleanup,
"unshare failed");
}
}
}
}
}
cleanup();
tst_exit();
}
int main(int argc, char *argv[])
{
int lc;
int i;
tst_parse_opts(argc, argv, NULL, NULL);
#ifdef UCLINUX
argv0 = argv[0];
maybe_run_child(&child_pid, "nd", 1, &sem_id_1);
maybe_run_child(&child_cnt, "ndd", 2, &sem_id_1, &sem_op);
#endif
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
/*
* Set up any conditions if needed
*/
if (TC[i].func_setup != NULL) {
/* call the setup function */
switch (TC[i].cmd) {
case GETNCNT:
(*TC[i].func_setup) (-ONE);
break;
case GETZCNT:
(*TC[i].func_setup) (0);
break;
default:
(*TC[i].func_setup) ();
break;
}
}
TEST(semctl(*(TC[i].semid), TC[i].semnum, TC[i].cmd,
TC[i].arg));
if (TEST_RETURN == -1) {
tst_resm(TFAIL, "%s call failed - errno = %d "
": %s", TCID, TEST_ERRNO,
strerror(TEST_ERRNO));
} else {
/*
* call the appropriate test function
* and pass the return value where it
* is needed to perform certain tests.
*/
switch (TC[i].cmd) {
case GETNCNT:
case GETZCNT:
case GETPID:
case GETVAL:
case IPC_INFO:
case SEM_STAT:
(*TC[i].func_test) (TEST_RETURN);
break;
default:
(*TC[i].func_test) ();
break;
}
}
/*
* If testing GETNCNT or GETZCNT, clean up the children.
*/
switch (TC[i].cmd) {
case GETNCNT:
case GETZCNT:
kill_all_children();
break;
}
}
/*
* recreate the semaphore resource if looping
*/
if (TEST_LOOPING(lc)) {
sem_id_1 = semget(semkey, PSEMS,
IPC_CREAT | IPC_EXCL | SEM_RA);
if (sem_id_1 == -1)
tst_brkm(TBROK, cleanup,
"couldn't recreate " "semaphore");
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
char *node_name; /* ptr. for node name created */
char *test_desc; /* test specific error message */
int ind; /* counter to test different test conditions */
tst_parse_opts(ac, av, NULL, NULL);
/*
* Invoke setup function to call individual test setup functions
* for the test which run as root/super-user.
*/
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (ind = 0; Test_cases[ind].desc != NULL; ind++) {
node_name = Test_cases[ind].pathname;
test_desc = Test_cases[ind].desc;
#if !defined(UCLINUX)
if (node_name == High_address_node) {
node_name = get_high_address();
}
#endif
/*
* Call mknod(2) to test different test conditions.
* verify that it fails with -1 return value and
* sets appropriate errno.
*/
TEST(mknod(node_name, MODE_RWX, 0));
/* Check return code from mknod(2) */
if (TEST_RETURN != -1) {
tst_resm(TFAIL,
"mknod() returned %ld, expected "
"-1, errno:%d", TEST_RETURN,
Test_cases[ind].exp_errno);
continue;
}
if (TEST_ERRNO == Test_cases[ind].exp_errno) {
tst_resm(TPASS, "mknod() fails, %s, errno:%d",
test_desc, TEST_ERRNO);
} else {
tst_resm(TFAIL, "mknod() fails, %s, errno:%d, "
"expected errno:%d", test_desc,
TEST_ERRNO, Test_cases[ind].exp_errno);
}
}
}
/*
* Invoke cleanup() to delete the test directories created
* in the setup().
*/
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int child_pid;
int status;
int rval;
int lc;
tst_parse_opts(ac, av, NULL, NULL);
#ifdef UCLINUX
maybe_run_child(&do_child, "");
#endif
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
/* Child is in new session we are not alowed to change pgid */
if ((child_pid = FORK_OR_VFORK()) == -1)
tst_brkm(TBROK, cleanup, "fork() failed");
if (child_pid == 0) {
#ifdef UCLINUX
if (self_exec(av[0], "") < 0)
tst_brkm(TBROK, cleanup, "self_exec failed");
#else
do_child();
#endif
}
TST_SAFE_CHECKPOINT_WAIT(cleanup, 0);
rval = setpgid(child_pid, getppid());
if (rval == -1 && errno == EPERM) {
tst_resm(TPASS, "setpgid failed with EPERM");
} else {
tst_resm(TFAIL,
"retval %d, errno %d, expected errno %d",
rval, errno, EPERM);
}
TST_SAFE_CHECKPOINT_WAKE(cleanup, 0);
if (wait(&status) < 0)
tst_resm(TFAIL | TERRNO, "wait() for child 1 failed");
if (!(WIFEXITED(status)) || (WEXITSTATUS(status) != 0))
tst_resm(TFAIL, "child 1 failed with status %d",
WEXITSTATUS(status));
/* Child after exec() we are no longer allowed to set pgid */
if ((child_pid = FORK_OR_VFORK()) == -1)
tst_resm(TFAIL, "Fork failed");
if (child_pid == 0) {
if (execlp(TEST_APP, TEST_APP, NULL) < 0)
perror("exec failed");
exit(127);
}
TST_SAFE_CHECKPOINT_WAIT(cleanup, 0);
rval = setpgid(child_pid, getppid());
if (rval == -1 && errno == EACCES) {
tst_resm(TPASS, "setpgid failed with EACCES");
} else {
tst_resm(TFAIL,
"retval %d, errno %d, expected errno %d",
rval, errno, EACCES);
}
TST_SAFE_CHECKPOINT_WAKE(cleanup, 0);
if (wait(&status) < 0)
tst_resm(TFAIL | TERRNO, "wait() for child 2 failed");
if (!(WIFEXITED(status)) || (WEXITSTATUS(status) != 0))
tst_resm(TFAIL, "child 2 failed with status %d",
WEXITSTATUS(status));
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
struct stat stat_buf; /* stat(2) struct contents */
int lc;
int i;
uid_t user_id; /* user id of the user set for testfile */
gid_t group_id; /* group id of the user set for testfile */
int test_flag; /* test condition specific flag variable */
char *file_name; /* ptr. for test file name */
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
file_name = test_cases[i].pathname;
user_id = test_cases[i].user_id;
group_id = test_cases[i].group_id;
test_flag = test_cases[i].test_flag;
/*
* Call chown(2) with different user id and
* group id (numeric values) to set it on testfile.
*/
TEST(CHOWN(cleanup, file_name, user_id, group_id));
if (TEST_RETURN == -1) {
tst_resm(TFAIL | TTERRNO,
"chown(%s, ..) failed", file_name);
continue;
}
/*
* Get the testfile information using stat(2).
*/
if (stat(file_name, &stat_buf) < 0) {
tst_brkm(TFAIL, cleanup, "stat(2) of "
"%s failed, errno:%d",
file_name, TEST_ERRNO);
}
/*
* Check for expected Ownership ids
* set on testfile.
*/
if (stat_buf.st_uid != user_id ||
stat_buf.st_gid != group_id) {
tst_brkm(TFAIL, cleanup, "%s: incorrect"
" ownership set, Expected %d "
"%d", file_name,
user_id, group_id);
}
/*
* Verify that S_ISUID/S_ISGID bits set on the
* testfile(s) in setup()s are cleared by
* chown().
*/
if (test_flag == 1 &&
(stat_buf.st_mode & (S_ISUID | S_ISGID)) != 0) {
tst_resm(TFAIL,
"%s: incorrect mode "
"permissions %#o, Expected "
"%#o", file_name, NEW_PERMS1,
EXP_PERMS);
} else if (test_flag == 2
&& (stat_buf.st_mode & S_ISGID) == 0) {
tst_resm(TFAIL,
"%s: Incorrect mode "
"permissions %#o, Expected "
"%#o", file_name,
stat_buf.st_mode, NEW_PERMS2);
} else {
tst_resm(TPASS,
"chown(%s, ..) succeeded",
file_name);
}
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int exp_eno;
int lc;
char osname[OSNAMESZ];
int osnamelth, status;
int name[] = { CTL_KERN, KERN_OSTYPE };
pid_t pid;
struct passwd *ltpuser;
tst_parse_opts(ac, av, NULL, NULL);
setup();
if ((tst_kvercmp(2, 6, 32)) <= 0) {
exp_eno = EPERM;
} else {
/* ^^ Look above this warning. ^^ */
tst_resm(TINFO,
"this test's results are based on potentially undocumented behavior in the kernel. read the NOTE in the source file for more details");
exp_eno = EACCES;
exp_enos[0] = EACCES;
}
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset tst_count in case we are looping */
tst_count = 0;
strcpy(osname, "Linux");
osnamelth = SIZE(osname);
TEST(sysctl(name, SIZE(name), 0, 0, osname, osnamelth));
if (TEST_RETURN != -1) {
tst_resm(TFAIL, "sysctl(2) succeeded unexpectedly");
} else {
if (TEST_ERRNO == exp_eno) {
tst_resm(TPASS | TTERRNO, "Got expected error");
} else if (errno == ENOSYS) {
tst_resm(TCONF,
"You may need to make CONFIG_SYSCTL_SYSCALL=y"
" to your kernel config.");
} else {
tst_resm(TFAIL | TTERRNO,
"Got unexpected error");
}
}
osnamelth = SIZE(osname);
if ((ltpuser = getpwnam("nobody")) == NULL) {
tst_brkm(TBROK, cleanup, "getpwnam() failed");
}
/* set process ID to "ltpuser1" */
if (seteuid(ltpuser->pw_uid) == -1) {
tst_brkm(TBROK, cleanup,
"seteuid() failed, errno %d", errno);
}
if ((pid = FORK_OR_VFORK()) == -1) {
tst_brkm(TBROK, cleanup, "fork() failed");
}
if (pid == 0) {
TEST(sysctl(name, SIZE(name), 0, 0, osname, osnamelth));
if (TEST_RETURN != -1) {
tst_resm(TFAIL, "call succeeded unexpectedly");
} else {
if (TEST_ERRNO == exp_eno) {
tst_resm(TPASS | TTERRNO,
"Got expected error");
} else if (TEST_ERRNO == ENOSYS) {
tst_resm(TCONF,
"You may need to make CONFIG_SYSCTL_SYSCALL=y"
" to your kernel config.");
} else {
tst_resm(TFAIL | TTERRNO,
"Got unexpected error");
}
}
cleanup();
} else {
/* wait for the child to finish */
wait(&status);
}
/* set process ID back to root */
if (seteuid(0) == -1) {
tst_brkm(TBROK, cleanup, "seteuid() failed");
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
struct itimerval *value, *ovalue;
tst_parse_opts(ac, av, NULL, NULL);
setup(); /* global setup */
/* The following loop checks looping state if -i option given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset tst_count in case we are looping */
tst_count = 0;
/* allocate some space for timer structures */
if ((value = malloc((size_t)sizeof(struct itimerval))) ==
NULL) {
tst_brkm(TBROK, cleanup, "value malloc failed");
}
if ((ovalue = malloc((size_t)sizeof(struct itimerval))) ==
NULL) {
tst_brkm(TBROK, cleanup, "value malloc failed");
}
/* set up some reasonable values */
value->it_value.tv_sec = 30;
value->it_value.tv_usec = 0;
value->it_interval.tv_sec = 0;
value->it_interval.tv_usec = 0;
/*
* issue the system call with the TEST() macro
* ITIMER_REAL = 0, ITIMER_VIRTUAL = 1 and ITIMER_PROF = 2
*/
/* make the first value negative to get a failure */
TEST(setitimer(-ITIMER_PROF, value, ovalue));
if (TEST_RETURN == 0) {
tst_resm(TFAIL, "call failed to produce expected error "
"- errno = %d - %s", TEST_ERRNO,
strerror(TEST_ERRNO));
continue;
}
switch (TEST_ERRNO) {
case EINVAL:
tst_resm(TPASS, "expected failure - errno = %d - %s",
TEST_ERRNO, strerror(TEST_ERRNO));
break;
default:
tst_resm(TFAIL, "call failed to produce expected error "
"- errno = %d - %s", TEST_ERRNO,
strerror(TEST_ERRNO));
}
/*
* clean up things in case we are looping
*/
free(value);
free(ovalue);
value = NULL;
ovalue = NULL;
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
int gidsetsize; /* total no. of groups */
int i;
char *test_desc; /* test specific error message */
int ngroups_max = sysconf(_SC_NGROUPS_MAX); /* max no. of groups in the current system */
tst_parse_opts(ac, av, NULL, NULL);
groups_list = malloc(ngroups_max * sizeof(GID_T));
if (groups_list == NULL) {
tst_brkm(TBROK, NULL, "malloc failed to alloc %zu errno "
" %d ", ngroups_max * sizeof(GID_T), errno);
}
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
if (Test_cases[i].setupfunc != NULL) {
Test_cases[i].setupfunc();
}
gidsetsize = ngroups_max + Test_cases[i].gsize_add;
test_desc = Test_cases[i].desc;
/*
* Call setgroups() to test different test conditions
* verify that it fails with -1 return value and
* sets appropriate errno.
*/
TEST(SETGROUPS(cleanup, gidsetsize, groups_list));
if (TEST_RETURN != -1) {
tst_resm(TFAIL, "setgroups(%d) returned %ld, "
"expected -1, errno=%d", gidsetsize,
TEST_RETURN, Test_cases[i].exp_errno);
continue;
}
if (TEST_ERRNO == Test_cases[i].exp_errno) {
tst_resm(TPASS,
"setgroups(%d) fails, %s, errno=%d",
gidsetsize, test_desc, TEST_ERRNO);
} else {
tst_resm(TFAIL, "setgroups(%d) fails, %s, "
"errno=%d, expected errno=%d",
gidsetsize, test_desc, TEST_ERRNO,
Test_cases[i].exp_errno);
}
}
}
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
int lc;
struct robust_list_head head;
size_t len_ptr; /* size of structure struct robust_list_head */
tst_parse_opts(argc, argv, NULL, NULL);
setup();
len_ptr = sizeof(struct robust_list_head);
for (lc = 0; TEST_LOOPING(lc); ++lc) {
tst_count = 0;
/*
* The get_robust_list function fails with EFAULT if the size of the
* struct robust_list_head can't be stored in the memory address space
* specified by len_ptr argument, or the head of the robust list can't
* be stored in the memory address space specified by the head_ptr
* argument.
*/
TEST(ltp_syscall(__NR_get_robust_list, 0,
(struct robust_list_head *)&head,
NULL));
if (TEST_RETURN == -1) {
if (TEST_ERRNO == EFAULT)
tst_resm(TPASS,
"get_robust_list failed as expected with "
"EFAULT");
else
tst_resm(TFAIL | TTERRNO,
"get_robust_list failed unexpectedly");
} else
tst_resm(TFAIL,
"get_robust_list succeeded unexpectedly");
TEST(ltp_syscall(__NR_get_robust_list, 0,
NULL,
&len_ptr));
if (TEST_RETURN) {
if (TEST_ERRNO == EFAULT)
tst_resm(TPASS,
"get_robust_list failed as expected with "
"EFAULT");
else
tst_resm(TFAIL | TTERRNO,
"get_robust_list failed unexpectedly");
} else
tst_resm(TFAIL,
"get_robust_list succeeded unexpectedly");
/*
* The get_robust_list function fails with ESRCH if it can't
* find the task specified by the pid argument.
*/
TEST(ltp_syscall(__NR_get_robust_list, unused_pid,
(struct robust_list_head *)&head,
&len_ptr));
if (TEST_RETURN == -1) {
if (TEST_ERRNO == ESRCH)
tst_resm(TPASS,
"get_robust_list failed as expected with "
"ESRCH");
else
tst_resm(TFAIL | TTERRNO,
"get_robust_list failed unexpectedly");
} else
tst_resm(TFAIL,
"get_robust_list succeeded unexpectedly");
TEST(ltp_syscall(__NR_get_robust_list, 0,
(struct robust_list_head **)&head,
&len_ptr));
if (TEST_RETURN == 0)
tst_resm(TPASS, "get_robust_list succeeded");
else
tst_resm(TFAIL | TTERRNO,
"get_robust_list failed unexpectedly");
if (setuid(1) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "setuid(1) failed");
TEST(ltp_syscall(__NR_get_robust_list, 1,
(struct robust_list_head *)&head,
&len_ptr));
if (TEST_RETURN == -1) {
if (TEST_ERRNO == EPERM)
tst_resm(TPASS,
"get_robust_list failed as expected with "
"EPERM");
else
tst_resm(TFAIL | TERRNO,
"get_robust_list failed unexpectedly");
} else
tst_resm(TFAIL,
"get_robust_list succeeded unexpectedly");
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
struct stat buf;
/*
* parse standard options
*/
tst_parse_opts(ac, av, NULL, NULL);
/*
* perform global setup for test
*/
setup();
/*
* check looping state if -i option given
*/
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
/*
* TEST mkdir() base functionality
*/
/* Initialize the test directory name */
sprintf(tstdir1, "tstdir1.%d", getpid());
/* Call mkdir(2) using the TEST macro */
TEST(mkdir(tstdir1, PERMS));
if (TEST_RETURN == -1) {
tst_resm(TFAIL, "mkdir(%s, %#o) Failed",
tstdir1, PERMS);
continue;
}
if (stat(tstdir1, &buf) == -1) {
tst_brkm(TBROK, cleanup, "failed to stat the "
"new directory");
}
/* check the owner */
if (buf.st_uid != geteuid()) {
tst_resm(TFAIL, "mkdir() FAILED to set owner ID"
" as process's effective ID");
continue;
}
/* check the group ID */
if (buf.st_gid != getegid()) {
tst_resm(TFAIL, "mkdir() failed to set group ID"
" as the process's group ID");
continue;
}
tst_resm(TPASS, "mkdir() functionality is correct");
/* clean up things in case we are looping */
if (rmdir(tstdir1) == -1) {
tst_brkm(TBROK, cleanup, "could not remove directory");
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
int fd[2]; /* fds for pipe read/write */
char wrbuf[BUFSIZ], rebuf[BUFSIZ];
int red, written; /* no of chars read and */
/* written to pipe */
int length, greater, forkstat;
int retval = 0, status, e_code;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset tst_count in case we are looping */
tst_count = 0;
TEST(pipe(fd));
if (TEST_RETURN == -1) {
retval = 1;
tst_resm(TFAIL, "pipe creation failed");
continue;
}
strcpy(wrbuf, "abcdefghijklmnopqrstuvwxyz");
length = strlen(wrbuf) + 1;
written = write(fd[1], wrbuf, length);
/* did write write at least some chars */
if ((written < 0) || (written > length)) {
tst_brkm(TBROK, cleanup, "write to pipe failed");
}
forkstat = FORK_OR_VFORK();
if (forkstat == -1) {
tst_brkm(TBROK, cleanup, "fork() failed");
}
if (forkstat == 0) { /* child */
red = safe_read(fd[0], rebuf, written);
/* did read , get at least some chars */
if ((red < 0) || (red > written)) {
tst_brkm(TBROK, cleanup, "read pipe failed");
}
greater = strcmp(rebuf, wrbuf);
/* are the strings written and read equal */
if (greater == 0) {
tst_resm(TPASS, "functionality is correct");
} else {
retval = 1;
tst_resm(TFAIL, "read & write strings do "
"not match");
}
exit(retval);
} else { /* parent */
/* wait for the child to finish */
wait(&status);
/* make sure the child returned a good exit status */
e_code = status >> 8;
if (e_code != 0) {
tst_resm(TFAIL, "Failures reported above");
}
}
}
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
int i, j, sec, usec;
int failflag = 0;
int bflag = 0, nflag = 0, Fflag = 0;
char *optb, *optn, *optF;
struct io_event event;
static struct timespec ts;
struct timeval stv, etv;
option_t options[] = {
{"b:", &bflag, &optb},
{"n:", &nflag, &optn},
{"F:", &Fflag, &optF},
{NULL, NULL, NULL}
};
tst_parse_opts(argc, argv, options, &help);
bufsize = (bflag ? atoi(optb) : 8192);
nr = (nflag ? atoi(optn) : 10);
if (Fflag) {
sprintf(fname, "%s", optF);
} else {
sprintf(fname, "aiofile");
}
setup();
/* TEST 1 */
pos = 0;
gettimeofday(&stv, NULL);
io_prep_pwrite(iocbs[0], fd, srcbuf, bufsize, pos);
for (i = 0; i < nr; i++) {
ts.tv_sec = 30;
ts.tv_nsec = 0;
do {
TEST(io_submit(io_ctx, 1, iocbs));
} while (TEST_RETURN == -EAGAIN);
if (TEST_RETURN < 0) {
tst_resm(TFAIL, "Test 1: io_submit failed - retval=%ld"
", errno=%d", TEST_RETURN, TEST_ERRNO);
failflag = 1;
continue;
}
while (io_getevents(io_ctx, 1, 1, &event, &ts) != 1) ;
gettimeofday(&etv, NULL);
}
if (!failflag) {
sec = etv.tv_sec - stv.tv_sec;
usec = etv.tv_usec - stv.tv_usec;
if (usec < 0) {
usec += 1000000;
sec--;
}
tst_resm(TPASS, "Test 1: %d writes in %3d.%06d sec",
nr, sec, usec);
}
/* TEST 2 */
pos = 0;
failflag = 0;
gettimeofday(&stv, NULL);
io_prep_pread(iocbs[0], fd, dstbuf, bufsize, pos);
for (i = 0; i < nr; i++) {
ts.tv_sec = 30;
ts.tv_nsec = 0;
do {
TEST(io_submit(io_ctx, 1, iocbs));
} while (TEST_RETURN == -EAGAIN);
if (TEST_RETURN < 0) {
tst_resm(TFAIL, "Test 2: io_submit failed - retval=%ld"
", errno=%d", TEST_RETURN, TEST_ERRNO);
failflag = 1;
continue;
}
while (io_getevents(io_ctx, 1, 1, &event, &ts) != 1) ;
gettimeofday(&etv, NULL);
}
if (!failflag) {
sec = etv.tv_sec - stv.tv_sec;
usec = etv.tv_usec - stv.tv_usec;
if (usec < 0) {
usec += 1000000;
sec--;
}
tst_resm(TPASS, "Test 2: %d reads in %3d.%06d sec",
nr, sec, usec);
}
/* TEST 3 */
pos = 0;
failflag = 0;
gettimeofday(&stv, NULL);
for (i = 0; i < nr; i++) {
io_prep_pwrite(iocbs[0], fd, srcbuf, bufsize, pos);
ts.tv_sec = 30;
ts.tv_nsec = 0;
do {
TEST(io_submit(io_ctx, 1, iocbs));
} while (TEST_RETURN == -EAGAIN);
if (TEST_RETURN < 0) {
tst_resm(TFAIL, "Test 3: io_submit failed - retval=%ld"
", errno=%d", TEST_RETURN, TEST_ERRNO);
failflag = 1;
continue;
}
while (io_getevents(io_ctx, 1, 1, &event, &ts) != 1) ;
gettimeofday(&etv, NULL);
}
if (!failflag) {
sec = etv.tv_sec - stv.tv_sec;
usec = etv.tv_usec - stv.tv_usec;
if (usec < 0) {
usec += 1000000;
sec--;
}
tst_resm(TPASS, "Test 3: %d prep,writes in %3d.%06d sec",
nr, sec, usec);
}
/* TEST 4 */
pos = 0;
failflag = 0;
gettimeofday(&stv, NULL);
for (i = 0; i < nr; i++) {
io_prep_pread(iocbs[0], fd, dstbuf, bufsize, pos);
ts.tv_sec = 30;
ts.tv_nsec = 0;
do {
TEST(io_submit(io_ctx, 1, iocbs));
} while (TEST_RETURN == -EAGAIN);
if (TEST_RETURN < 0) {
tst_resm(TFAIL, "Test 4: io_submit failed - retval=%ld"
", errno=%d", TEST_RETURN, TEST_ERRNO);
failflag = 1;
continue;
}
while (io_getevents(io_ctx, 1, 1, &event, &ts) != 1) ;
gettimeofday(&etv, NULL);
}
if (!failflag) {
sec = etv.tv_sec - stv.tv_sec;
usec = etv.tv_usec - stv.tv_usec;
if (usec < 0) {
usec += 1000000;
sec--;
}
tst_resm(TPASS, "Test 4: %d prep,reads in %3d.%06d sec",
nr, sec, usec);
}
/* TEST 5 */
pos = 0;
failflag = 0;
gettimeofday(&stv, NULL);
for (i = 0; i < nr; i++) {
io_prep_pwrite(iocbs[0], fd, srcbuf, bufsize, pos);
ts.tv_sec = 30;
ts.tv_nsec = 0;
do {
TEST(io_submit(io_ctx, 1, iocbs));
} while (TEST_RETURN == -EAGAIN);
if (TEST_RETURN < 0) {
tst_resm(TFAIL, "Test 5: write io_submit failed - "
"retval=%ld, errno=%d", TEST_RETURN,
TEST_ERRNO);
failflag = 1;
continue;
}
while (io_getevents(io_ctx, 1, 1, &event, &ts) != 1) ;
io_prep_pread(iocbs[0], fd, dstbuf, bufsize, pos);
ts.tv_sec = 30;
ts.tv_nsec = 0;
do {
TEST(io_submit(io_ctx, 1, iocbs));
} while (TEST_RETURN == -EAGAIN);
if (TEST_RETURN < 0) {
tst_resm(TFAIL, "Test 5: read io_submit failed - "
"retval=%ld, errno=%d", TEST_RETURN,
TEST_ERRNO);
failflag = 1;
continue;
}
while (io_getevents(io_ctx, 1, 1, &event, &ts) != 1) ;
gettimeofday(&etv, NULL);
}
if (!failflag) {
sec = etv.tv_sec - stv.tv_sec;
usec = etv.tv_usec - stv.tv_usec;
if (usec < 0) {
usec += 1000000;
sec--;
}
tst_resm(TPASS, "Test 5: %d reads and writes in %3d.%06d sec",
nr, sec, usec);
}
/* TEST 6 */
pos = 0;
failflag = 0;
gettimeofday(&stv, NULL);
for (i = 0; i < nr; i++) {
io_prep_pwrite(iocbs[0], fd, srcbuf, bufsize, pos);
ts.tv_sec = 30;
ts.tv_nsec = 0;
do {
TEST(io_submit(io_ctx, 1, iocbs));
} while (TEST_RETURN == -EAGAIN);
if (TEST_RETURN < 0) {
tst_resm(TFAIL, "Test 6: write io_submit failed - "
"retval=%ld, errno=%d", TEST_RETURN,
TEST_ERRNO);
failflag = 1;
continue;
}
while (io_getevents(io_ctx, 1, 1, &event, &ts) != 1) ;
io_prep_pread(iocbs[0], fd, dstbuf, bufsize, pos);
ts.tv_sec = 30;
ts.tv_nsec = 0;
do {
TEST(io_submit(io_ctx, 1, iocbs));
} while (TEST_RETURN == -EAGAIN);
if (TEST_RETURN < 0) {
tst_resm(TFAIL, "Test 6: read io_submit failed - "
"retval=%ld, errno=%d", TEST_RETURN,
TEST_ERRNO);
failflag = 1;
continue;
}
while (io_getevents(io_ctx, 1, 1, &event, &ts) != 1) ;
for (j = 0; j < bufsize; j++) {
if (srcbuf[j] != dstbuf[j]) {
tst_resm(TFAIL, "Test 6: compare failed - "
"read: %c, " "actual: %c",
dstbuf[j], srcbuf[j]);
break;
}
}
gettimeofday(&etv, NULL);
}
if (!failflag) {
sec = etv.tv_sec - stv.tv_sec;
usec = etv.tv_usec - stv.tv_usec;
if (usec < 0) {
usec += 1000000;
sec--;
}
tst_resm(TPASS, "Test 6: %d read,write,verify in %d.%06d sec",
i, sec, usec);
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc, i;
int len;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
/*
* generate events
*/
for (i = 0; i < MAX_EVENTS + 1; i++) {
sprintf(fname, "fname_%d", i);
fd = SAFE_OPEN(cleanup, fname, O_RDWR | O_CREAT, 0644);
SAFE_CLOSE(cleanup, fd);
}
while (1) {
/*
* get list on events
*/
len = read(fd_notify, &event, sizeof(event));
if (len < 0) {
if (errno == -EAGAIN) {
tst_resm(TFAIL, "Overflow event not "
"generated!\n");
break;
}
tst_brkm(TBROK | TERRNO, cleanup,
"read of notification event failed");
break;
}
if (event.fd != FAN_NOFD)
close(event.fd);
/*
* check events
*/
if (event.mask != FAN_OPEN &&
event.mask != FAN_Q_OVERFLOW) {
tst_resm(TFAIL,
"get event: mask=%llx (expected %llx)"
"pid=%u fd=%d",
(unsigned long long)event.mask,
(unsigned long long)FAN_OPEN,
(unsigned)event.pid, event.fd);
break;
}
if (event.mask == FAN_Q_OVERFLOW) {
if (event.fd != FAN_NOFD) {
tst_resm(TFAIL,
"invalid overflow event: "
"mask=%llx pid=%u fd=%d",
(unsigned long long)event.mask,
(unsigned)event.pid,
event.fd);
break;
}
tst_resm(TPASS,
"get event: mask=%llx pid=%u fd=%d",
(unsigned long long)event.mask,
(unsigned)event.pid, event.fd);
break;
}
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
/*
* TEST CASE:
* Dont change either real or effective gid
*/
gid = getgid();
GID16_CHECK(gid, setregid, NULL);
egid = getegid();
GID16_CHECK(egid, setregid, NULL);
TEST(SETREGID(NULL, -1, -1));
if (TEST_RETURN == -1) {
tst_resm(TFAIL,
"setregid - Dont change either real or effective gid failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
} else {
tst_resm(TPASS,
"setregid - Dont change either real or effective gid returned %ld",
TEST_RETURN);
}
/*
* TEST CASE:
* change effective to effective gid
*/
TEST(SETREGID(NULL, -1, egid));
if (TEST_RETURN == -1) {
tst_resm(TFAIL,
"setregid - change effective to effective gid failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
} else {
tst_resm(TPASS,
"setregid - change effective to effective gid returned %ld",
TEST_RETURN);
}
/*
* TEST CASE:
* change real to real gid
*/
TEST(SETREGID(NULL, gid, -1));
if (TEST_RETURN == -1) {
tst_resm(TFAIL,
"setregid - change real to real gid failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
} else {
tst_resm(TPASS,
"setregid - change real to real gid returned %ld",
TEST_RETURN);
}
/*
* TEST CASE:
* change effective to real gid
*/
TEST(SETREGID(NULL, -1, gid));
if (TEST_RETURN == -1) {
tst_resm(TFAIL,
"setregid - change effective to real gid failed, errno=%d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
} else {
tst_resm(TPASS,
"setregid - change effective to real gid returned %ld",
TEST_RETURN);
}
/*
* TEST CASE:
* try to change real to current real
*/
TEST(SETREGID(NULL, gid, gid));
if (TEST_RETURN == -1) {
tst_resm(TFAIL | TTERRNO, "setregid failed");
} else {
tst_resm(TPASS, "setregid return %ld",
TEST_RETURN);
}
}
tst_exit();
}
int main(int ac, char **av)
{
int lc;
int rval;
pid_t pid, pid1;
int status;
/*
* parse standard options
*/
tst_parse_opts(ac, av, NULL, NULL);
/*
* perform global setup for test
*/
setup();
/*
* check looping state if -i option given
*/
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
if ((pid = FORK_OR_VFORK()) == -1) {
tst_brkm(TBROK, cleanup, "fork() #1 failed");
}
if (pid == 0) { /* first child */
/* set to nobody */
rval = setreuid(nobody_uid, nobody_uid);
if (rval < 0) {
tst_resm(TWARN, "setreuid failed to "
"to set the real uid to %d and "
"effective uid to %d",
nobody_uid, nobody_uid);
perror("setreuid");
exit(1);
}
/* create the a directory with 0700 permits */
if (mkdir(fdir, PERMS) == -1) {
tst_resm(TWARN, "mkdir(%s, %#o) Failed",
fdir, PERMS);
exit(1);
}
/* create "old" file under it */
SAFE_TOUCH(cleanup, fname, 0700, NULL);
exit(0);
}
/* wait for child to exit */
wait(&status);
if (!WIFEXITED(status) || (WEXITSTATUS(status) != 0)) {
tst_brkm(TBROK, cleanup, "First child failed to set "
"up conditions for the test");
}
if ((pid1 = FORK_OR_VFORK()) == -1) {
tst_brkm(TBROK, cleanup, "fork() #2 failed");
}
if (pid1 == 0) { /* second child */
/* set to bin */
if ((rval = seteuid(bin_uid)) == -1) {
tst_resm(TWARN, "seteuid() failed");
perror("setreuid");
exit(1);
}
/* create "new" directory */
if (mkdir(mdir, PERMS) == -1) {
tst_resm(TWARN, "mkdir(%s, %#o) failed",
mdir, PERMS);
exit(1);
}
SAFE_TOUCH(cleanup, mname, 0700, NULL);
/* rename "old" to "new" */
TEST(rename(fname, mname));
if (TEST_RETURN != -1) {
tst_resm(TFAIL, "call succeeded unexpectedly");
continue;
}
if (TEST_ERRNO != EACCES) {
tst_resm(TFAIL, "Expected EACCES got %d",
TEST_ERRNO);
} else {
tst_resm(TPASS, "rename() returned EACCES");
}
/* set the process id back to root */
if (seteuid(0) == -1) {
tst_resm(TWARN, "seteuid(0) failed");
exit(1);
}
/* clean up things in case we are looping */
SAFE_UNLINK(cleanup, fname);
SAFE_UNLINK(cleanup, mname);
SAFE_RMDIR(cleanup, fdir);
SAFE_RMDIR(cleanup, mdir);
} else {
/* parent - let the second child carry on */
waitpid(pid1, &status, 0);
if (!WIFEXITED(status) || (WEXITSTATUS(status) != 0)) {
exit(WEXITSTATUS(status));
} else {
exit(0);
}
}
}
/*
* cleanup and exit
*/
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
int i;
pid_t pid;
void do_child();
tst_parse_opts(ac, av, NULL, NULL);
#ifdef UCLINUX
maybe_run_child(&do_child_uclinux, "dd", &i_uclinux, &sem_id_1);
#endif
setup(); /* global setup */
/* The following loop checks looping state if -i option given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset tst_count in case we are looping */
tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
/* initialize the s_buf buffer */
s_buf.sem_op = TC[i].op;
s_buf.sem_flg = TC[i].flg;
s_buf.sem_num = TC[i].num;
/* initialize all of the primitive semaphores */
if (semctl(sem_id_1, TC[i].num, SETVAL, TC[i].semunptr)
== -1) {
tst_brkm(TBROK, cleanup, "semctl() failed");
}
if ((pid = FORK_OR_VFORK()) == -1) {
tst_brkm(TBROK, cleanup, "could not fork");
}
if (pid == 0) { /* child */
#ifdef UCLINUX
if (self_exec(av[0], "dd", i, sem_id_1) < 0) {
tst_brkm(TBROK, cleanup,
"could not self_exec");
}
#else
do_child(i);
#endif
} else {
TST_PROCESS_STATE_WAIT(cleanup, pid, 'S');
/*
* If we are testing for EIDRM then remove
* the semaphore, else send a signal that
* must be caught as we are testing for
* EINTR.
*/
if (TC[i].error == EIDRM) {
/* remove the semaphore resource */
rm_sema(sem_id_1);
} else {
SAFE_KILL(cleanup, pid, SIGHUP);
}
/* let the child carry on */
waitpid(pid, NULL, 0);
}
/*
* recreate the semaphore resource if needed
*/
if (TC[i].error == EINTR) {
continue;
}
if ((sem_id_1 = semget(semkey, PSEMS, IPC_CREAT |
IPC_EXCL | SEM_RA)) == -1) {
tst_brkm(TBROK, cleanup, "couldn't recreate "
"semaphore");
}
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
pid_t pid, pid1;
int status;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
if ((pid = FORK_OR_VFORK()) < 0) {
tst_brkm(TBROK, cleanup, "first fork failed");
}
if (pid == 0) {
if (setreuid(nobody_uid, nobody_uid) != 0) {
perror("setreuid failed in child #1");
exit(1);
}
if (mkdir(good_dir, 00700) != 0) {
perror("mkdir failed in child #1");
exit(1);
}
exit(0);
}
wait(&status);
if ((pid1 = FORK_OR_VFORK()) < 0)
tst_brkm(TBROK, cleanup, "second fork failed");
if (pid1 == 0) { /* second child */
int rval;
/*
* set the child's ID to ltpuser2 using seteuid()
* so that the ID can be changed back after the
* TEST call is made.
*/
if (seteuid(bin_uid) != 0) {
perror("setreuid failed in child #2");
exit(1);
}
TEST(chdir(good_dir));
if (TEST_RETURN != -1) {
printf("call succeeded unexpectedly\n");
rval = 1;
} else if (TEST_ERRNO != EACCES) {
printf("didn't get EACCES as expected; got ");
rval = 1;
} else {
printf("got EACCES as expected\n");
rval = 0;
}
/* Only really required with vfork. */
if (seteuid(0) != 0) {
perror("seteuid(0) failed");
rval = 1;
}
exit(rval);
} else {
if (wait(&status) == -1)
tst_brkm(TBROK | TERRNO, cleanup,
"wait failed");
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
tst_brkm(TBROK, cleanup,
"child exited abnormally");
tst_resm(TPASS, "child reported success");
}
if (rmdir(good_dir) == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"rmdir(%s) failed", good_dir);
}
}
cleanup();
tst_exit();
}
/*--------------------------------------------------------------------*/
int main(int argc, char **argv)
{
/***** BEGINNING OF MAIN. *****/
int pid, npid;
int nsig, exno, nexno, status;
int ret_val = 0;
int core;
void chsig();
#ifdef UCLINUX
tst_parse_opts(argc, argv, NULL, NULL);
maybe_run_child(&do_child, "dd", &temp, &sig);
#endif
setup();
//tempdir(); /* move to new directory */ 12/20/2003
blenter();
exno = 1;
if (sigset(SIGCHLD, chsig) == SIG_ERR) {
fprintf(temp, "\tsigset failed, errno = %d\n", errno);
fail_exit();
}
for (sig = 1; sig < 14; sig++) {
fflush(temp);
chflag = 0;
pid = FORK_OR_VFORK();
if (pid < 0) {
forkfail();
}
if (pid == 0) {
#ifdef UCLINUX
if (self_exec(argv[0], "dd", temp, sig) < 0) {
tst_brkm(TBROK, NULL, "self_exec FAILED - "
"terminating test.");
}
#else
do_child();
#endif
} else {
//fprintf(temp, "Testing signal %d\n", sig);
while (!chflag) /* wait for child */
sleep(1);
kill(pid, sig); /* child should ignroe this sig */
kill(pid, SIGCHLD); /* child should exit */
#ifdef BCS
while ((npid = wait(&status)) != pid
|| (npid == -1 && errno == EINTR)) ;
if (npid != pid) {
fprintf(temp,
"wait error: wait returned wrong pid\n");
ret_val = 1;
}
#else
while ((npid = waitpid(pid, &status, 0)) != -1
|| errno == EINTR) ;
#endif
/*
nsig = status & 0177;
core = status & 0200;
nexno = (status & 0xff00) >> 8;
*/
/***** LTP Port *****/
nsig = WTERMSIG(status);
#ifdef WCOREDUMP
core = WCOREDUMP(status);
#endif
nexno = WIFEXITED(status);
/***** ** ** *****/
/* nsig is the signal number returned by wait
it should be 0, except when sig = 9 */
if ((sig == 9) && (nsig != sig)) {
fprintf(temp, "wait error: unexpected signal"
" returned when the signal sent was 9"
" The status of the process is %d \n",
status);
ret_val = 1;
}
if ((sig != 9) && (nsig != 0)) {
fprintf(temp, "wait error: unexpected signal "
"returned, the status of the process is "
"%d \n", status);
ret_val = 1;
}
/* nexno is the exit number returned by wait
it should be 1, except when sig = 9 */
if (sig == 9)
if (nexno != 0) {
fprintf(temp, "signal error: unexpected"
" exit number returned when"
" signal sent was 9, the status"
" of the process is %d \n",
status);
ret_val = 1;
} else;
else if (nexno != 1) {
fprintf(temp, "signal error: unexpected exit "
"number returned,the status of the"
" process is %d\n", status);
ret_val = 1;
}
}
}
if (ret_val)
local_flag = FAILED;
/*--------------------------------------------------------------------*/
anyfail();
tst_exit();
} /******** END OF MAIN. ********/
int main(int ac, char **av)
{
int lc;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
int ret, len, i = 0, test_num = 0;
tst_count = 0;
if (fanotify_mark(fd_notify, FAN_MARK_ADD, FAN_ACCESS |
FAN_MODIFY | FAN_CLOSE | FAN_OPEN |
FAN_EVENT_ON_CHILD | FAN_ONDIR, AT_FDCWD,
".") < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"fanotify_mark (%d, FAN_MARK_ADD, FAN_ACCESS | "
"FAN_MODIFY | FAN_CLOSE | FAN_OPEN | "
"FAN_EVENT_ON_CHILD | FAN_ONDIR, AT_FDCWD, '.') "
"failed", fd_notify);
}
/*
* generate sequence of events
*/
fd = SAFE_OPEN(cleanup, fname, O_RDWR | O_CREAT, 0700);
event_set[tst_count] = FAN_OPEN;
tst_count++;
SAFE_WRITE(cleanup, 1, fd, fname, strlen(fname));
event_set[tst_count] = FAN_MODIFY;
tst_count++;
SAFE_CLOSE(cleanup, fd);
event_set[tst_count] = FAN_CLOSE_WRITE;
tst_count++;
/*
* Get list of events so far. We get events here to avoid
* merging of following events with the previous ones.
*/
ret = SAFE_READ(cleanup, 0, fd_notify, event_buf,
EVENT_BUF_LEN);
len = ret;
fd = SAFE_OPEN(cleanup, fname, O_RDONLY);
event_set[tst_count] = FAN_OPEN;
tst_count++;
SAFE_READ(cleanup, 0, fd, buf, BUF_SIZE);
event_set[tst_count] = FAN_ACCESS;
tst_count++;
SAFE_CLOSE(cleanup, fd);
event_set[tst_count] = FAN_CLOSE_NOWRITE;
tst_count++;
/*
* get next events
*/
ret = SAFE_READ(cleanup, 0, fd_notify, event_buf + len,
EVENT_BUF_LEN - len);
len += ret;
/*
* now remove child mark
*/
if (fanotify_mark(fd_notify, FAN_MARK_REMOVE,
FAN_EVENT_ON_CHILD, AT_FDCWD, ".") < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"fanotify_mark (%d, FAN_MARK REMOVE, "
"FAN_EVENT_ON_CHILD, AT_FDCWD, '.') failed",
fd_notify);
}
/*
* Do something to verify events didn't get generated
*/
fd = SAFE_OPEN(cleanup, fname, O_RDONLY);
SAFE_CLOSE(cleanup, fd);
fd = SAFE_OPEN(cleanup, ".", O_RDONLY | O_DIRECTORY);
event_set[tst_count] = FAN_OPEN;
tst_count++;
SAFE_CLOSE(cleanup, fd);
event_set[tst_count] = FAN_CLOSE_NOWRITE;
tst_count++;
/*
* Check events got generated only for the directory
*/
ret = SAFE_READ(cleanup, 0, fd_notify, event_buf + len,
EVENT_BUF_LEN - len);
len += ret;
if (TST_TOTAL != tst_count) {
tst_brkm(TBROK, cleanup,
"TST_TOTAL and tst_count are not equal");
}
tst_count = 0;
/*
* check events
*/
while (i < len) {
struct fanotify_event_metadata *event;
event = (struct fanotify_event_metadata *)&event_buf[i];
if (test_num >= TST_TOTAL) {
tst_resm(TFAIL,
"get unnecessary event: mask=%llx "
"pid=%u fd=%u",
(unsigned long long)event->mask,
(unsigned)event->pid, event->fd);
} else if (!(event->mask & event_set[test_num])) {
tst_resm(TFAIL,
"get event: mask=%llx (expected %llx) "
"pid=%u fd=%u",
(unsigned long long)event->mask,
event_set[test_num],
(unsigned)event->pid, event->fd);
} else if (event->pid != getpid()) {
tst_resm(TFAIL,
"get event: mask=%llx pid=%u "
"(expected %u) fd=%u",
(unsigned long long)event->mask,
(unsigned)event->pid,
(unsigned)getpid(),
event->fd);
} else {
tst_resm(TPASS,
"get event: mask=%llx pid=%u fd=%u",
(unsigned long long)event->mask,
(unsigned)event->pid, event->fd);
}
event->mask &= ~event_set[test_num];
/* No events left in current mask? Go for next event */
if (event->mask == 0) {
i += event->event_len;
close(event->fd);
}
test_num++;
}
for (; test_num < TST_TOTAL; test_num++) {
tst_resm(TFAIL, "didn't get event: mask=%llx",
event_set[test_num]);
}
}
cleanup();
tst_exit();
}
