Index: stable/12/tests/sys/fs/fusefs/getattr.cc
===================================================================
--- stable/12/tests/sys/fs/fusefs/getattr.cc	(revision 362113)
+++ stable/12/tests/sys/fs/fusefs/getattr.cc	(revision 362114)
@@ -1,304 +1,316 @@
 /*-
  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
  *
  * Copyright (c) 2019 The FreeBSD Foundation
  *
  * This software was developed by BFF Storage Systems, LLC under sponsorship
  * from the FreeBSD Foundation.
  *
  * 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 AUTHOR 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 AUTHOR 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.
  *
  * $FreeBSD$
  */
 
 extern "C" {
 #include <sys/param.h>
+
+#include <semaphore.h>
 }
 
 #include "mockfs.hh"
 #include "utils.hh"
 
 using namespace testing;
 
 class Getattr : public FuseTest {
 public:
 void expect_lookup(const char *relpath, uint64_t ino, mode_t mode,
 	uint64_t size, int times, uint64_t attr_valid, uint32_t attr_valid_nsec)
 {
 	EXPECT_LOOKUP(FUSE_ROOT_ID, relpath)
 	.Times(times)
 	.WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out.body.entry.attr.mode = mode;
 		out.body.entry.nodeid = ino;
 		out.body.entry.attr.nlink = 1;
 		out.body.entry.attr_valid = attr_valid;
 		out.body.entry.attr_valid_nsec = attr_valid_nsec;
 		out.body.entry.attr.size = size;
 		out.body.entry.entry_valid = UINT64_MAX;
 	})));
 }
 };
 
 class Getattr_7_8: public FuseTest {
 public:
 virtual void SetUp() {
 	m_kernel_minor_version = 8;
 	FuseTest::SetUp();
 }
 };
 
 /*
  * If getattr returns a non-zero cache timeout, then subsequent VOP_GETATTRs
  * should use the cached attributes, rather than query the daemon
  */
 TEST_F(Getattr, attr_cache)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const uint64_t ino = 42;
 	struct stat sb;
 
 	EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 	.WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out.body.entry.attr.mode = S_IFREG | 0644;
 		out.body.entry.nodeid = ino;
 		out.body.entry.entry_valid = UINT64_MAX;
 	})));
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([](auto in) {
 			return (in.header.opcode == FUSE_GETATTR &&
 				in.header.nodeid == ino);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, attr);
 		out.body.attr.attr_valid = UINT64_MAX;
 		out.body.attr.attr.ino = ino;	// Must match nodeid
 		out.body.attr.attr.mode = S_IFREG | 0644;
 	})));
 	EXPECT_EQ(0, stat(FULLPATH, &sb));
 	/* The second stat(2) should use cached attributes */
 	EXPECT_EQ(0, stat(FULLPATH, &sb));
 }
 
 /*
  * If getattr returns a finite but non-zero cache timeout, then we should
  * discard the cached attributes and requery the daemon after the timeout
  * period passes.
  */
 TEST_F(Getattr, attr_cache_timeout)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const uint64_t ino = 42;
 	struct stat sb;
 
 	expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1, 0, 0);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([](auto in) {
 			return (in.header.opcode == FUSE_GETATTR &&
 				in.header.nodeid == ino);
 		}, Eq(true)),
 		_)
 	).Times(2)
 	.WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, attr);
 		out.body.attr.attr_valid_nsec = NAP_NS / 2;
 		out.body.attr.attr_valid = 0;
 		out.body.attr.attr.ino = ino;	// Must match nodeid
 		out.body.attr.attr.mode = S_IFREG | 0644;
 	})));
 
 	EXPECT_EQ(0, stat(FULLPATH, &sb));
 	nap();
 	/* Timeout has expired. stat(2) should requery the daemon */
 	EXPECT_EQ(0, stat(FULLPATH, &sb));
 }
 
 /* 
  * If attr.blksize is zero, then the kernel should use a default value for
  * st_blksize
  */
 TEST_F(Getattr, blksize_zero)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const uint64_t ino = 42;
 	struct stat sb;
 
 	expect_lookup(RELPATH, ino, S_IFREG | 0644, 1, 1, 0, 0);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([](auto in) {
 			return (in.header.opcode == FUSE_GETATTR &&
 				in.header.nodeid == ino);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, attr);
 		out.body.attr.attr.mode = S_IFREG | 0644;
 		out.body.attr.attr.ino = ino;	// Must match nodeid
 		out.body.attr.attr.blksize = 0;
 		out.body.attr.attr.size = 1;
 	})));
 
 	ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno);
 	EXPECT_EQ((blksize_t)PAGE_SIZE, sb.st_blksize);
 }
 
 TEST_F(Getattr, enoent)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	struct stat sb;
 	const uint64_t ino = 42;
