Re: kern/48958: kevent(2): EVFILT_VNODE filter miscounting hardlinks

[rudolf <netbsd%eq.cz@localhost>]

The following reply was made to PR kern/48958; it has been noted by GNATS.

From: rudolf <netbsd%eq.cz@localhost>
To: gnats-bugs%NetBSD.org@localhost
Cc: 
Subject: Re: kern/48958: kevent(2): EVFILT_VNODE filter miscounting hardlinks
Date: Thu, 03 Jul 2014 00:14:16 +0200

 This is a multi-part message in MIME format.
 --------------090009000106070409060508
 Content-Type: text/plain; charset=ISO-8859-1; format=flowed
 Content-Transfer-Encoding: 7bit
 
 Here is an improved version of the ATF test program. Now it contains 14 
 test cases with two of them failing currently under NetBSD 6.1_STABLE amd64.
 
 r.
 
 
 --------------090009000106070409060508
 Content-Type: text/x-csrc;
  name="t_vnode1.c"
 Content-Transfer-Encoding: 7bit
 Content-Disposition: attachment;
  filename="t_vnode1.c"
 
 #include <sys/event.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <unistd.h>
 
 #include <atf-c.h>
 
 /*
  * 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_inside = "foo/bar";
 static const char *dir_outside = "bar";
 static const char *file_inside = "foo/baz";
 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()
 {
        if (mkdir(dir_target, S_IRWXU) < 0) {
                return -1;
        }
        target = open(dir_target, O_RDONLY, 0);
        return target;
 }
 
 int
 init_kqueue()
 {
        struct kevent eventlist[1];
 
        kq = kqueue();
        if (kq < 0) {
                return -1;
        }
        EV_SET(&eventlist[0], 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_inside);
        (void)unlink(file_outside);
        (void)rmdir(dir_inside);
        (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_inside) != -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_inside) != -1);
        ATF_REQUIRE(init_kqueue() != -1);
 
        ATF_REQUIRE(unlink(file_inside) != -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_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_inside, 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_inside, S_IRWXU) != -1);
        ATF_REQUIRE(init_kqueue() != -1);
 
        ATF_REQUIRE(rmdir(dir_inside) != -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_inside) != -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_inside, S_IRWXU) != -1);
        ATF_REQUIRE(init_kqueue() != -1);
 
        ATF_REQUIRE(rename(dir_inside, 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_inside, 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_inside) != -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_inside, S_IRWXU) != -1);
        ATF_REQUIRE(init_kqueue() != -1);
 
        ATF_REQUIRE(rmdir(dir_inside) != -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_inside) != -1);
        ATF_REQUIRE(init_kqueue() != -1);
 
        ATF_REQUIRE(unlink(file_inside) != -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_inside) != -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 'foo'.");
 }
 ATF_TC_BODY(dir_note_write_mv_dir_out, tc)
 {
        struct kevent changelist[1];
 
        ATF_REQUIRE(init_target() != -1);
        ATF_REQUIRE(mkdir(dir_inside, S_IRWXU) != -1);
        ATF_REQUIRE(init_kqueue() != -1);
 
        ATF_REQUIRE(rename(dir_inside, 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_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_inside) != -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_inside) != -1);
        ATF_REQUIRE(init_kqueue() != -1);
 
        ATF_REQUIRE(rename(file_inside, 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_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_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_file_in);
        ATF_TP_ADD_TC(tp, dir_note_write_mv_file_out);
        return atf_no_error();
 }
 
 --------------090009000106070409060508--