Index: head/contrib/netbsd-tests/kernel/kqueue/t_proc2.c =================================================================== --- head/contrib/netbsd-tests/kernel/kqueue/t_proc2.c (revision 305467) +++ head/contrib/netbsd-tests/kernel/kqueue/t_proc2.c (revision 305468) @@ -1,139 +1,142 @@ /* $NetBSD: t_proc2.c,v 1.2 2015/01/14 22:22:32 christos Exp $ */ /*- * Copyright (c) 2008 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Peter Werner . * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include __COPYRIGHT("@(#) Copyright (c) 2008\ The NetBSD Foundation, inc. All rights reserved."); __RCSID("$NetBSD: t_proc2.c,v 1.2 2015/01/14 22:22:32 christos Exp $"); +#ifdef __FreeBSD__ +#include +#endif #include #include #include #include #include #include #include #include #include #include #include "../../h_macros.h" static void child_two(void) { _exit(EXIT_SUCCESS); } static void child_one(void) { pid_t pid; struct passwd *pwd; const char *nam = "nobody"; pwd = getpwnam(nam); if (pwd == NULL) err(EXIT_FAILURE, "getpwnam(\"%s\")", nam); if ((setuid(pwd->pw_uid)) == -1) err(EXIT_FAILURE, "setuid(%d)", pwd->pw_uid); pid = fork(); if (pid == -1) err(EXIT_FAILURE, "fork()"); if (pid == 0) child_two(); _exit(EXIT_SUCCESS); } ATF_TC(proc2); ATF_TC_HEAD(proc2, tc) { atf_tc_set_md_var(tc, "require.user", "root"); atf_tc_set_md_var(tc, "descr", "Checks EVFILT_PROC for NOTE_FORK|NOTE_TRACK error path problem " "fixed in rev. 1.1.1.1.2.17 of sys/kern/kern_event.c"); } ATF_TC_BODY(proc2, tc) { pid_t pid = 0; int kq, status; struct kevent ke; struct timespec timeout; RL(kq = kqueue()); timeout.tv_sec = 0; timeout.tv_nsec = 0; RL(pid = fork()); if (pid == 0) { (void)sleep(1); /* let parent set kevent */ child_one(); /* NOTREACHED */ } EV_SET(&ke, (uintptr_t)pid, EVFILT_PROC, EV_ADD, NOTE_FORK|NOTE_TRACK, 0, 0); RL(kevent(kq, &ke, 1, NULL, 0, &timeout)); (void)sleep(2); ke.ident = 0; ke.fflags = 0; ke.flags = EV_ENABLE; RL(kevent(kq, NULL, 0, &ke, 1, &timeout)); RL(close(kq)); RL(waitpid(pid, &status, 0)); ATF_REQUIRE(WIFEXITED(status)); ATF_REQUIRE_EQ(WEXITSTATUS(status), EXIT_SUCCESS); /* * we are expecting an error here as we should not have * been able to add a knote to child 2. */ ATF_REQUIRE(ke.fflags & NOTE_TRACKERR); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, proc2); return atf_no_error(); } Index: head/contrib/netbsd-tests/kernel/kqueue/t_proc3.c =================================================================== --- head/contrib/netbsd-tests/kernel/kqueue/t_proc3.c (revision 305467) +++ head/contrib/netbsd-tests/kernel/kqueue/t_proc3.c (revision 305468) @@ -1,99 +1,102 @@ /* $NetBSD: t_proc3.c,v 1.2 2015/01/14 22:22:32 christos Exp $ */ /*- * Copyright (c) 2012 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Joerg Sonnenberger. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include __RCSID("$NetBSD: t_proc3.c,v 1.2 2015/01/14 22:22:32 christos Exp $"); +#ifdef __FreeBSD__ +#include +#endif #include #include #include #include #include #include #include #include #include #include #include "../../h_macros.h" ATF_TC(proc3); ATF_TC_HEAD(proc3, tc) { atf_tc_set_md_var(tc, "descr", "Checks EVFILT_PROC for NOTE_TRACK on self bug "); } ATF_TC_BODY(proc3, tc) { pid_t pid = 0; int kq, status; struct kevent ke; struct timespec timeout; RL(kq = kqueue()); EV_SET(&ke, (uintptr_t)getpid(), EVFILT_PROC, EV_ADD, NOTE_TRACK, 0, 0); RL(kevent(kq, &ke, 1, NULL, 0, NULL)); RL(pid = fork()); if (pid == 0) { _exit(EXIT_SUCCESS); /* NOTREACHED */ } RL(waitpid(pid, &status, 0)); ATF_REQUIRE(WIFEXITED(status)); ATF_REQUIRE_EQ(WEXITSTATUS(status), EXIT_SUCCESS); timeout.tv_sec = 0; timeout.tv_nsec = 0; ke.ident = 0; ke.fflags = 0; ke.flags = EV_ENABLE; RL(kevent(kq, NULL, 0, &ke, 1, &timeout)); RL(close(kq)); ATF_REQUIRE(ke.fflags & NOTE_CHILD); ATF_REQUIRE((ke.fflags & NOTE_TRACKERR) == 0); ATF_REQUIRE_EQ((pid_t)ke.ident, pid); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, proc3); return atf_no_error(); } Index: head/contrib/netbsd-tests/kernel/kqueue/t_sig.c =================================================================== --- head/contrib/netbsd-tests/kernel/kqueue/t_sig.c (revision 305467) +++ head/contrib/netbsd-tests/kernel/kqueue/t_sig.c (revision 305468) @@ -1,133 +1,146 @@ /* $NetBSD: t_sig.c,v 1.2 2010/11/03 16:10:20 christos Exp $ */ /*- * Copyright (c) 2002, 2008 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Luke Mewburn and Jaromir Dolecek. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include __COPYRIGHT("@(#) Copyright (c) 2008\ The NetBSD Foundation, inc. All rights reserved."); __RCSID("$NetBSD: t_sig.c,v 1.2 2010/11/03 16:10:20 christos Exp $"); +#ifdef __FreeBSD__ +#include +#endif #include #include #include #include #include #include #include #include #include #include #include #include "../../h_macros.h" #define NSIGNALS 5 ATF_TC(sig); ATF_TC_HEAD(sig, tc) { atf_tc_set_md_var(tc, "descr", "Checks EVFILT_SIGNAL"); } ATF_TC_BODY(sig, tc) { struct timespec timeout; +#ifdef __NetBSD__ struct kfilter_mapping km; +#endif struct kevent event[1]; +#ifdef __NetBSD__ char namebuf[32]; +#endif pid_t pid, child; int kq, n, num, status; pid = getpid(); (void)printf("my pid: %d\n", pid); /* fork a child to send signals */ RL(child = fork()); if (child == 0) { int i; (void)sleep(2); for(i = 0; i < NSIGNALS; ++i) { (void)kill(pid, SIGUSR1); (void)sleep(2); } _exit(0); /* NOTREACHED */ } RL(kq = kqueue()); +#ifdef __NetBSD__ (void)strlcpy(namebuf, "EVFILT_SIGNAL", sizeof(namebuf)); km.name = namebuf; RL(ioctl(kq, KFILTER_BYNAME, &km)); (void)printf("got %d as filter number for `%s'.\n", km.filter, km.name); +#endif /* ignore the signal to avoid taking it for real */ REQUIRE_LIBC(signal(SIGUSR1, SIG_IGN), SIG_ERR); event[0].ident = SIGUSR1; +#ifdef __NetBSD__ event[0].filter = km.filter; +#else + event[0].filter = EVFILT_SIGNAL; +#endif event[0].flags = EV_ADD | EV_ENABLE; RL(kevent(kq, event, 1, NULL, 0, NULL)); (void)sleep(1); timeout.tv_sec = 1; timeout.tv_nsec = 0; for (num = 0; num < NSIGNALS; num += n) { struct timeval then, now, diff; RL(gettimeofday(&then, NULL)); RL(n = kevent(kq, NULL, 0, event, 1, &timeout)); RL(gettimeofday(&now, NULL)); timersub(&now, &then, &diff); (void)printf("sig: kevent returned %d in %lld.%06ld\n", n, (long long)diff.tv_sec, (long)diff.tv_usec); if (n == 0) continue; (void)printf("sig: kevent flags: 0x%x, data: %" PRId64 " (# " "times signal posted)\n", event[0].flags, event[0].data); } (void)waitpid(child, &status, 0); (void)printf("sig: finished successfully\n"); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, sig); return atf_no_error(); } Index: head/contrib/netbsd-tests/kernel/kqueue/t_vnode.c =================================================================== --- head/contrib/netbsd-tests/kernel/kqueue/t_vnode.c (revision 305467) +++ head/contrib/netbsd-tests/kernel/kqueue/t_vnode.c (revision 305468) @@ -1,533 +1,536 @@ +#ifdef __FreeBSD__ +#include +#endif #include #include #include #include #include #include #include /* * Test cases for events triggered by manipulating a target directory * content. Using EVFILT_VNODE filter on the target directory descriptor. * */ static const char *dir_target = "foo"; static const char *dir_inside1 = "foo/bar1"; static const char *dir_inside2 = "foo/bar2"; static const char *dir_outside = "bar"; static const char *file_inside1 = "foo/baz1"; static const char *file_inside2 = "foo/baz2"; static const char *file_outside = "qux"; static const struct timespec ts = {0, 0}; static int kq = -1; static int target = -1; int init_target(void); int init_kqueue(void); int create_file(const char *); void cleanup(void); int init_target(void) { if (mkdir(dir_target, S_IRWXU) < 0) { return -1; } target = open(dir_target, O_RDONLY, 0); return target; } int init_kqueue(void) { struct kevent eventlist[1]; kq = kqueue(); if (kq < 0) { return -1; } EV_SET(&eventlist[0], (uintptr_t)target, EVFILT_VNODE, EV_ADD | EV_ONESHOT, NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_LINK | NOTE_RENAME | NOTE_REVOKE, 0, 0); return kevent(kq, eventlist, 1, NULL, 0, NULL); } int create_file(const char *file) { int fd; fd = open(file, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR); if (fd < 0) { return -1; } return close(fd); } void cleanup(void) { (void)unlink(file_inside1); (void)unlink(file_inside2); (void)unlink(file_outside); (void)rmdir(dir_inside1); (void)rmdir(dir_inside2); (void)rmdir(dir_outside); (void)rmdir(dir_target); (void)close(kq); (void)close(target); } ATF_TC_WITH_CLEANUP(dir_no_note_link_create_file_in); ATF_TC_HEAD(dir_no_note_link_create_file_in, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) does not return NOTE_LINK for the directory " "'foo' if a file 'foo/baz' is created."); } ATF_TC_BODY(dir_no_note_link_create_file_in, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(create_file(file_inside1) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_LINK, 0); } ATF_TC_CLEANUP(dir_no_note_link_create_file_in, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_no_note_link_delete_file_in); ATF_TC_HEAD(dir_no_note_link_delete_file_in, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) does not return NOTE_LINK for the directory " "'foo' if a file 'foo/baz' is deleted."); } ATF_TC_BODY(dir_no_note_link_delete_file_in, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(create_file(file_inside1) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(unlink(file_inside1) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_LINK, 0); } ATF_TC_CLEANUP(dir_no_note_link_delete_file_in, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_no_note_link_mv_dir_within); ATF_TC_HEAD(dir_no_note_link_mv_dir_within, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) does not return NOTE_LINK for the directory " "'foo' if a directory 'foo/bar' is renamed to 'foo/baz'."); } ATF_TC_BODY(dir_no_note_link_mv_dir_within, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(mkdir(dir_inside1, S_IRWXU) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rename(dir_inside1, dir_inside2) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_LINK, 0); } ATF_TC_CLEANUP(dir_no_note_link_mv_dir_within, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_no_note_link_mv_file_within); ATF_TC_HEAD(dir_no_note_link_mv_file_within, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) does not return NOTE_LINK for the directory " "'foo' if a file 'foo/baz' is renamed to 'foo/qux'."); } ATF_TC_BODY(dir_no_note_link_mv_file_within, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(create_file(file_inside1) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rename(file_inside1, file_inside2) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_LINK, 0); } ATF_TC_CLEANUP(dir_no_note_link_mv_file_within, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_link_create_dir_in); ATF_TC_HEAD(dir_note_link_create_dir_in, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_LINK for the directory " "'foo' if a directory 'foo/bar' is created."); } ATF_TC_BODY(dir_note_link_create_dir_in, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(mkdir(dir_inside1, S_IRWXU) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_LINK, NOTE_LINK); } ATF_TC_CLEANUP(dir_note_link_create_dir_in, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_link_delete_dir_in); ATF_TC_HEAD(dir_note_link_delete_dir_in, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_LINK for the directory " "'foo' if a directory 'foo/bar' is deleted."); } ATF_TC_BODY(dir_note_link_delete_dir_in, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(mkdir(dir_inside1, S_IRWXU) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rmdir(dir_inside1) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_LINK, NOTE_LINK); } ATF_TC_CLEANUP(dir_note_link_delete_dir_in, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_link_mv_dir_in); ATF_TC_HEAD(dir_note_link_mv_dir_in, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_LINK for the directory " "'foo' if a directory 'bar' is renamed to 'foo/bar'."); } ATF_TC_BODY(dir_note_link_mv_dir_in, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(mkdir(dir_outside, S_IRWXU) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rename(dir_outside, dir_inside1) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_LINK, NOTE_LINK); } ATF_TC_CLEANUP(dir_note_link_mv_dir_in, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_link_mv_dir_out); ATF_TC_HEAD(dir_note_link_mv_dir_out, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_LINK for the directory " "'foo' if a directory 'foo/bar' is renamed to 'bar'."); } ATF_TC_BODY(dir_note_link_mv_dir_out, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(mkdir(dir_inside1, S_IRWXU) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rename(dir_inside1, dir_outside) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_LINK, NOTE_LINK); } ATF_TC_CLEANUP(dir_note_link_mv_dir_out, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_write_create_dir_in); ATF_TC_HEAD(dir_note_write_create_dir_in, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_WRITE for the directory " "'foo' if a directory 'foo/bar' is created."); } ATF_TC_BODY(dir_note_write_create_dir_in, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(mkdir(dir_inside1, S_IRWXU) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_WRITE, NOTE_WRITE); } ATF_TC_CLEANUP(dir_note_write_create_dir_in, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_write_create_file_in); ATF_TC_HEAD(dir_note_write_create_file_in, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_WRITE for the directory " "'foo' if a file 'foo/baz' is created."); } ATF_TC_BODY(dir_note_write_create_file_in, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(create_file(file_inside1) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_WRITE, NOTE_WRITE); } ATF_TC_CLEANUP(dir_note_write_create_file_in, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_write_delete_dir_in); ATF_TC_HEAD(dir_note_write_delete_dir_in, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_WRITE for the directory " "'foo' if a directory 'foo/bar' is deleted."); } ATF_TC_BODY(dir_note_write_delete_dir_in, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(mkdir(dir_inside1, S_IRWXU) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rmdir(dir_inside1) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_WRITE, NOTE_WRITE); } ATF_TC_CLEANUP(dir_note_write_delete_dir_in, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_write_delete_file_in); ATF_TC_HEAD(dir_note_write_delete_file_in, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_WRITE for the directory " "'foo' if a file 'foo/baz' is deleted."); } ATF_TC_BODY(dir_note_write_delete_file_in, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(create_file(file_inside1) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(unlink(file_inside1) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_WRITE, NOTE_WRITE); } ATF_TC_CLEANUP(dir_note_write_delete_file_in, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_write_mv_dir_in); ATF_TC_HEAD(dir_note_write_mv_dir_in, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_WRITE for the directory " "'foo' if a directory 'bar' is renamed to 'foo/bar'."); } ATF_TC_BODY(dir_note_write_mv_dir_in, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(mkdir(dir_outside, S_IRWXU) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rename(dir_outside, dir_inside1) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_WRITE, NOTE_WRITE); } ATF_TC_CLEANUP(dir_note_write_mv_dir_in, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_write_mv_dir_out); ATF_TC_HEAD(dir_note_write_mv_dir_out, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_WRITE for the directory " "'foo' if a directory 'foo/bar' is renamed to 'bar'."); } ATF_TC_BODY(dir_note_write_mv_dir_out, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(mkdir(dir_inside1, S_IRWXU) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rename(dir_inside1, dir_outside) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_WRITE, NOTE_WRITE); } ATF_TC_CLEANUP(dir_note_write_mv_dir_out, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_write_mv_dir_within); ATF_TC_HEAD(dir_note_write_mv_dir_within, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_WRITE for the directory " "'foo' if a directory 'foo/bar' is renamed to 'foo/baz'."); } ATF_TC_BODY(dir_note_write_mv_dir_within, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(mkdir(dir_inside1, S_IRWXU) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rename(dir_inside1, dir_inside2) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_WRITE, NOTE_WRITE); } ATF_TC_CLEANUP(dir_note_write_mv_dir_within, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_write_mv_file_in); ATF_TC_HEAD(dir_note_write_mv_file_in, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_WRITE for the directory " "'foo' if a file 'qux' is renamed to 'foo/baz'."); } ATF_TC_BODY(dir_note_write_mv_file_in, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(create_file(file_outside) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rename(file_outside, file_inside1) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_WRITE, NOTE_WRITE); } ATF_TC_CLEANUP(dir_note_write_mv_file_in, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_write_mv_file_out); ATF_TC_HEAD(dir_note_write_mv_file_out, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_WRITE for the directory " "'foo' if a file 'foo/baz' is renamed to 'qux'."); } ATF_TC_BODY(dir_note_write_mv_file_out, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(create_file(file_inside1) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rename(file_inside1, file_outside) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_WRITE, NOTE_WRITE); } ATF_TC_CLEANUP(dir_note_write_mv_file_out, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(dir_note_write_mv_file_within); ATF_TC_HEAD(dir_note_write_mv_file_within, tc) { atf_tc_set_md_var(tc, "descr", "This test case ensures " "that kevent(2) returns NOTE_WRITE for the directory " "'foo' if a file 'foo/baz' is renamed to 'foo/qux'."); } ATF_TC_BODY(dir_note_write_mv_file_within, tc) { struct kevent changelist[1]; ATF_REQUIRE(init_target() != -1); ATF_REQUIRE(create_file(file_inside1) != -1); ATF_REQUIRE(init_kqueue() != -1); ATF_REQUIRE(rename(file_inside1, file_inside2) != -1); ATF_REQUIRE(kevent(kq, NULL, 0, changelist, 1, &ts) != -1); ATF_CHECK_EQ(changelist[0].fflags & NOTE_WRITE, NOTE_WRITE); } ATF_TC_CLEANUP(dir_note_write_mv_file_within, tc) { cleanup(); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, dir_no_note_link_create_file_in); ATF_TP_ADD_TC(tp, dir_no_note_link_delete_file_in); ATF_TP_ADD_TC(tp, dir_no_note_link_mv_dir_within); ATF_TP_ADD_TC(tp, dir_no_note_link_mv_file_within); ATF_TP_ADD_TC(tp, dir_note_link_create_dir_in); ATF_TP_ADD_TC(tp, dir_note_link_delete_dir_in); ATF_TP_ADD_TC(tp, dir_note_link_mv_dir_in); ATF_TP_ADD_TC(tp, dir_note_link_mv_dir_out); ATF_TP_ADD_TC(tp, dir_note_write_create_dir_in); ATF_TP_ADD_TC(tp, dir_note_write_create_file_in); ATF_TP_ADD_TC(tp, dir_note_write_delete_dir_in); ATF_TP_ADD_TC(tp, dir_note_write_delete_file_in); ATF_TP_ADD_TC(tp, dir_note_write_mv_dir_in); ATF_TP_ADD_TC(tp, dir_note_write_mv_dir_out); ATF_TP_ADD_TC(tp, dir_note_write_mv_dir_within); ATF_TP_ADD_TC(tp, dir_note_write_mv_file_in); ATF_TP_ADD_TC(tp, dir_note_write_mv_file_out); ATF_TP_ADD_TC(tp, dir_note_write_mv_file_within); return atf_no_error(); } Index: head/tests/sys/kqueue/Makefile =================================================================== --- head/tests/sys/kqueue/Makefile (revision 305467) +++ head/tests/sys/kqueue/Makefile (revision 305468) @@ -1,8 +1,20 @@ # $FreeBSD$ +TESTSRC= ${SRCTOP}/contrib/netbsd-tests/kernel/kqueue + TESTSDIR= ${TESTSBASE}/sys/kqueue BINDIR= ${TESTSDIR} +NETBSD_ATF_TESTS_C= proc1_test +# XXX: fails `ke.fflags & NOTE_TRACKERR` invariant +#NETBSD_ATF_TESTS_C+= proc2_test +NETBSD_ATF_TESTS_C+= proc3_test +NETBSD_ATF_TESTS_C+= sig_test +NETBSD_ATF_TESTS_C+= vnode_test + +WARNS?= 3 + TESTS_SUBDIRS+= libkqueue +.include .include