+	sem_t sem;
 
+	ASSERT_EQ(0, sem_init(&sem, 0, 0)) << strerror(errno);
+
 	expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1, 0, 0);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([](auto in) {
 			return (in.header.opcode == FUSE_GETATTR &&
 				in.header.nodeid == ino);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnErrno(ENOENT)));
+	// Since FUSE_GETATTR returns ENOENT, the kernel will reclaim the vnode
+	// and send a FUSE_FORGET
+	expect_forget(ino, 1, &sem);
+
 	EXPECT_NE(0, stat(FULLPATH, &sb));
 	EXPECT_EQ(ENOENT, errno);
+
+	sem_wait(&sem);
+	sem_destroy(&sem);
 }
 
 TEST_F(Getattr, ok)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const uint64_t ino = 42;
 	struct stat sb;
 
 	expect_lookup(RELPATH, ino, S_IFREG | 0644, 1, 1, 0, 0);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([](auto in) {
 			return (in.header.opcode == FUSE_GETATTR &&
 				in.body.getattr.getattr_flags == 0 &&
 				in.header.nodeid == ino);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, attr);
 		out.body.attr.attr.ino = ino;	// Must match nodeid
 		out.body.attr.attr.mode = S_IFREG | 0644;
 		out.body.attr.attr.size = 1;
 		out.body.attr.attr.blocks = 2;
 		out.body.attr.attr.atime = 3;
 		out.body.attr.attr.mtime = 4;
 		out.body.attr.attr.ctime = 5;
 		out.body.attr.attr.atimensec = 6;
 		out.body.attr.attr.mtimensec = 7;
 		out.body.attr.attr.ctimensec = 8;
 		out.body.attr.attr.nlink = 9;
 		out.body.attr.attr.uid = 10;
 		out.body.attr.attr.gid = 11;
 		out.body.attr.attr.rdev = 12;
 		out.body.attr.attr.blksize = 12345;
 	})));
 
 	ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno);
 	EXPECT_EQ(1, sb.st_size);
 	EXPECT_EQ(2, sb.st_blocks);
 	EXPECT_EQ(3, sb.st_atim.tv_sec);
 	EXPECT_EQ(6, sb.st_atim.tv_nsec);
 	EXPECT_EQ(4, sb.st_mtim.tv_sec);
 	EXPECT_EQ(7, sb.st_mtim.tv_nsec);
 	EXPECT_EQ(5, sb.st_ctim.tv_sec);
 	EXPECT_EQ(8, sb.st_ctim.tv_nsec);
 	EXPECT_EQ(9ull, sb.st_nlink);
 	EXPECT_EQ(10ul, sb.st_uid);
 	EXPECT_EQ(11ul, sb.st_gid);
 	EXPECT_EQ(12ul, sb.st_rdev);
 	EXPECT_EQ((blksize_t)12345, sb.st_blksize);
 	EXPECT_EQ(ino, sb.st_ino);
 	EXPECT_EQ(S_IFREG | 0644, sb.st_mode);
 
 	//st_birthtim and st_flags are not supported by protocol 7.8.  They're
 	//only supported as OS-specific extensions to OSX.
 	//EXPECT_EQ(, sb.st_birthtim);
 	//EXPECT_EQ(, sb.st_flags);
 	
 	//FUSE can't set st_blksize until protocol 7.9
 }
 
 TEST_F(Getattr_7_8, ok)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const uint64_t ino = 42;
 	struct stat sb;
 
 	EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, entry_7_8);
 		out.body.entry.attr.mode = S_IFREG | 0644;
 		out.body.entry.nodeid = ino;
 		out.body.entry.attr.nlink = 1;
 		out.body.entry.attr.size = 1;
 	})));
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([](auto in) {
 			return (in.header.opcode == FUSE_GETATTR &&
 				in.header.nodeid == ino);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnImmediate([](auto i __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, attr_7_8);
 		out.body.attr.attr.ino = ino;	// Must match nodeid
 		out.body.attr.attr.mode = S_IFREG | 0644;
 		out.body.attr.attr.size = 1;
 		out.body.attr.attr.blocks = 2;
 		out.body.attr.attr.atime = 3;
 		out.body.attr.attr.mtime = 4;
 		out.body.attr.attr.ctime = 5;
 		out.body.attr.attr.atimensec = 6;
 		out.body.attr.attr.mtimensec = 7;
 		out.body.attr.attr.ctimensec = 8;
 		out.body.attr.attr.nlink = 9;
 		out.body.attr.attr.uid = 10;
 		out.body.attr.attr.gid = 11;
 		out.body.attr.attr.rdev = 12;
 	})));
 
 	ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno);
 	EXPECT_EQ(1, sb.st_size);
 	EXPECT_EQ(2, sb.st_blocks);
 	EXPECT_EQ(3, sb.st_atim.tv_sec);
 	EXPECT_EQ(6, sb.st_atim.tv_nsec);
 	EXPECT_EQ(4, sb.st_mtim.tv_sec);
 	EXPECT_EQ(7, sb.st_mtim.tv_nsec);
 	EXPECT_EQ(5, sb.st_ctim.tv_sec);
 	EXPECT_EQ(8, sb.st_ctim.tv_nsec);
 	EXPECT_EQ(9ull, sb.st_nlink);
 	EXPECT_EQ(10ul, sb.st_uid);
 	EXPECT_EQ(11ul, sb.st_gid);
 	EXPECT_EQ(12ul, sb.st_rdev);
 	EXPECT_EQ(ino, sb.st_ino);
 	EXPECT_EQ(S_IFREG | 0644, sb.st_mode);
 
 	//st_birthtim and st_flags are not supported by protocol 7.8.  They're
 	//only supported as OS-specific extensions to OSX.
 }
