static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
fd_notify = myinotify_init();
if (fd_notify == -1)
tst_brkm(TBROK|TERRNO, cleanup, "inotify_init() failed");
SAFE_MKDIR(cleanup, TEST_DIR, 00700);
close(SAFE_CREAT(cleanup, TEST_FILE, 00600));
wd_dir = myinotify_add_watch(fd_notify, TEST_DIR, IN_ALL_EVENTS);
if (wd_dir == -1) {
tst_brkm(TBROK|TERRNO, cleanup,
"inotify_add_watch(%d, \"%s\", IN_ALL_EVENTS) [1] failed",
fd_notify, TEST_DIR);
}
reap_wd_dir = 1;
wd_file = myinotify_add_watch(fd_notify, TEST_FILE, IN_ALL_EVENTS);
if (wd_file == -1)
tst_brkm(TBROK|TERRNO, cleanup,
"inotify_add_watch(%d, \"%s\", IN_ALL_EVENTS) [2] failed",
fd_notify, TEST_FILE);
reap_wd_file = 1;
}
/*
* setup() - performs all ONE TIME setup for this test.
*/
void setup()
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
if ((fd_notify = myinotify_init()) < 0) {
if (errno == ENOSYS) {
tst_brkm(TCONF, cleanup,
"inotify is not configured in this kernel.");
} else {
tst_brkm(TBROK|TERRNO, cleanup,
"inotify_init () failed");
}
}
if ((wd = myinotify_add_watch(fd_notify, ".", IN_ALL_EVENTS)) < 0) {
tst_brkm(TBROK|TERRNO, cleanup,
"inotify_add_watch (%d, \".\", IN_ALL_EVENTS) failed",
fd_notify);
};
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
sprintf(fname, "tfile_%d", getpid());
fd = SAFE_OPEN(cleanup, fname, O_RDWR | O_CREAT, 0700);
SAFE_WRITE(cleanup, 1, fd, buf, BUF_SIZE);
SAFE_CLOSE(cleanup, fd);
fd_notify = syscall(__NR_inotify_init1, O_NONBLOCK);
if (fd_notify < 0) {
if (errno == ENOSYS) {
tst_brkm(TCONF, cleanup,
"inotify is not configured in this kernel.");
} else {
tst_brkm(TBROK | TERRNO, cleanup,
"inotify_init failed");
}
}
wd = myinotify_add_watch(fd_notify, fname, IN_ALL_EVENTS);
if (wd < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"inotify_add_watch (%d, %s, IN_ALL_EVENTS) failed",
fd_notify, fname);
};
SAFE_FILE_SCANF(cleanup, "/proc/sys/fs/inotify/max_queued_events",
"%d", &max_events);
}
/*
* setup() - performs all ONE TIME setup for this test.
*/
void setup()
{
/* capture signals */
tst_sig(NOFORK, DEF_HANDLER, cleanup);
/* Pause if that option was specified */
TEST_PAUSE;
/* make a temp directory and cd to it */
tst_tmpdir();
if ((fd_notify = myinotify_init()) < 0) {
if (errno == ENOSYS) {
tst_resm(TCONF,
"inotify is not configured in this kernel.");
tst_resm(TCONF, "Test will not run.");
tst_exit();
} else {
tst_brkm(TBROK, cleanup,
"inotify_init () Failed, errno=%d : %s", errno,
strerror(errno));
}
}
if ((wd = myinotify_add_watch(fd_notify, ".", IN_ALL_EVENTS)) < 0) {
tst_brkm(TBROK, cleanup,
"inotify_add_watch (%d, \".\", IN_ALL_EVENTS)"
"Failed, errno=%d : %s", fd_notify, errno,
strerror(errno));
};
} /* End setup() */
static void verify_inotify(void)
{
int inotify_fd, fd;
pid_t pid;
int i, tests;
pid = SAFE_FORK();
if (pid == 0) {
while (1) {
for (i = 0; i < FILES; i++) {
fd = SAFE_OPEN(names[i], O_CREAT | O_RDWR, 0600);
SAFE_CLOSE(fd);
}
for (i = 0; i < FILES; i++)
SAFE_UNLINK(names[i]);
}
}
for (tests = 0; tests < TEARDOWNS; tests++) {
inotify_fd = myinotify_init1(O_NONBLOCK);
if (inotify_fd < 0)
tst_brk(TBROK | TERRNO, "inotify_init failed");
for (i = 0; i < FILES; i++) {
/*
* Both failure and success are fine since
* files are being deleted in parallel - this
* is what provokes the race we want to test
* for...
*/
myinotify_add_watch(inotify_fd, names[i], IN_MODIFY);
}
SAFE_CLOSE(inotify_fd);
}
/* We survived for given time - test succeeded */
tst_res(TPASS, "kernel survived inotify beating");
/* Kill the child creating / deleting files and wait for it */
SAFE_KILL(pid, SIGKILL);
SAFE_WAIT(NULL);
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
sprintf(fname, "tfile_%d", getpid());
if ((fd = open(fname, O_RDWR | O_CREAT, 0700)) == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"open(%s, O_RDWR|O_CREAT,0700) failed", fname);
}
if ((write(fd, fname, 1)) == -1) {
tst_brkm(TBROK | TERRNO, cleanup, "write(%d, %s, 1) failed",
fd, fname);
}
/* close the file we have open */
if (close(fd) == -1) {
tst_brkm(TBROK, cleanup, "close(%s) failed", fname);
}
if ((fd_notify = myinotify_init()) < 0) {
if (errno == ENOSYS) {
tst_brkm(TCONF, cleanup,
"inotify is not configured in this kernel.");
} else {
tst_brkm(TBROK | TERRNO, cleanup,
"inotify_init failed");
}
}
if ((wd = myinotify_add_watch(fd_notify, fname, IN_ALL_EVENTS)) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"inotify_add_watch (%d, %s, IN_ALL_EVENTS) failed",
fd_notify, fname);
};
}
static void setup(void)
{
int ret;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
fs_type = tst_dev_fs_type();
tst_tmpdir();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to obtain block device");
tst_mkfs(cleanup, device, fs_type, NULL);
if (mkdir(mntpoint, DIR_MODE) < 0) {
tst_brkm(TBROK | TERRNO, cleanup, "mkdir(%s, %#o) failed",
mntpoint, DIR_MODE);
}
/* Call mount(2) */
tst_resm(TINFO, "mount %s to %s fs_type=%s", device, mntpoint, fs_type);
TEST(mount(device, mntpoint, fs_type, 0, NULL));
/* check return code */
if (TEST_RETURN != 0) {
TEST_ERROR_LOG(TEST_ERRNO);
tst_brkm(TBROK | TTERRNO, cleanup, "mount(2) failed");
}
mount_flag = 1;
sprintf(fname, "%s/tfile_%d", mntpoint, getpid());
fd = open(fname, O_RDWR | O_CREAT, 0700);
if (fd == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"open(%s, O_RDWR|O_CREAT,0700) failed", fname);
}
ret = write(fd, fname, 1);
if (ret == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"write(%d, %s, 1) failed", fd, fname);
}
/* close the file we have open */
if (close(fd) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "close(%s) failed", fname);
fd_notify = myinotify_init();
if (fd_notify < 0) {
if (errno == ENOSYS)
tst_brkm(TCONF, cleanup,
"inotify is not configured in this kernel.");
else
tst_brkm(TBROK | TERRNO, cleanup,
"inotify_init failed");
}
wd = myinotify_add_watch(fd_notify, fname, IN_ALL_EVENTS);
if (wd < 0)
tst_brkm(TBROK | TERRNO, cleanup,
"inotify_add_watch (%d, %s, IN_ALL_EVENTS) failed.",
fd_notify, fname);
}
void verify_inotify(void)
{
int ret;
int len, i, test_num;
int test_cnt = 0;
SAFE_MOUNT(tst_device->dev, mntpoint, tst_device->fs_type, 0, NULL);
mount_flag = 1;
wd = myinotify_add_watch(fd_notify, fname, IN_ALL_EVENTS);
if (wd < 0) {
tst_brk(TBROK | TERRNO,
"inotify_add_watch (%d, %s, IN_ALL_EVENTS) failed.",
fd_notify, fname);
}
event_set[test_cnt] = IN_UNMOUNT;
test_cnt++;
event_set[test_cnt] = IN_IGNORED;
test_cnt++;
/*check exit code from inotify_rm_watch */
test_cnt++;
tst_res(TINFO, "umount %s", tst_device->dev);
TEST(tst_umount(mntpoint));
if (TEST_RETURN != 0) {
tst_brk(TBROK, "umount(2) Failed "
"while unmounting errno = %d : %s",
TEST_ERRNO, strerror(TEST_ERRNO));
}
mount_flag = 0;
len = read(fd_notify, event_buf, EVENT_BUF_LEN);
if (len < 0) {
tst_brk(TBROK | TERRNO,
"read(%d, buf, %zu) failed", fd_notify, EVENT_BUF_LEN);
}
/* check events */
test_num = 0;
i = 0;
while (i < len) {
struct inotify_event *event;
event = (struct inotify_event *)&event_buf[i];
if (test_num >= (test_cnt - 1)) {
tst_res(TFAIL,
"get unnecessary event: wd=%d mask=%x "
"cookie=%u len=%u",
event->wd, event->mask,
event->cookie, event->len);
} else if (event_set[test_num] == event->mask) {
tst_res(TPASS, "get event: wd=%d mask=%x"
" cookie=%u len=%u",
event->wd, event->mask,
event->cookie, event->len);
} else {
tst_res(TFAIL, "get event: wd=%d mask=%x "
"(expected %x) cookie=%u len=%u",
event->wd, event->mask,
event_set[test_num],
event->cookie, event->len);
}
test_num++;
i += EVENT_SIZE + event->len;
}
for (; test_num < test_cnt - 1; test_num++) {
tst_res(TFAIL, "don't get event: mask=%x ",
event_set[test_num]);
}
ret = myinotify_rm_watch(fd_notify, wd);
if (ret != -1 || errno != EINVAL)
tst_res(TFAIL | TERRNO,
"inotify_rm_watch (%d, %d) didn't return EINVAL",
fd_notify, wd);
else
tst_res(TPASS, "inotify_rm_watch (%d, %d) returned EINVAL",
fd_notify, wd);
}