[LTP] [PATCH v3 2/3] fanotify: rewrite old cases with new lib
Xiong Zhou
xzhou@redhat.com
Mon Aug 14 16:01:50 CEST 2017
To use SAFE_FANOTIFY_INIT helper.
Signed-off-by: Xiong Zhou <xzhou@redhat.com>
---
testcases/kernel/syscalls/fanotify/fanotify01.c | 520 +++++++++++-------------
testcases/kernel/syscalls/fanotify/fanotify02.c | 320 +++++++--------
testcases/kernel/syscalls/fanotify/fanotify03.c | 248 +++++------
testcases/kernel/syscalls/fanotify/fanotify04.c | 159 +++-----
testcases/kernel/syscalls/fanotify/fanotify05.c | 153 +++----
testcases/kernel/syscalls/fanotify/fanotify06.c | 191 ++++-----
testcases/kernel/syscalls/fanotify/fanotify07.c | 9 +-
7 files changed, 707 insertions(+), 893 deletions(-)
diff --git a/testcases/kernel/syscalls/fanotify/fanotify01.c b/testcases/kernel/syscalls/fanotify/fanotify01.c
index 4799d54..bca0f47 100644
--- a/testcases/kernel/syscalls/fanotify/fanotify01.c
+++ b/testcases/kernel/syscalls/fanotify/fanotify01.c
@@ -35,12 +35,9 @@
#include <errno.h>
#include <string.h>
#include <sys/syscall.h>
-#include "test.h"
-#include "lapi/syscalls.h"
+#include "tst_test.h"
#include "fanotify.h"
-#include "safe_macros.h"
-char *TCID = "fanotify01";
int TST_TOTAL = 12;
#if defined(HAVE_SYS_FANOTIFY_H)
@@ -52,9 +49,6 @@ int TST_TOTAL = 12;
/* reasonable guess as to size of 1024 events */
#define EVENT_BUF_LEN (EVENT_MAX * EVENT_SIZE)
-static void setup(void);
-static void cleanup(void);
-
#define BUF_SIZE 256
static char fname[BUF_SIZE];
static char buf[BUF_SIZE];
@@ -64,308 +58,282 @@ static unsigned long long event_set[EVENT_MAX];
static char event_buf[EVENT_BUF_LEN];
-int main(int ac, char **av)
+void test01(void)
{
- 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, AT_FDCWD, fname) < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_mark (%d, FAN_MARK_ADD, FAN_ACCESS | "
- "FAN_MODIFY | FAN_CLOSE | FAN_OPEN, AT_FDCWD, %s) "
- "failed", fd_notify, fname);
- }
-
- /*
- * generate sequence of events
- */
- 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 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_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++;
+ int ret, len, i = 0, test_num = 0;
- /*
- * get another list of events
- */
- ret = SAFE_READ(cleanup, 0, fd_notify, event_buf + len,
- EVENT_BUF_LEN - len);
- len += ret;
-
- /*
- * Ignore mask testing
- */
-
- /* Ignore access events */
- if (fanotify_mark(fd_notify,
- FAN_MARK_ADD | FAN_MARK_IGNORED_MASK,
- FAN_ACCESS, AT_FDCWD, fname) < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_mark (%d, FAN_MARK_ADD | "
- "FAN_MARK_IGNORED_MASK, FAN_ACCESS, "
- "AT_FDCWD, %s) failed", fd_notify, fname);
- }
-
- fd = SAFE_OPEN(cleanup, fname, O_RDWR);
- event_set[tst_count] = FAN_OPEN;
- tst_count++;
-
- /* This event should be ignored */
- SAFE_READ(cleanup, 0, fd, buf, BUF_SIZE);
+ int tst_count = 0;
- /*
- * get another list of events to verify the last one got ignored
- */
- ret = SAFE_READ(cleanup, 0, fd_notify, event_buf + len,
- EVENT_BUF_LEN - len);
- len += ret;
-
- lseek(fd, 0, SEEK_SET);
- /* Generate modify event to clear ignore mask */
- SAFE_WRITE(cleanup, 1, fd, fname, 1);
- event_set[tst_count] = FAN_MODIFY;
- tst_count++;
-
- /*
- * This event shouldn't be ignored because previous modification
- * should have removed the ignore mask
- */
- 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_WRITE;
- tst_count++;
-
- /* Read events to verify previous access was properly generated */
- ret = SAFE_READ(cleanup, 0, fd_notify, event_buf + len,
- EVENT_BUF_LEN - len);
- len += ret;
+ if (fanotify_mark(fd_notify, FAN_MARK_ADD, FAN_ACCESS | FAN_MODIFY |
+ FAN_CLOSE | FAN_OPEN, AT_FDCWD, fname) < 0) {
+ tst_brk(TBROK | TERRNO,
+ "fanotify_mark (%d, FAN_MARK_ADD, FAN_ACCESS | "
+ "FAN_MODIFY | FAN_CLOSE | FAN_OPEN, AT_FDCWD, %s) "
+ "failed", fd_notify, fname);
+ }
- /*
- * Now ignore open & close events regardless of file
- * modifications
- */
- if (fanotify_mark(fd_notify,
- FAN_MARK_ADD | FAN_MARK_IGNORED_MASK | FAN_MARK_IGNORED_SURV_MODIFY,
- FAN_OPEN | FAN_CLOSE, AT_FDCWD, fname) < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_mark (%d, FAN_MARK_ADD | "
- "FAN_MARK_IGNORED_MASK | "
- "FAN_MARK_IGNORED_SURV_MODIFY, FAN_OPEN | "
- "FAN_CLOSE, AT_FDCWD, %s) failed", fd_notify,
- fname);
- }
+ /*
+ * generate sequence of events
+ */
+ fd = SAFE_OPEN(fname, O_RDONLY);
+ event_set[tst_count] = FAN_OPEN;
+ tst_count++;
+
+ SAFE_READ(0, fd, buf, BUF_SIZE);
+ event_set[tst_count] = FAN_ACCESS;
+ tst_count++;
+
+ SAFE_CLOSE(fd);
+ event_set[tst_count] = FAN_CLOSE_NOWRITE;
+ 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(0, fd_notify, event_buf, EVENT_BUF_LEN);
+ len = ret;
+
+ fd = SAFE_OPEN(fname, O_RDWR | O_CREAT, 0700);
+ event_set[tst_count] = FAN_OPEN;
+ tst_count++;
+
+ SAFE_WRITE(1, fd, fname, strlen(fname));
+ event_set[tst_count] = FAN_MODIFY;
+ tst_count++;
+
+ SAFE_CLOSE(fd);
+ event_set[tst_count] = FAN_CLOSE_WRITE;
+ tst_count++;
+
+ /*
+ * get another list of events
+ */
+ ret = SAFE_READ(0, fd_notify, event_buf + len,
+ EVENT_BUF_LEN - len);
+ len += ret;
+
+ /*
+ * Ignore mask testing
+ */
+
+ /* Ignore access events */
+ if (fanotify_mark(fd_notify,
+ FAN_MARK_ADD | FAN_MARK_IGNORED_MASK,
+ FAN_ACCESS, AT_FDCWD, fname) < 0) {
+ tst_brk(TBROK | TERRNO,
+ "fanotify_mark (%d, FAN_MARK_ADD | "
+ "FAN_MARK_IGNORED_MASK, FAN_ACCESS, "
+ "AT_FDCWD, %s) failed", fd_notify, fname);
+ }
- /* This event should be ignored */
- fd = SAFE_OPEN(cleanup, fname, O_RDWR);
-
- SAFE_WRITE(cleanup, 1, fd, fname, 1);
- event_set[tst_count] = FAN_MODIFY;
- tst_count++;
-
- /* This event should be still ignored */
- SAFE_CLOSE(cleanup, fd);
-
- /* This event should still be ignored */
- fd = SAFE_OPEN(cleanup, fname, O_RDWR);
-
- /* Read events to verify open & close were ignored */
- ret = SAFE_READ(cleanup, 0, fd_notify, event_buf + len,
- EVENT_BUF_LEN - len);
- len += ret;
-
- /* Now remove open and close from ignored mask */
- if (fanotify_mark(fd_notify,
- FAN_MARK_REMOVE | FAN_MARK_IGNORED_MASK,
- FAN_OPEN | FAN_CLOSE, AT_FDCWD, fname) < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_mark (%d, FAN_MARK_REMOVE | "
- "FAN_MARK_IGNORED_MASK, FAN_OPEN | "
- "FAN_CLOSE, AT_FDCWD, %s) failed", fd_notify,
- fname);
- }
+ fd = SAFE_OPEN(fname, O_RDWR);
+ event_set[tst_count] = FAN_OPEN;
+ tst_count++;
+
+ /* This event should be ignored */
+ SAFE_READ(0, fd, buf, BUF_SIZE);
+
+ /*
+ * get another list of events to verify the last one got ignored
+ */
+ ret = SAFE_READ(0, fd_notify, event_buf + len,
+ EVENT_BUF_LEN - len);
+ len += ret;
+
+ lseek(fd, 0, SEEK_SET);
+ /* Generate modify event to clear ignore mask */
+ SAFE_WRITE(1, fd, fname, 1);
+ event_set[tst_count] = FAN_MODIFY;
+ tst_count++;
+
+ /*
+ * This event shouldn't be ignored because previous modification
+ * should have removed the ignore mask
+ */
+ SAFE_READ(0, fd, buf, BUF_SIZE);
+ event_set[tst_count] = FAN_ACCESS;
+ tst_count++;
+
+ SAFE_CLOSE(fd);
+ event_set[tst_count] = FAN_CLOSE_WRITE;
+ tst_count++;
+
+ /* Read events to verify previous access was properly generated */
+ ret = SAFE_READ(0, fd_notify, event_buf + len,
+ EVENT_BUF_LEN - len);
+ len += ret;
+
+ /*
+ * Now ignore open & close events regardless of file
+ * modifications
+ */
+ if (fanotify_mark(fd_notify,
+ FAN_MARK_ADD | FAN_MARK_IGNORED_MASK | FAN_MARK_IGNORED_SURV_MODIFY,
+ FAN_OPEN | FAN_CLOSE, AT_FDCWD, fname) < 0) {
+ tst_brk(TBROK | TERRNO,
+ "fanotify_mark (%d, FAN_MARK_ADD | "
+ "FAN_MARK_IGNORED_MASK | "
+ "FAN_MARK_IGNORED_SURV_MODIFY, FAN_OPEN | "
+ "FAN_CLOSE, AT_FDCWD, %s) failed", fd_notify,
+ fname);
+ }
- SAFE_CLOSE(cleanup, fd);
- event_set[tst_count] = FAN_CLOSE_WRITE;
- tst_count++;
+ /* This event should be ignored */
+ fd = SAFE_OPEN(fname, O_RDWR);
+
+ SAFE_WRITE(1, fd, fname, 1);
+ event_set[tst_count] = FAN_MODIFY;
+ tst_count++;
+
+ /* This event should be still ignored */
+ SAFE_CLOSE(fd);
+
+ /* This event should still be ignored */
+ fd = SAFE_OPEN(fname, O_RDWR);
+
+ /* Read events to verify open & close were ignored */
+ ret = SAFE_READ(0, fd_notify, event_buf + len,
+ EVENT_BUF_LEN - len);
+ len += ret;
+
+ /* Now remove open and close from ignored mask */
+ if (fanotify_mark(fd_notify,
+ FAN_MARK_REMOVE | FAN_MARK_IGNORED_MASK,
+ FAN_OPEN | FAN_CLOSE, AT_FDCWD, fname) < 0) {
+ tst_brk(TBROK | TERRNO,
+ "fanotify_mark (%d, FAN_MARK_REMOVE | "
+ "FAN_MARK_IGNORED_MASK, FAN_OPEN | "
+ "FAN_CLOSE, AT_FDCWD, %s) failed", fd_notify,
+ fname);
+ }
- /* Read events to verify close was generated */
- ret = SAFE_READ(cleanup, 0, fd_notify, event_buf + len,
- EVENT_BUF_LEN - len);
- len += ret;
+ SAFE_CLOSE(fd);
+ event_set[tst_count] = FAN_CLOSE_WRITE;
+ tst_count++;
- if (TST_TOTAL != tst_count) {
- tst_brkm(TBROK, cleanup,
- "TST_TOTAL (%d) and tst_count (%d) are not "
- "equal", TST_TOTAL, tst_count);
- }
- tst_count = 0;
+ /* Read events to verify close was generated */
+ ret = SAFE_READ(0, fd_notify, event_buf + len,
+ EVENT_BUF_LEN - len);
+ len += ret;
- /*
- * 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",
+ if (TST_TOTAL != tst_count) {
+ tst_brk(TBROK,
+ "TST_TOTAL (%d) and tst_count (%d) are not "
+ "equal", TST_TOTAL, tst_count);
+ }
+ 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_res(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_res(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_res(TFAIL,
+ "get event: mask=%llx pid=%u "
+ "(expected %u) fd=%u",
+ (unsigned long long)event->mask,
+ (unsigned)event->pid,
+ (unsigned)getpid(),
+ event->fd);
+ } else {
+ if (event->fd == -2)
+ goto pass;
+ ret = read(event->fd, buf, BUF_SIZE);
+ if (ret != strlen(fname)) {
+ tst_res(TFAIL,
+ "cannot read from returned fd "
+ "of event: mask=%llx pid=%u "
+ "fd=%u ret=%d (errno=%d)",
(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)event->pid,
+ event->fd, ret, errno);
+ } else if (memcmp(buf, fname, strlen(fname))) {
+ tst_res(TFAIL,
+ "wrong data read from returned fd "
+ "of event: mask=%llx pid=%u "
+ "fd=%u",
(unsigned long long)event->mask,
(unsigned)event->pid,
- (unsigned)getpid(),
event->fd);
} else {
- if (event->fd == -2)
- goto pass;
- ret = read(event->fd, buf, BUF_SIZE);
- if (ret != strlen(fname)) {
- tst_resm(TFAIL,
- "cannot read from returned fd "
- "of event: mask=%llx pid=%u "
- "fd=%u ret=%d (errno=%d)",
- (unsigned long long)event->mask,
- (unsigned)event->pid,
- event->fd, ret, errno);
- } else if (memcmp(buf, fname, strlen(fname))) {
- tst_resm(TFAIL,
- "wrong data read from returned fd "
- "of event: mask=%llx pid=%u "
- "fd=%u",
- (unsigned long long)event->mask,
- (unsigned)event->pid,
- event->fd);
- } else {
pass:
- tst_resm(TPASS,
- "get event: mask=%llx pid=%u fd=%u",
- (unsigned long long)event->mask,
- (unsigned)event->pid, event->fd);
- }
+ tst_res(TPASS,
+ "get event: mask=%llx pid=%u fd=%u",
+ (unsigned long long)event->mask,
+ (unsigned)event->pid, event->fd);
}
- /*
- * We have verified the data now so close fd and
- * invalidate it so that we don't check it again
- * unnecessarily
- */
- close(event->fd);
- event->fd = -2;
- event->mask &= ~event_set[test_num];
- /* No events left in current mask? Go for next event */
- if (event->mask == 0) {
- i += event->event_len;
- }
- test_num++;
- }
- for (; test_num < TST_TOTAL; test_num++) {
- tst_resm(TFAIL, "didn't get event: mask=%llx",
- event_set[test_num]);
-
}
- /* Remove mark to clear FAN_MARK_IGNORED_SURV_MODIFY */
- if (fanotify_mark(fd_notify, FAN_MARK_REMOVE, FAN_ACCESS | FAN_MODIFY |
- FAN_CLOSE | FAN_OPEN, AT_FDCWD, fname) < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_mark (%d, FAN_MARK_REMOVE, FAN_ACCESS | "
- "FAN_MODIFY | FAN_CLOSE | FAN_OPEN, AT_FDCWD, %s) "
- "failed", fd_notify, fname);
+ /*
+ * We have verified the data now so close fd and
+ * invalidate it so that we don't check it again
+ * unnecessarily
+ */
+ close(event->fd);
+ event->fd = -2;
+ event->mask &= ~event_set[test_num];
+ /* No events left in current mask? Go for next event */
+ if (event->mask == 0) {
+ i += event->event_len;
}
-
+ test_num++;
}
+ for (; test_num < TST_TOTAL; test_num++) {
+ tst_res(TFAIL, "didn't get event: mask=%llx",
+ event_set[test_num]);
- cleanup();
- tst_exit();
+ }
+ /* Remove mark to clear FAN_MARK_IGNORED_SURV_MODIFY */
+ if (fanotify_mark(fd_notify, FAN_MARK_REMOVE, FAN_ACCESS | FAN_MODIFY |
+ FAN_CLOSE | FAN_OPEN, AT_FDCWD, fname) < 0) {
+ tst_brk(TBROK | TERRNO,
+ "fanotify_mark (%d, FAN_MARK_REMOVE, FAN_ACCESS | "
+ "FAN_MODIFY | FAN_CLOSE | FAN_OPEN, AT_FDCWD, %s) "
+ "failed", fd_notify, fname);
+ }
}
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, fname, 1);
-
+ fd = SAFE_OPEN(fname, O_RDWR | O_CREAT, 0700);
+ SAFE_WRITE(1, fd, fname, 1);
/* close the file we have open */
- SAFE_CLOSE(cleanup, fd);
+ SAFE_CLOSE(fd);
- if ((fd_notify = fanotify_init(FAN_CLASS_NOTIF, O_RDONLY)) < 0) {
- if (errno == ENOSYS) {
- tst_brkm(TCONF, cleanup,
- "fanotify is not configured in this kernel.");
- } else {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_init failed");
- }
- }
+ fd_notify = SAFE_FANOTIFY_INIT(FAN_CLASS_NOTIF, O_RDONLY);
}
static void cleanup(void)
{
if (fd_notify > 0 && close(fd_notify))
- tst_resm(TWARN | TERRNO, "close(%d) failed", fd_notify);
-
- tst_rmdir();
+ tst_res(TWARN | TERRNO, "close(%d) failed", fd_notify);
}
-#else
-
-int main(void)
-{
- tst_brkm(TCONF, NULL, "system doesn't have required fanotify support");
-}
+static struct tst_test test = {
+ .test_all = test01,
+ .setup = setup,
+ .cleanup = cleanup,
+ .needs_tmpdir = 1,
+ .needs_root = 1
+};
+#else
+ TST_TEST_TCONF("system doesn't have required fanotify support");
#endif
diff --git a/testcases/kernel/syscalls/fanotify/fanotify02.c b/testcases/kernel/syscalls/fanotify/fanotify02.c
index 29dbe4f..6cb7097 100644
--- a/testcases/kernel/syscalls/fanotify/fanotify02.c
+++ b/testcases/kernel/syscalls/fanotify/fanotify02.c
@@ -35,12 +35,9 @@
#include <errno.h>
#include <string.h>
#include <sys/syscall.h>
-#include "test.h"
-#include "lapi/syscalls.h"
+#include "tst_test.h"
#include "fanotify.h"
-#include "safe_macros.h"
-char *TCID = "fanotify02";
int TST_TOTAL = 8;
#if defined(HAVE_SYS_FANOTIFY_H)
@@ -52,9 +49,6 @@ int TST_TOTAL = 8;
/* reasonable guess as to size of 1024 events */
#define EVENT_BUF_LEN (EVENT_MAX * EVENT_SIZE)
-static void setup(void);
-static void cleanup(void);
-
#define BUF_SIZE 256
static char fname[BUF_SIZE];
static char buf[BUF_SIZE];
@@ -64,197 +58,173 @@ static unsigned long long event_set[EVENT_MAX];
static char event_buf[EVENT_BUF_LEN];
-int main(int ac, char **av)
+void test01(void)
{
- 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);
- }
+ int ret, len, i = 0, test_num = 0;
+
+ int 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_brk(TBROK | TERRNO,
+ "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);
- }
+ /*
+ * generate sequence of events
+ */
+ fd = SAFE_OPEN(fname, O_RDWR | O_CREAT, 0700);
+ event_set[tst_count] = FAN_OPEN;
+ tst_count++;
+
+ SAFE_WRITE(1, fd, fname, strlen(fname));
+ event_set[tst_count] = FAN_MODIFY;
+ tst_count++;
+
+ SAFE_CLOSE(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(0, fd_notify, event_buf,
+ EVENT_BUF_LEN);
+ len = ret;
+
+ fd = SAFE_OPEN(fname, O_RDONLY);
+ event_set[tst_count] = FAN_OPEN;
+ tst_count++;
+
+ SAFE_READ(0, fd, buf, BUF_SIZE);
+ event_set[tst_count] = FAN_ACCESS;
+ tst_count++;
+
+ SAFE_CLOSE(fd);
+ event_set[tst_count] = FAN_CLOSE_NOWRITE;
+ tst_count++;
+
+ /*
+ * get next events
+ */
+ ret = SAFE_READ(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_brk(TBROK | TERRNO,
+ "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);
+ /*
+ * Do something to verify events didn't get generated
+ */
+ fd = SAFE_OPEN(fname, O_RDONLY);
- SAFE_CLOSE(cleanup, fd);
+ SAFE_CLOSE(fd);
- fd = SAFE_OPEN(cleanup, ".", O_RDONLY | O_DIRECTORY);
- event_set[tst_count] = FAN_OPEN;
- tst_count++;
+ fd = SAFE_OPEN(".", 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++;
+ SAFE_CLOSE(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;
+ /*
+ * Check events got generated only for the directory
+ */
+ ret = SAFE_READ(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++;
+ if (TST_TOTAL != tst_count) {
+ tst_brk(TBROK,
+ "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_res(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_res(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_res(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_res(TPASS,
+ "get event: mask=%llx pid=%u fd=%u",
+ (unsigned long long)event->mask,
+ (unsigned)event->pid, event->fd);
}
- for (; test_num < TST_TOTAL; test_num++) {
- tst_resm(TFAIL, "didn't get event: mask=%llx",
- event_set[test_num]);
-
+ 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_res(TFAIL, "didn't get event: mask=%llx",
+ event_set[test_num]);
- cleanup();
- tst_exit();
+ }
}
static void setup(void)
{
- tst_sig(NOFORK, DEF_HANDLER, cleanup);
-
- TEST_PAUSE;
-
- tst_tmpdir();
sprintf(fname, "fname_%d", getpid());
-
- if ((fd_notify = fanotify_init(FAN_CLASS_NOTIF, O_RDONLY)) < 0) {
- if (errno == ENOSYS) {
- tst_brkm(TCONF, cleanup,
- "fanotify is not configured in this kernel.");
- } else {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_init failed");
- }
- }
+ fd_notify = SAFE_FANOTIFY_INIT(FAN_CLASS_NOTIF, O_RDONLY);
}
static void cleanup(void)
{
if (fd_notify > 0 && close(fd_notify))
- tst_resm(TWARN | TERRNO, "close(%d) failed", fd_notify);
-
- tst_rmdir();
+ tst_res(TWARN | TERRNO, "close(%d) failed", fd_notify);
}
-#else
-
-int main(void)
-{
- tst_brkm(TCONF, NULL, "system doesn't have required fanotify support");
-}
+static struct tst_test test = {
+ .test_all = test01,
+ .setup = setup,
+ .cleanup = cleanup,
+ .needs_tmpdir = 1,
+ .needs_root = 1
+};
+#else
+ TST_TEST_TCONF("system doesn't have required fanotify support");
#endif
diff --git a/testcases/kernel/syscalls/fanotify/fanotify03.c b/testcases/kernel/syscalls/fanotify/fanotify03.c
index 2aca2e1..0732146 100644
--- a/testcases/kernel/syscalls/fanotify/fanotify03.c
+++ b/testcases/kernel/syscalls/fanotify/fanotify03.c
@@ -38,12 +38,9 @@
#include <string.h>
#include <signal.h>
#include <sys/syscall.h>
-#include "test.h"
-#include "lapi/syscalls.h"
+#include "tst_test.h"
#include "fanotify.h"
-#include "safe_macros.h"
-char *TCID = "fanotify03";
int TST_TOTAL = 3;
#if defined(HAVE_SYS_FANOTIFY_H)
@@ -55,9 +52,6 @@ int TST_TOTAL = 3;
/* reasonable guess as to size of 1024 events */
#define EVENT_BUF_LEN (EVENT_MAX * EVENT_SIZE)
-static void setup(void);
-static void cleanup(void);
-
#define BUF_SIZE 256
static char fname[BUF_SIZE];
static char buf[BUF_SIZE];
@@ -109,7 +103,7 @@ static void run_child(void)
child_action.sa_flags = SA_NOCLDSTOP;
if (sigaction(SIGCHLD, &child_action, NULL) < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
+ tst_brk(TBROK | TERRNO,
"sigaction(SIGCHLD, &child_action, NULL) failed");
}
@@ -120,7 +114,7 @@ static void run_child(void)
generate_events();
exit(0);
case -1:
- tst_brkm(TBROK | TERRNO, cleanup, "fork() failed");
+ tst_brk(TBROK | TERRNO, "fork() failed");
}
}
@@ -133,171 +127,148 @@ static void check_child(void)
sigemptyset(&child_action.sa_mask);
child_action.sa_flags = SA_NOCLDSTOP;
if (sigaction(SIGCHLD, &child_action, NULL) < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
+ tst_brk(TBROK | TERRNO,
"sigaction(SIGCHLD, &child_action, NULL) failed");
}
if (waitpid(-1, &child_ret, 0) < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
+ tst_brk(TBROK | TERRNO,
"waitpid(-1, &child_ret, 0) failed");
}
if (WIFSIGNALED(child_ret)) {
- tst_resm(TFAIL, "child exited due to signal %d",
+ tst_res(TFAIL, "child exited due to signal %d",
WTERMSIG(child_ret));
} else if (WIFEXITED(child_ret)) {
if (WEXITSTATUS(child_ret) == 0)
- tst_resm(TPASS, "child exited correctly");
+ tst_res(TPASS, "child exited correctly");
else
- tst_resm(TFAIL, "child exited with status %d",
+ tst_res(TFAIL, "child exited with status %d",
WEXITSTATUS(child_ret));
} else {
- tst_resm(TFAIL, "child exited for unknown reason (status %d)",
+ tst_res(TFAIL, "child exited for unknown reason (status %d)",
child_ret);
}
}
-int main(int ac, char **av)
+void test01(void)
{
- int lc;
- int fd_notify_backup = -1;
-
- tst_parse_opts(ac, av, NULL, NULL);
+ int tst_count, fd_notify_backup = -1;
- setup();
+ int ret, len = 0, i = 0, test_num = 0;
- for (lc = 0; TEST_LOOPING(lc); lc++) {
- int ret, len = 0, i = 0, test_num = 0;
-
- if (fd_notify_backup == -1) {
- fd_notify_backup = dup(fd_notify);
- if (fd_notify_backup < 0)
- tst_brkm(TBROK | TERRNO, cleanup,
- "dup(%d) failed", fd_notify);
- }
- run_child();
+ if (fd_notify_backup == -1) {
+ fd_notify_backup = dup(fd_notify);
+ if (fd_notify_backup < 0)
+ tst_brk(TBROK | TERRNO,
+ "dup(%d) failed", fd_notify);
+ }
+ run_child();
- tst_count = 0;
+ tst_count = 0;
- event_set[tst_count] = FAN_OPEN_PERM;
- event_resp[tst_count++] = FAN_ALLOW;
- event_set[tst_count] = FAN_ACCESS_PERM;
- event_resp[tst_count++] = FAN_DENY;
+ event_set[tst_count] = FAN_OPEN_PERM;
+ event_resp[tst_count++] = FAN_ALLOW;
+ event_set[tst_count] = FAN_ACCESS_PERM;
+ event_resp[tst_count++] = FAN_DENY;
- /* tst_count + 1 is for checking child return value */
- if (TST_TOTAL != tst_count + 1) {
- tst_brkm(TBROK, cleanup,
- "TST_TOTAL and tst_count do not match");
- }
- tst_count = 0;
-
- /*
- * check events
- */
- while (test_num < TST_TOTAL && fd_notify != -1) {
- struct fanotify_event_metadata *event;
-
- if (i == len) {
- /* Get more events */
- ret = read(fd_notify, event_buf + len,
- EVENT_BUF_LEN - len);
- if (fd_notify == -1)
- break;
- if (ret < 0) {
- tst_brkm(TBROK, cleanup,
- "read(%d, buf, %zu) failed",
- fd_notify, EVENT_BUF_LEN);
- }
- len += ret;
- }
+ /* tst_count + 1 is for checking child return value */
+ if (TST_TOTAL != tst_count + 1) {
+ tst_brk(TBROK,
+ "TST_TOTAL and tst_count do not match");
+ }
+ tst_count = 0;
- event = (struct fanotify_event_metadata *)&event_buf[i];
- 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 != child_pid) {
- tst_resm(TFAIL,
- "get event: mask=%llx pid=%u "
- "(expected %u) fd=%u",
- (unsigned long long)event->mask,
- (unsigned)event->pid,
- (unsigned)child_pid,
- event->fd);
- } else {
- tst_resm(TPASS,
- "get event: mask=%llx pid=%u fd=%u",
- (unsigned long long)event->mask,
- (unsigned)event->pid, event->fd);
- }
- /* Write response to permission event */
- if (event_set[test_num] & FAN_ALL_PERM_EVENTS) {
- struct fanotify_response resp;
-
- resp.fd = event->fd;
- resp.response = event_resp[test_num];
- SAFE_WRITE(cleanup, 1, fd_notify, &resp,
- sizeof(resp));
- }
- 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);
+ /*
+ * check events
+ */
+ while (test_num < TST_TOTAL && fd_notify != -1) {
+ struct fanotify_event_metadata *event;
+
+ if (i == len) {
+ /* Get more events */
+ ret = read(fd_notify, event_buf + len,
+ EVENT_BUF_LEN - len);
+ if (fd_notify == -1)
+ break;
+ if (ret < 0) {
+ tst_brk(TBROK,
+ "read(%d, buf, %zu) failed",
+ fd_notify, EVENT_BUF_LEN);
}
- test_num++;
+ len += ret;
}
- for (; test_num < TST_TOTAL - 1; test_num++) {
- tst_resm(TFAIL, "didn't get event: mask=%llx",
- event_set[test_num]);
+ event = (struct fanotify_event_metadata *)&event_buf[i];
+ if (!(event->mask & event_set[test_num])) {
+ tst_res(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 != child_pid) {
+ tst_res(TFAIL,
+ "get event: mask=%llx pid=%u "
+ "(expected %u) fd=%u",
+ (unsigned long long)event->mask,
+ (unsigned)event->pid,
+ (unsigned)child_pid,
+ event->fd);
+ } else {
+ tst_res(TPASS,
+ "get event: mask=%llx pid=%u fd=%u",
+ (unsigned long long)event->mask,
+ (unsigned)event->pid, event->fd);
+ }
+ /* Write response to permission event */
+ if (event_set[test_num] & FAN_ALL_PERM_EVENTS) {
+ struct fanotify_response resp;
+
+ resp.fd = event->fd;
+ resp.response = event_resp[test_num];
+ SAFE_WRITE(1, fd_notify, &resp,
+ sizeof(resp));
}
- check_child();
- /* We got SIGCHLD while running, resetup fd_notify */
- if (fd_notify == -1) {
- fd_notify = fd_notify_backup;
- fd_notify_backup = -1;
+ 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 - 1; test_num++) {
+ tst_res(TFAIL, "didn't get event: mask=%llx",
+ event_set[test_num]);
- cleanup();
- tst_exit();
+ }
+ check_child();
+ /* We got SIGCHLD while running, resetup fd_notify */
+ if (fd_notify == -1) {
+ fd_notify = fd_notify_backup;
+ fd_notify_backup = -1;
+ }
}
static void setup(void)
{
int fd;
- tst_sig(FORK, DEF_HANDLER, cleanup);
-
- TEST_PAUSE;
-
- tst_tmpdir();
sprintf(fname, "fname_%d", getpid());
- fd = SAFE_OPEN(cleanup, fname, O_CREAT | O_RDWR, 0644);
- SAFE_WRITE(cleanup, 1, fd, fname, 1);
- SAFE_CLOSE(cleanup, fd);
-
- if ((fd_notify = fanotify_init(FAN_CLASS_CONTENT, O_RDONLY)) < 0) {
- if (errno == ENOSYS) {
- tst_brkm(TCONF, cleanup,
- "fanotify is not configured in this kernel.");
- } else {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_init failed");
- }
- }
+ fd = SAFE_OPEN(fname, O_CREAT | O_RDWR, 0644);
+ SAFE_WRITE(1, fd, fname, 1);
+ SAFE_CLOSE(fd);
+
+ fd_notify = SAFE_FANOTIFY_INIT(FAN_CLASS_CONTENT, O_RDONLY);
if (fanotify_mark(fd_notify, FAN_MARK_ADD, FAN_ACCESS_PERM |
FAN_OPEN_PERM, AT_FDCWD, fname) < 0) {
if (errno == EINVAL) {
- tst_brkm(TCONF | TERRNO, cleanup,
+ tst_brk(TCONF | TERRNO,
"CONFIG_FANOTIFY_ACCESS_PERMISSIONS not "
"configured in kernel?");
} else {
- tst_brkm(TBROK | TERRNO, cleanup,
+ tst_brk(TBROK | TERRNO,
"fanotify_mark (%d, FAN_MARK_ADD, FAN_ACCESS_PERM | "
"FAN_OPEN_PERM, AT_FDCWD, %s) failed.", fd_notify, fname);
}
@@ -308,16 +279,17 @@ static void setup(void)
static void cleanup(void)
{
if (fd_notify > 0 && close(fd_notify))
- tst_resm(TWARN | TERRNO, "close(%d) failed", fd_notify);
-
- tst_rmdir();
+ tst_res(TWARN | TERRNO, "close(%d) failed", fd_notify);
}
-#else
-
-int main(void)
-{
- tst_brkm(TCONF, NULL, "system doesn't have required fanotify support");
-}
+static struct tst_test test = {
+ .test_all = test01,
+ .setup = setup,
+ .cleanup = cleanup,
+ .needs_tmpdir = 1,
+ .needs_root = 1
+};
+#else
+ TST_TEST_TCONF("system doesn't have required fanotify support");
#endif
diff --git a/testcases/kernel/syscalls/fanotify/fanotify04.c b/testcases/kernel/syscalls/fanotify/fanotify04.c
index dca52f0..091e51c 100644
--- a/testcases/kernel/syscalls/fanotify/fanotify04.c
+++ b/testcases/kernel/syscalls/fanotify/fanotify04.c
@@ -36,12 +36,9 @@
#include <errno.h>
#include <string.h>
#include <sys/syscall.h>
-#include "test.h"
-#include "lapi/syscalls.h"
+#include "tst_test.h"
#include "fanotify.h"
-#include "safe_macros.h"
-char *TCID = "fanotify04";
int TST_TOTAL = 9;
#if defined(HAVE_SYS_FANOTIFY_H)
@@ -53,9 +50,6 @@ int TST_TOTAL = 9;
/* reasonable guess as to size of 1024 events */
#define EVENT_BUF_LEN (EVENT_MAX * EVENT_SIZE)
-static void setup(void);
-static void cleanup(void);
-
#define BUF_SIZE 256
static char fname[BUF_SIZE];
static char sname[BUF_SIZE];
@@ -84,11 +78,11 @@ static void check_mark(char *file, unsigned long long flag, char *flagstr,
{
if (fanotify_mark(fd_notify, FAN_MARK_ADD | flag, FAN_OPEN, AT_FDCWD,
file) != expect) {
- tst_resm(TFAIL,
+ tst_res(TFAIL,
"fanotify_mark (%d, FAN_MARK_ADD | %s, FAN_OPEN, AT_FDCWD, "
"'%s') %s", fd_notify, flagstr, file, expect_str_fail(expect));
} else {
- tst_resm(TPASS,
+ tst_res(TPASS,
"fanotify_mark (%d, FAN_MARK_ADD | %s, FAN_OPEN, AT_FDCWD, "
"'%s') %s", fd_notify, flagstr, file, expect_str_pass(expect));
@@ -101,7 +95,7 @@ static void check_mark(char *file, unsigned long long flag, char *flagstr,
if (fanotify_mark(fd_notify, FAN_MARK_REMOVE | flag,
FAN_OPEN, AT_FDCWD, file) < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
+ tst_brk(TBROK | TERRNO,
"fanotify_mark (%d, FAN_MARK_REMOVE | %s, "
"FAN_OPEN, AT_FDCWD, '%s') failed",
fd_notify, flagstr, file);
@@ -115,8 +109,8 @@ static void do_open(char *file, int flag, char *flagstr)
{
int fd;
- fd = SAFE_OPEN(cleanup, file, O_RDONLY | flag);
- SAFE_CLOSE(cleanup, fd);
+ fd = SAFE_OPEN(file, O_RDONLY | flag);
+ SAFE_CLOSE(fd);
}
#define DO_OPEN(file, flag) do_open(file, flag, #flag)
@@ -138,22 +132,22 @@ static void verify_event(int mask)
struct stat st;
/* Read the event */
- ret = SAFE_READ(cleanup, 0, fd_notify, event_buf + len,
+ ret = SAFE_READ(0, fd_notify, event_buf + len,
EVENT_BUF_LEN - len);
event = (struct fanotify_event_metadata *)&event_buf[len];
len += ret;
if (event->mask != FAN_OPEN) {
- tst_resm(TFAIL, "got unexpected event %llx",
+ tst_res(TFAIL, "got unexpected event %llx",
(unsigned long long)event->mask);
} else if (fstat(event->fd, &st) < 0) {
- tst_resm(TFAIL, "failed to stat event->fd (%s)",
+ tst_res(TFAIL, "failed to stat event->fd (%s)",
strerror(errno));
} else if ((st.st_mode & S_IFMT) != mask) {
- tst_resm(TFAIL, "event->fd points to object of different type "
+ tst_res(TFAIL, "event->fd points to object of different type "
"(%o != %o)", st.st_mode & S_IFMT, mask);
} else {
- tst_resm(TPASS, "event generated properly for type %o", mask);
+ tst_res(TPASS, "event generated properly for type %o", mask);
}
close(event->fd);
}
@@ -181,15 +175,15 @@ static void verify_no_event(void)
struct fanotify_event_metadata *event;
event = (struct fanotify_event_metadata *)&event_buf[len];
- tst_resm(TFAIL, "seen unexpected event (mask %llx)",
+ tst_res(TFAIL, "seen unexpected event (mask %llx)",
(unsigned long long)event->mask);
/* Cleanup fd from the event */
close(event->fd);
} else if (errno != EAGAIN) {
- tst_resm(TFAIL | TERRNO, "read(%d, buf, %zu) failed", fd_notify,
+ tst_res(TFAIL | TERRNO, "read(%d, buf, %zu) failed", fd_notify,
EVENT_BUF_LEN);
} else {
- tst_resm(TPASS, "No event as expected");
+ tst_res(TPASS, "No event as expected");
}
}
@@ -200,104 +194,81 @@ static void test_open_symlink(char *file)
verify_no_event();
}
-int main(int ac, char **av)
+void test01(void)
{
- int lc;
-
- tst_parse_opts(ac, av, NULL, NULL);
-
- setup();
+ /* Check ONLYDIR on a directory */
+ CHECK_MARK(".", FAN_MARK_ONLYDIR, 0, NULL);
- for (lc = 0; TEST_LOOPING(lc); lc++) {
- /* Check ONLYDIR on a directory */
- CHECK_MARK(".", FAN_MARK_ONLYDIR, 0, NULL);
+ /* Check ONLYDIR without a directory */
+ CHECK_MARK(fname, FAN_MARK_ONLYDIR, -1, NULL);
- /* Check ONLYDIR without a directory */
- CHECK_MARK(fname, FAN_MARK_ONLYDIR, -1, NULL);
+ /* Check DONT_FOLLOW for a symlink */
+ CHECK_MARK(sname, FAN_MARK_DONT_FOLLOW, 0, test_open_symlink);
- /* Check DONT_FOLLOW for a symlink */
- CHECK_MARK(sname, FAN_MARK_DONT_FOLLOW, 0, test_open_symlink);
+ /* Check without DONT_FOLLOW for a symlink */
+ CHECK_MARK(sname, 0, 0, test_open_file);
- /* Check without DONT_FOLLOW for a symlink */
- CHECK_MARK(sname, 0, 0, test_open_file);
-
- /* Verify FAN_MARK_FLUSH destroys all inode marks */
- if (fanotify_mark(fd_notify, FAN_MARK_ADD,
- FAN_OPEN, AT_FDCWD, fname) < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_mark (%d, FAN_MARK_ADD, FAN_OPEN, "
- "AT_FDCWD, '%s') failed", fd_notify, fname);
- }
- if (fanotify_mark(fd_notify, FAN_MARK_ADD,
- FAN_OPEN | FAN_ONDIR, AT_FDCWD, dir) < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_mark (%d, FAN_MARK_ADD, FAN_OPEN | "
- "FAN_ONDIR, AT_FDCWD, '%s') failed", fd_notify,
- dir);
- }
- open_file(fname);
- verify_event(S_IFREG);
- open_dir(dir);
- verify_event(S_IFDIR);
- if (fanotify_mark(fd_notify, FAN_MARK_FLUSH,
- 0, AT_FDCWD, ".") < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_mark (%d, FAN_MARK_FLUSH, 0, "
- "AT_FDCWD, '.') failed", fd_notify);
- }
-
- open_dir(dir);
- verify_no_event();
+ /* Verify FAN_MARK_FLUSH destroys all inode marks */
+ if (fanotify_mark(fd_notify, FAN_MARK_ADD,
+ FAN_OPEN, AT_FDCWD, fname) < 0) {
+ tst_brk(TBROK | TERRNO,
+ "fanotify_mark (%d, FAN_MARK_ADD, FAN_OPEN, "
+ "AT_FDCWD, '%s') failed", fd_notify, fname);
+ }
+ if (fanotify_mark(fd_notify, FAN_MARK_ADD,
+ FAN_OPEN | FAN_ONDIR, AT_FDCWD, dir) < 0) {
+ tst_brk(TBROK | TERRNO,
+ "fanotify_mark (%d, FAN_MARK_ADD, FAN_OPEN | "
+ "FAN_ONDIR, AT_FDCWD, '%s') failed", fd_notify,
+ dir);
+ }
+ open_file(fname);
+ verify_event(S_IFREG);
+ open_dir(dir);
+ verify_event(S_IFDIR);
+ if (fanotify_mark(fd_notify, FAN_MARK_FLUSH,
+ 0, AT_FDCWD, ".") < 0) {
+ tst_brk(TBROK | TERRNO,
+ "fanotify_mark (%d, FAN_MARK_FLUSH, 0, "
+ "AT_FDCWD, '.') failed", fd_notify);
}
- cleanup();
- tst_exit();
+ open_dir(dir);
+ verify_no_event();
}
static void setup(void)
{
int fd;
- tst_sig(NOFORK, DEF_HANDLER, cleanup);
-
- TEST_PAUSE;
-
- tst_tmpdir();
sprintf(fname, "fname_%d", getpid());
- fd = SAFE_OPEN(cleanup, fname, O_RDWR | O_CREAT, 0644);
- SAFE_CLOSE(cleanup, fd);
+ fd = SAFE_OPEN(fname, O_RDWR | O_CREAT, 0644);
+ SAFE_CLOSE(fd);
sprintf(sname, "symlink_%d", getpid());
- SAFE_SYMLINK(cleanup, fname, sname);
+ SAFE_SYMLINK(fname, sname);
sprintf(dir, "dir_%d", getpid());
- SAFE_MKDIR(cleanup, dir, 0755);
-
- if ((fd_notify = fanotify_init(FAN_CLASS_NOTIF | FAN_NONBLOCK,
- O_RDONLY)) < 0) {
- if (errno == ENOSYS) {
- tst_brkm(TCONF, cleanup,
- "fanotify is not configured in this kernel.");
- } else {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_init failed");
- }
- }
+ SAFE_MKDIR(dir, 0755);
+
+ fd_notify = SAFE_FANOTIFY_INIT(FAN_CLASS_NOTIF | FAN_NONBLOCK,
+ O_RDONLY);
}
static void cleanup(void)
{
if (fd_notify > 0 && close(fd_notify))
- tst_resm(TWARN | TERRNO, "close(%d) failed", fd_notify);
-
- tst_rmdir();
+ tst_res(TWARN | TERRNO, "close(%d) failed", fd_notify);
}
-#else
-
-int main(void)
-{
- tst_brkm(TCONF, NULL, "system doesn't have required fanotify support");
-}
+static struct tst_test test = {
+ .test_all = test01,
+ .setup = setup,
+ .cleanup = cleanup,
+ .needs_tmpdir = 1,
+ .needs_root = 1
+};
+#else
+ TST_TEST_TCONF("system doesn't have required fanotify support");
#endif
diff --git a/testcases/kernel/syscalls/fanotify/fanotify05.c b/testcases/kernel/syscalls/fanotify/fanotify05.c
index 6063764..805fcd8 100644
--- a/testcases/kernel/syscalls/fanotify/fanotify05.c
+++ b/testcases/kernel/syscalls/fanotify/fanotify05.c
@@ -34,13 +34,8 @@
#include <errno.h>
#include <string.h>
#include <sys/syscall.h>
-#include "test.h"
-#include "lapi/syscalls.h"
+#include "tst_test.h"
#include "fanotify.h"
-#include "safe_macros.h"
-
-char *TCID = "fanotify05";
-int TST_TOTAL = 1;
#if defined(HAVE_SYS_FANOTIFY_H)
#include <sys/fanotify.h>
@@ -48,110 +43,84 @@ int TST_TOTAL = 1;
/* Currently this is fixed in kernel... */
#define MAX_EVENTS 16384
-static void setup(void);
-static void cleanup(void);
-
#define BUF_SIZE 256
static char fname[BUF_SIZE];
static int fd, fd_notify;
struct fanotify_event_metadata event;
-int main(int ac, char **av)
+void test01(void)
{
- int lc, i;
+ int i;
int len;
- tst_parse_opts(ac, av, NULL, NULL);
-
- setup();
+ /*
+ * generate events
+ */
+ for (i = 0; i < MAX_EVENTS + 1; i++) {
+ sprintf(fname, "fname_%d", i);
+ fd = SAFE_OPEN(fname, O_RDWR | O_CREAT, 0644);
+ SAFE_CLOSE(fd);
+ }
- for (lc = 0; TEST_LOOPING(lc); lc++) {
+ while (1) {
/*
- * generate events
+ * get list on 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");
+ len = read(fd_notify, &event, sizeof(event));
+ if (len < 0) {
+ if (errno == -EAGAIN) {
+ tst_res(TFAIL, "Overflow event not "
+ "generated!\n");
break;
}
- if (event.fd != FAN_NOFD)
- close(event.fd);
+ tst_brk(TBROK | TERRNO,
+ "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",
+ /*
+ * check events
+ */
+ if (event.mask != FAN_OPEN &&
+ event.mask != FAN_Q_OVERFLOW) {
+ tst_res(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_res(TFAIL,
+ "invalid overflow event: "
+ "mask=%llx pid=%u fd=%d",
(unsigned long long)event.mask,
- (unsigned long long)FAN_OPEN,
- (unsigned)event.pid, event.fd);
+ (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;
- }
+ tst_res(TPASS,
+ "get event: mask=%llx pid=%u fd=%d",
+ (unsigned long long)event.mask,
+ (unsigned)event.pid, event.fd);
+ break;
}
}
-
- cleanup();
- tst_exit();
}
static void setup(void)
{
- tst_sig(NOFORK, DEF_HANDLER, cleanup);
-
- TEST_PAUSE;
-
- tst_tmpdir();
-
- fd_notify = fanotify_init(FAN_CLASS_NOTIF | FAN_NONBLOCK, O_RDONLY);
- if (fd_notify < 0) {
- if (errno == ENOSYS) {
- tst_brkm(TCONF, cleanup,
- "fanotify is not configured in this kernel.");
- } else {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_init failed");
- }
- }
+ fd_notify = SAFE_FANOTIFY_INIT(FAN_CLASS_NOTIF | FAN_NONBLOCK,
+ O_RDONLY);
if (fanotify_mark(fd_notify, FAN_MARK_MOUNT | FAN_MARK_ADD, FAN_OPEN,
AT_FDCWD, ".") < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
+ tst_brk(TBROK | TERRNO,
"fanotify_mark (%d, FAN_MARK_MOUNT | FAN_MARK_ADD, "
"FAN_OPEN, AT_FDCWD, \".\") failed",
fd_notify);
@@ -161,16 +130,16 @@ static void setup(void)
static void cleanup(void)
{
if (fd_notify > 0 && close(fd_notify))
- tst_resm(TWARN | TERRNO, "close(%d) failed", fd_notify);
-
- tst_rmdir();
+ tst_res(TWARN | TERRNO, "close(%d) failed", fd_notify);
}
+static struct tst_test test = {
+ .test_all = test01,
+ .setup = setup,
+ .cleanup = cleanup,
+ .needs_root = 1,
+ .needs_tmpdir = 1,
+};
#else
-
-int main(void)
-{
- tst_brkm(TCONF, NULL, "system doesn't have required fanotify support");
-}
-
+ TST_TEST_TCONF("system doesn't have required fanotify support");
#endif
diff --git a/testcases/kernel/syscalls/fanotify/fanotify06.c b/testcases/kernel/syscalls/fanotify/fanotify06.c
index d7fef6d..e30da8b 100644
--- a/testcases/kernel/syscalls/fanotify/fanotify06.c
+++ b/testcases/kernel/syscalls/fanotify/fanotify06.c
@@ -34,6 +34,7 @@
*
* fanotify: fix notification of groups with inode & mount marks
*/
+#define _GNU_SOURCE
#include "config.h"
#include <stdio.h>
@@ -44,12 +45,8 @@
#include <string.h>
#include <sys/mount.h>
#include <sys/syscall.h>
-#include "test.h"
-#include "lapi/syscalls.h"
+#include "tst_test.h"
#include "fanotify.h"
-#include "safe_macros.h"
-
-char *TCID = "fanotify06";
#if defined(HAVE_SYS_FANOTIFY_H)
#include <sys/fanotify.h>
@@ -91,26 +88,17 @@ static void create_fanotify_groups(void)
for (p = 0; p < FANOTIFY_PRIORITIES; p++) {
for (i = 0; i < GROUPS_PER_PRIO; i++) {
- fd_notify[p][i] = fanotify_init(fanotify_prio[p] |
+ fd_notify[p][i] = SAFE_FANOTIFY_INIT(fanotify_prio[p] |
FAN_NONBLOCK,
O_RDONLY);
- if (fd_notify[p][i] < 0) {
- if (errno == ENOSYS) {
- tst_brkm(TCONF, cleanup,
- "fanotify is not configured in"
- " this kernel.");
- } else {
- tst_brkm(TBROK | TERRNO, cleanup,
- "fanotify_init failed");
- }
- }
+
/* Add mount mark for each group */
ret = fanotify_mark(fd_notify[p][i],
FAN_MARK_ADD | FAN_MARK_MOUNT,
FAN_MODIFY,
AT_FDCWD, ".");
if (ret < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
+ tst_brk(TBROK | TERRNO,
"fanotify_mark(%d, FAN_MARK_ADD | "
"FAN_MARK_MOUNT, FAN_MODIFY, AT_FDCWD,"
" '.') failed", fd_notify[p][i]);
@@ -124,7 +112,7 @@ static void create_fanotify_groups(void)
FAN_MARK_IGNORED_SURV_MODIFY,
FAN_MODIFY, AT_FDCWD, fname);
if (ret < 0) {
- tst_brkm(TBROK | TERRNO, cleanup,
+ tst_brk(TBROK | TERRNO,
"fanotify_mark(%d, FAN_MARK_ADD | "
"FAN_MARK_IGNORED_MASK | "
"FAN_MARK_IGNORED_SURV_MODIFY, "
@@ -143,7 +131,7 @@ static void cleanup_fanotify_groups(void)
for (i = 0; i < GROUPS_PER_PRIO; i++) {
if (fd_notify[p][i] && fd_notify[p][i] != -1) {
if (close(fd_notify[p][i]) == -1)
- tst_resm(TWARN, "close(%d) failed",
+ tst_res(TWARN, "close(%d) failed",
fd_notify[p][i]);
fd_notify[p][i] = 0;
}
@@ -154,115 +142,97 @@ static void cleanup_fanotify_groups(void)
static void verify_event(int group, struct fanotify_event_metadata *event)
{
if (event->mask != FAN_MODIFY) {
- tst_resm(TFAIL, "group %d get event: mask %llx (expected %llx) "
+ tst_res(TFAIL, "group %d get event: mask %llx (expected %llx) "
"pid=%u fd=%u", group, (unsigned long long)event->mask,
(unsigned long long)FAN_MODIFY,
(unsigned)event->pid, event->fd);
} else if (event->pid != getpid()) {
- tst_resm(TFAIL, "group %d get event: mask %llx pid=%u "
+ tst_res(TFAIL, "group %d get event: mask %llx pid=%u "
"(expected %u) fd=%u", group,
(unsigned long long)event->mask, (unsigned)event->pid,
(unsigned)getpid(), event->fd);
} else {
- tst_resm(TPASS, "group %d get event: mask %llx pid=%u fd=%u",
+ tst_res(TPASS, "group %d get event: mask %llx pid=%u fd=%u",
group, (unsigned long long)event->mask,
(unsigned)event->pid, event->fd);
}
}
-int main(int ac, char **av)
+void test01(void)
{
- int lc;
-
- tst_parse_opts(ac, av, NULL, NULL);
-
- setup();
-
- for (lc = 0; TEST_LOOPING(lc); lc++) {
- int ret;
- unsigned int p, i;
- struct fanotify_event_metadata *event;
-
- create_fanotify_groups();
-
- /*
- * generate sequence of events
- */
- fd = SAFE_OPEN(cleanup, fname, O_RDWR);
- SAFE_WRITE(cleanup, 1, fd, fname, strlen(fname));
- SAFE_CLOSE(cleanup, fd);
-
- /* First verify all groups without ignore mask got the event */
- for (i = 0; i < GROUPS_PER_PRIO; i++) {
- ret = read(fd_notify[0][i], event_buf, EVENT_BUF_LEN);
- if (ret < 0) {
- if (errno == EAGAIN) {
- tst_resm(TFAIL, "group %d did not get "
- "event", i);
- }
- tst_brkm(TBROK | TERRNO, cleanup,
- "reading fanotify events failed");
- }
- if (ret < (int)FAN_EVENT_METADATA_LEN) {
- tst_brkm(TBROK, cleanup,
- "short read when reading fanotify "
- "events (%d < %d)", ret,
- (int)EVENT_BUF_LEN);
+ int ret;
+ unsigned int p, i;
+ struct fanotify_event_metadata *event;
+
+ create_fanotify_groups();
+
+ /*
+ * generate sequence of events
+ */
+ fd = SAFE_OPEN(fname, O_RDWR);
+ SAFE_WRITE(1, fd, fname, strlen(fname));
+ SAFE_CLOSE(fd);
+
+ /* First verify all groups without ignore mask got the event */
+ for (i = 0; i < GROUPS_PER_PRIO; i++) {
+ ret = read(fd_notify[0][i], event_buf, EVENT_BUF_LEN);
+ if (ret < 0) {
+ if (errno == EAGAIN) {
+ tst_res(TFAIL, "group %d did not get "
+ "event", i);
}
- event = (struct fanotify_event_metadata *)event_buf;
- if (ret > (int)event->event_len) {
- tst_resm(TFAIL, "group %d got more than one "
- "event (%d > %d)", i, ret,
- event->event_len);
- } else
- verify_event(i, event);
- close(event->fd);
+ tst_brk(TBROK | TERRNO,
+ "reading fanotify events failed");
+ }
+ if (ret < (int)FAN_EVENT_METADATA_LEN) {
+ tst_brk(TBROK,
+ "short read when reading fanotify "
+ "events (%d < %d)", ret,
+ (int)EVENT_BUF_LEN);
}
- for (p = 1; p < FANOTIFY_PRIORITIES; p++) {
- for (i = 0; i < GROUPS_PER_PRIO; i++) {
- ret = read(fd_notify[p][i], event_buf, EVENT_BUF_LEN);
- if (ret > 0) {
- tst_resm(TFAIL, "group %d got event",
- p*GROUPS_PER_PRIO + i);
- } else if (ret == 0) {
- tst_brkm(TBROK, cleanup, "zero length "
- "read from fanotify fd");
- } else if (errno != EAGAIN) {
- tst_brkm(TBROK | TERRNO, cleanup,
- "reading fanotify events failed");
- } else {
- tst_resm(TPASS, "group %d got no event",
- p*GROUPS_PER_PRIO + i);
- }
+ event = (struct fanotify_event_metadata *)event_buf;
+ if (ret > (int)event->event_len) {
+ tst_res(TFAIL, "group %d got more than one "
+ "event (%d > %d)", i, ret,
+ event->event_len);
+ } else
+ verify_event(i, event);
+ close(event->fd);
+ }
+ for (p = 1; p < FANOTIFY_PRIORITIES; p++) {
+ for (i = 0; i < GROUPS_PER_PRIO; i++) {
+ ret = read(fd_notify[p][i], event_buf, EVENT_BUF_LEN);
+ if (ret > 0) {
+ tst_res(TFAIL, "group %d got event",
+ p*GROUPS_PER_PRIO + i);
+ } else if (ret == 0) {
+ tst_brk(TBROK, "zero length "
+ "read from fanotify fd");
+ } else if (errno != EAGAIN) {
+ tst_brk(TBROK | TERRNO,
+ "reading fanotify events failed");
+ } else {
+ tst_res(TPASS, "group %d got no event",
+ p*GROUPS_PER_PRIO + i);
}
}
- cleanup_fanotify_groups();
}
-
- cleanup();
- tst_exit();
+ cleanup_fanotify_groups();
}
static void setup(void)
{
- tst_sig(NOFORK, DEF_HANDLER, cleanup);
-
- TEST_PAUSE;
-
- tst_require_root();
- tst_tmpdir();
-
- SAFE_MKDIR(cleanup, MOUNT_NAME, 0755);
- SAFE_MOUNT(cleanup, MOUNT_NAME, MOUNT_NAME, NULL, MS_BIND, NULL);
+ SAFE_MKDIR(MOUNT_NAME, 0755);
+ SAFE_MOUNT(MOUNT_NAME, MOUNT_NAME, NULL, MS_BIND, NULL);
mount_created = 1;
- SAFE_CHDIR(cleanup, MOUNT_NAME);
+ SAFE_CHDIR(MOUNT_NAME);
sprintf(fname, "tfile_%d", getpid());
- fd = SAFE_OPEN(cleanup, fname, O_RDWR | O_CREAT, 0700);
- SAFE_WRITE(cleanup, 1, fd, fname, 1);
+ fd = SAFE_OPEN(fname, O_RDWR | O_CREAT, 0700);
+ SAFE_WRITE(1, fd, fname, 1);
/* close the file we have open */
- SAFE_CLOSE(cleanup, fd);
+ SAFE_CLOSE(fd);
}
static void cleanup(void)
@@ -270,19 +240,20 @@ static void cleanup(void)
cleanup_fanotify_groups();
if (chdir(tst_get_tmpdir()) < 0)
- tst_brkm(TBROK, NULL, "chdir(tmpdir) failed");
+ tst_brk(TBROK, "chdir(tmpdir) failed");
if (mount_created && tst_umount(MOUNT_NAME) < 0)
- tst_brkm(TBROK | TERRNO, NULL, "umount failed");
-
- tst_rmdir();
+ tst_brk(TBROK | TERRNO, "umount failed");
}
-#else
-
-int main(void)
-{
- tst_brkm(TCONF, NULL, "system doesn't have required fanotify support");
-}
+static struct tst_test test = {
+ .test_all = test01,
+ .setup = setup,
+ .cleanup = cleanup,
+ .needs_tmpdir = 1,
+ .needs_root = 1
+};
+#else
+ TST_TEST_TCONF("system doesn't have required fanotify support");
#endif
diff --git a/testcases/kernel/syscalls/fanotify/fanotify07.c b/testcases/kernel/syscalls/fanotify/fanotify07.c
index 54e5a1f..af95c39 100644
--- a/testcases/kernel/syscalls/fanotify/fanotify07.c
+++ b/testcases/kernel/syscalls/fanotify/fanotify07.c
@@ -119,14 +119,7 @@ static int setup_instance(void)
{
int fd;
- if ((fd = fanotify_init(FAN_CLASS_CONTENT, O_RDONLY)) < 0) {
- if (errno == ENOSYS) {
- tst_brk(TCONF,
- "fanotify is not configured in this kernel.");
- } else {
- tst_brk(TBROK | TERRNO, "fanotify_init failed");
- }
- }
+ fd = SAFE_FANOTIFY_INIT(FAN_CLASS_CONTENT, O_RDONLY);
if (fanotify_mark(fd, FAN_MARK_ADD, FAN_ACCESS_PERM, AT_FDCWD,
fname) < 0) {
--
1.8.3.1
More information about the ltp
mailing list