Index: stable/12/tests/sys/fs/fusefs/open.cc
===================================================================
--- stable/12/tests/sys/fs/fusefs/open.cc	(revision 362113)
+++ stable/12/tests/sys/fs/fusefs/open.cc	(revision 362114)
@@ -1,264 +1,276 @@
 /*-
  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
  *
  * Copyright (c) 2019 The FreeBSD Foundation
  *
  * This software was developed by BFF Storage Systems, LLC under sponsorship
  * from the FreeBSD Foundation.
  *
  * 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 AUTHOR 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 AUTHOR 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.
  *
  * $FreeBSD$
  */
 
 extern "C" {
 #include <sys/wait.h>
+
 #include <fcntl.h>
+#include <semaphore.h>
 }
 
 #include "mockfs.hh"
 #include "utils.hh"
 
 using namespace testing;
 
 class Open: public FuseTest {
 
 public:
 
 /* Test an OK open of a file with the given flags */
 void test_ok(int os_flags, int fuse_flags) {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	uint64_t ino = 42;
 	int fd;
 
 	FuseTest::expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in.header.opcode == FUSE_OPEN &&
 				in.body.open.flags == (uint32_t)fuse_flags &&
 				in.header.nodeid == ino);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnImmediate([](auto in __unused, auto& out) {
 		out.header.len = sizeof(out.header);
 		SET_OUT_HEADER_LEN(out, open);
 	})));
 
 	fd = open(FULLPATH, os_flags);
 	EXPECT_LE(0, fd) << strerror(errno);
 	leak(fd);
 }
 };
 
 
 /* 
  * fusefs(5) does not support I/O on device nodes (neither does UFS).  But it
  * shouldn't crash
  */
 TEST_F(Open, chr)
 {
 	const char FULLPATH[] = "mountpoint/zero";
 	const char RELPATH[] = "zero";
 	uint64_t ino = 42;
 
 	EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
 	.WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out.body.entry.attr.mode = S_IFCHR | 0644;
 		out.body.entry.nodeid = ino;
 		out.body.entry.attr.nlink = 1;
 		out.body.entry.attr_valid = UINT64_MAX;
 		out.body.entry.attr.rdev = 44;	/* /dev/zero's rdev */
 	})));
 
 	ASSERT_EQ(-1, open(FULLPATH, O_RDONLY));
 	EXPECT_EQ(EOPNOTSUPP, errno);
 }
 
 /* 
  * The fuse daemon fails the request with enoent.  This usually indicates a
  * race condition: some other FUSE client removed the file in between when the
  * kernel checked for it with lookup and tried to open it
  */
 TEST_F(Open, enoent)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	uint64_t ino = 42;
+	sem_t sem;
 
+	ASSERT_EQ(0, sem_init(&sem, 0, 0)) << strerror(errno);
+
 	expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in.header.opcode == FUSE_OPEN &&
 				in.header.nodeid == ino);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnErrno(ENOENT)));
+	// Since FUSE_OPEN returns ENOENT, the kernel will reclaim the vnode
+	// and send a FUSE_FORGET
+	expect_forget(ino, 1, &sem);
+
 	ASSERT_EQ(-1, open(FULLPATH, O_RDONLY));
 	EXPECT_EQ(ENOENT, errno);
+
+	sem_wait(&sem);
+	sem_destroy(&sem);
 }
 
 /* 
  * The daemon is responsible for checking file permissions (unless the
  * default_permissions mount option was used)
  */
 TEST_F(Open, eperm)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	uint64_t ino = 42;
 
 	expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in.header.opcode == FUSE_OPEN &&
 				in.header.nodeid == ino);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnErrno(EPERM)));
 	ASSERT_EQ(-1, open(FULLPATH, O_RDONLY));
 	EXPECT_EQ(EPERM, errno);
 }
 
 /* 
  * fusefs must issue multiple FUSE_OPEN operations if clients with different
  * credentials open the same file, even if they use the same mode.  This is
  * necessary so that the daemon can validate each set of credentials.
  */
 TEST_F(Open, multiple_creds)
 {
 	const static char FULLPATH[] = "mountpoint/some_file.txt";
 	const static char RELPATH[] = "some_file.txt";
 	int fd1, status;
 	const static uint64_t ino = 42;
 	const static uint64_t fh0 = 100, fh1 = 200;
 
 	/* Fork a child to open the file with different credentials */
 	fork(false, &status, [&] {
 
 		expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 2);
 		EXPECT_CALL(*m_mock, process(
 			ResultOf([=](auto in) {
 				return (in.header.opcode == FUSE_OPEN &&
 					in.header.pid == (uint32_t)getpid() &&
 					in.header.nodeid == ino);
 			}, Eq(true)),
 			_)
 		).WillOnce(Invoke(
 			ReturnImmediate([](auto in __unused, auto& out) {
 			out.body.open.fh = fh0;
 			out.header.len = sizeof(out.header);
 			SET_OUT_HEADER_LEN(out, open);
 		})));
 
 		EXPECT_CALL(*m_mock, process(
 			ResultOf([=](auto in) {
 				return (in.header.opcode == FUSE_OPEN &&
 					in.header.pid != (uint32_t)getpid() &&
 					in.header.nodeid == ino);
 			}, Eq(true)),
 			_)
 		).WillOnce(Invoke(
 			ReturnImmediate([](auto in __unused, auto& out) {
 			out.body.open.fh = fh1;
 			out.header.len = sizeof(out.header);
 			SET_OUT_HEADER_LEN(out, open);
 		})));
 		expect_flush(ino, 2, ReturnErrno(0));
 		expect_release(ino, fh0);
 		expect_release(ino, fh1);
 
 		fd1 = open(FULLPATH, O_RDONLY);
 		EXPECT_LE(0, fd1) << strerror(errno);
 	}, [] {
 		int fd0;
 
 		fd0 = open(FULLPATH, O_RDONLY);
 		if (fd0 < 0) {
 			perror("open");
 			return(1);
 		}
 		return 0;
 	}
 	);
 	ASSERT_EQ(0, WEXITSTATUS(status));
 
 	close(fd1);
 }
 
 /* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=236340 */
 TEST_F(Open, DISABLED_o_append)
 {
 	test_ok(O_WRONLY | O_APPEND, O_WRONLY | O_APPEND);
 }
 
 /* The kernel is supposed to filter out this flag */
 TEST_F(Open, o_creat)
 {
 	test_ok(O_WRONLY | O_CREAT, O_WRONLY);
 }
 
 /* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=236340 */
 TEST_F(Open, DISABLED_o_direct)
 {
 	test_ok(O_WRONLY | O_DIRECT, O_WRONLY | O_DIRECT);
 }
 
 /* The kernel is supposed to filter out this flag */
 TEST_F(Open, o_excl)
 {
 	test_ok(O_WRONLY | O_EXCL, O_WRONLY);
 }
 
 TEST_F(Open, o_exec)
 {
 	test_ok(O_EXEC, O_EXEC);
 }
 
 /* The kernel is supposed to filter out this flag */
 TEST_F(Open, o_noctty)
 {
 	test_ok(O_WRONLY | O_NOCTTY, O_WRONLY);
 }
 
 TEST_F(Open, o_rdonly)
 {
 	test_ok(O_RDONLY, O_RDONLY);
 }
 
 /* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=236340 */
 TEST_F(Open, DISABLED_o_trunc)
 {
 	test_ok(O_WRONLY | O_TRUNC, O_WRONLY | O_TRUNC);
 }
 
 TEST_F(Open, o_wronly)
 {
 	test_ok(O_WRONLY, O_WRONLY);
 }
 
 TEST_F(Open, o_rdwr)
 {
 	test_ok(O_RDWR, O_RDWR);
 }
 
Index: stable/12/tests/sys/fs/fusefs/opendir.cc
===================================================================
--- stable/12/tests/sys/fs/fusefs/opendir.cc	(revision 362113)
+++ stable/12/tests/sys/fs/fusefs/opendir.cc	(revision 362114)
@@ -1,163 +1,174 @@
 /*-
  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
  *
  * Copyright (c) 2019 The FreeBSD Foundation
  *
  * This software was developed by BFF Storage Systems, LLC under sponsorship
  * from the FreeBSD Foundation.
  *
  * 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 AUTHOR 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 AUTHOR 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.
  *
  * $FreeBSD$
  */
 
 extern "C" {
 #include <dirent.h>
+
 #include <fcntl.h>
+#include <semaphore.h>
 }
 
 #include "mockfs.hh"
 #include "utils.hh"
 
 using namespace testing;
 
 class Opendir: public FuseTest {
 public:
 void expect_lookup(const char *relpath, uint64_t ino)
 {
 	FuseTest::expect_lookup(relpath, ino, S_IFDIR | 0755, 0, 1);
 }
 
 void expect_opendir(uint64_t ino, uint32_t flags, ProcessMockerT r)
 {
 	/* opendir(3) calls fstatfs */
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([](auto in) {
 			return (in.header.opcode == FUSE_STATFS);
 		}, Eq(true)),
 		_)
 	).WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, statfs);
 	})));
 
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in.header.opcode == FUSE_OPENDIR &&
 				in.header.nodeid == ino &&
 				in.body.opendir.flags == flags);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(r));
 }
 
 };
 
 
 /* 
  * The fuse daemon fails the request with enoent.  This usually indicates a
  * race condition: some other FUSE client removed the file in between when the
  * kernel checked for it with lookup and tried to open it
  */
 TEST_F(Opendir, enoent)
 {
 	const char FULLPATH[] = "mountpoint/some_dir";
 	const char RELPATH[] = "some_dir";
 	uint64_t ino = 42;
+	sem_t sem;
 
+	ASSERT_EQ(0, sem_init(&sem, 0, 0)) << strerror(errno);
+
 	expect_lookup(RELPATH, ino);
 	expect_opendir(ino, O_RDONLY, ReturnErrno(ENOENT));
+	// Since FUSE_OPENDIR returns ENOENT, the kernel will reclaim the vnode
+	// and send a FUSE_FORGET
+	expect_forget(ino, 1, &sem);
 
 	ASSERT_EQ(-1, open(FULLPATH, O_DIRECTORY));
 	EXPECT_EQ(ENOENT, errno);
+
+	sem_wait(&sem);
+	sem_destroy(&sem);
 }
 
 /* 
  * The daemon is responsible for checking file permissions (unless the
  * default_permissions mount option was used)
  */
 TEST_F(Opendir, eperm)
 {
 	const char FULLPATH[] = "mountpoint/some_dir";
 	const char RELPATH[] = "some_dir";
 	uint64_t ino = 42;
 
 	expect_lookup(RELPATH, ino);
 	expect_opendir(ino, O_RDONLY, ReturnErrno(EPERM));
 
 	EXPECT_EQ(-1, open(FULLPATH, O_DIRECTORY));
 	EXPECT_EQ(EPERM, errno);
 }
 
 TEST_F(Opendir, open)
 {
 	const char FULLPATH[] = "mountpoint/some_dir";
 	const char RELPATH[] = "some_dir";
 	uint64_t ino = 42;
 	int fd;
 
 	expect_lookup(RELPATH, ino);
 	expect_opendir(ino, O_RDONLY,
 	ReturnImmediate([=](auto in __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, open);
 	}));
 
 	fd = open(FULLPATH, O_DIRECTORY);
 	EXPECT_LE(0, fd) << strerror(errno);
 
 	leak(fd);
 }
 
 /* Directories can be opened O_EXEC for stuff like fchdir(2) */
 TEST_F(Opendir, open_exec)
 {
 	const char FULLPATH[] = "mountpoint/some_dir";
 	const char RELPATH[] = "some_dir";
 	uint64_t ino = 42;
 	int fd;
 
 	expect_lookup(RELPATH, ino);
 	expect_opendir(ino, O_EXEC,
 	ReturnImmediate([=](auto in __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, open);
 	}));
 
 	fd = open(FULLPATH, O_EXEC | O_DIRECTORY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	leak(fd);
 }
 
 TEST_F(Opendir, opendir)
 {
 	const char FULLPATH[] = "mountpoint/some_dir";
 	const char RELPATH[] = "some_dir";
 	uint64_t ino = 42;
 
 	expect_lookup(RELPATH, ino);
 	expect_opendir(ino, O_RDONLY,
 	ReturnImmediate([=](auto in __unused, auto& out) {
 		SET_OUT_HEADER_LEN(out, open);
 	}));
 
 	errno = 0;
 	EXPECT_NE(nullptr, opendir(FULLPATH)) << strerror(errno);
 }
Index: stable/12
===================================================================
--- stable/12	(revision 362113)
+++ stable/12	(revision 362114)

Property changes on: stable/12
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head:r361223