Index: projects/fuse2/tests/sys/fs/fusefs/getattr.cc
===================================================================
--- projects/fuse2/tests/sys/fs/fusefs/getattr.cc	(revision 347402)
+++ projects/fuse2/tests/sys/fs/fusefs/getattr.cc	(revision 347403)
@@ -1,204 +1,199 @@
 /*-
  * 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.
  */
 
 #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(1, 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;
 	})));
 }
 };
 
 
 /*
  * 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(1, 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;
-	/* 
-	 * The timeout should be longer than the longest plausible time the
-	 * daemon would take to complete a write(2) to /dev/fuse, but no longer.
-	 */
-	long timeout_ns = 250'000'000;
 
 	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 = timeout_ns;
+		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));
-	usleep(2 * timeout_ns / 1000);
+	nap();
 	/* Timeout has expired. stat(2) should requery the daemon */
 	EXPECT_EQ(0, stat(FULLPATH, &sb));
 }
 
 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;
 
 	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)));
 	EXPECT_NE(0, stat(FULLPATH, &sb));
 	EXPECT_EQ(ENOENT, errno);
 }
 
 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->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;
 	})));
 
 	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.
 	//EXPECT_EQ(, sb.st_birthtim);
 	//EXPECT_EQ(, sb.st_flags);
 	
 	//FUSE can't set st_blksize until protocol 7.9
 }
Index: projects/fuse2/tests/sys/fs/fusefs/interrupt.cc
===================================================================
--- projects/fuse2/tests/sys/fs/fusefs/interrupt.cc	(revision 347402)
+++ projects/fuse2/tests/sys/fs/fusefs/interrupt.cc	(revision 347403)
@@ -1,762 +1,762 @@
 /*-
  * 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.
  */
 
 extern "C" {
 #include <sys/types.h>
 #include <sys/extattr.h>
 #include <sys/mman.h>
 #include <sys/wait.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <semaphore.h>
 #include <signal.h>
 }
 
 #include "mockfs.hh"
 #include "utils.hh"
 
 using namespace testing;
 
 /* Initial size of files used by these tests */
 const off_t FILESIZE = 1000;
 /* Access mode used by all directories in these tests */
 const mode_t MODE = 0755;
 const char FULLDIRPATH0[] = "mountpoint/some_dir";
 const char RELDIRPATH0[] = "some_dir";
 const char FULLDIRPATH1[] = "mountpoint/other_dir";
 const char RELDIRPATH1[] = "other_dir";
 
 static sem_t *blocked_semaphore;
 static sem_t *signaled_semaphore;
 
 static bool killer_should_sleep = false;
 
 /* Don't do anything; all we care about is that the syscall gets interrupted */
 void sigusr2_handler(int __unused sig) {
 	if (verbosity > 1) {
 		printf("Signaled!  thread %p\n", pthread_self());
 	}
 
 }
 
 void* killer(void* target) {
 	/* Wait until the main thread is blocked in fdisp_wait_answ */
 	if (killer_should_sleep)
-		usleep(250'000);
+		nap();
 	else
 		sem_wait(blocked_semaphore);
 	if (verbosity > 1)
 		printf("Signalling!  thread %p\n", target);
 	pthread_kill((pthread_t)target, SIGUSR2);
 	if (signaled_semaphore != NULL)
 		sem_post(signaled_semaphore);
 
 	return(NULL);
 }
 
 class Interrupt: public FuseTest {
 public:
 pthread_t m_child;
 
 Interrupt(): m_child(NULL) {};
 
 void expect_lookup(const char *relpath, uint64_t ino)
 {
 	FuseTest::expect_lookup(relpath, ino, S_IFREG | 0644, FILESIZE, 1);
 }
 
 /* 
  * Expect a FUSE_MKDIR but don't reply.  Instead, just record the unique value
  * to the provided pointer
  */
 void expect_mkdir(uint64_t *mkdir_unique)
 {
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_MKDIR);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke([=](auto in, auto &out __unused) {
 		*mkdir_unique = in->header.unique;
 		sem_post(blocked_semaphore);
 	}));
 }
 
 /* 
  * Expect a FUSE_READ but don't reply.  Instead, just record the unique value
  * to the provided pointer
  */
 void expect_read(uint64_t ino, uint64_t *read_unique)
 {
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_READ &&
 				in->header.nodeid == ino);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke([=](auto in, auto &out __unused) {
 		*read_unique = in->header.unique;
 		sem_post(blocked_semaphore);
 	}));
 }
 
 /* 
  * Expect a FUSE_WRITE but don't reply.  Instead, just record the unique value
  * to the provided pointer
  */
 void expect_write(uint64_t ino, uint64_t *write_unique)
 {
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_WRITE &&
 				in->header.nodeid == ino);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke([=](auto in, auto &out __unused) {
 		*write_unique = in->header.unique;
 		sem_post(blocked_semaphore);
 	}));
 }
 
 void setup_interruptor(pthread_t target, bool sleep = false)
 {
 	ASSERT_NE(SIG_ERR, signal(SIGUSR2, sigusr2_handler)) << strerror(errno);
 	killer_should_sleep = sleep;
 	ASSERT_EQ(0, pthread_create(&m_child, NULL, killer, (void*)target))
 		<< strerror(errno);
 }
 
 void SetUp() {
 	const int mprot = PROT_READ | PROT_WRITE;
 	const int mflags = MAP_ANON | MAP_SHARED;
 
 	signaled_semaphore = NULL;
 
 	blocked_semaphore = (sem_t*)mmap(NULL, sizeof(*blocked_semaphore),
 		mprot, mflags, -1, 0);
 	ASSERT_NE(MAP_FAILED, blocked_semaphore) << strerror(errno);
 	ASSERT_EQ(0, sem_init(blocked_semaphore, 1, 0)) << strerror(errno);
 
 	FuseTest::SetUp();
 }
 
 void TearDown() {
 	struct sigaction sa;
 
 	if (m_child != NULL) {
 		pthread_join(m_child, NULL);
 	}
 	bzero(&sa, sizeof(sa));
 	sa.sa_handler = SIG_DFL;
 	sigaction(SIGUSR2, &sa, NULL);
 
 	sem_destroy(blocked_semaphore);
 	munmap(blocked_semaphore, sizeof(*blocked_semaphore));
 
 	FuseTest::TearDown();
 }
 };
 
 static void* mkdir0(void* arg __unused) {
 	ssize_t r;
 
 	r = mkdir(FULLDIRPATH0, MODE);
 	if (r >= 0)
 		return 0;
 	else
 		return (void*)(intptr_t)errno;
 }
 
 static void* read1(void* arg) {
 	const size_t bufsize = FILESIZE;
 	char buf[bufsize];
 	int fd = (int)(intptr_t)arg;
 	ssize_t r;
 
 	r = read(fd, buf, bufsize);
 	if (r >= 0)
 		return 0;
 	else
 		return (void*)(intptr_t)errno;
 }
 
 /* 
  * An interrupt operation that gets received after the original command is
  * complete should generate an EAGAIN response.
  */
 /* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=236530 */
 TEST_F(Interrupt, already_complete)
 {
 	uint64_t ino = 42;
 	pthread_t self;
 	uint64_t mkdir_unique = 0;
 
 	self = pthread_self();
 
 	EXPECT_LOOKUP(1, RELDIRPATH0).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	expect_mkdir(&mkdir_unique);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([&](auto in) {
 			return (in->header.opcode == FUSE_INTERRUPT &&
 				in->body.interrupt.unique == mkdir_unique);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke([&](auto in, auto &out) {
 		// First complete the mkdir request
 		auto out0 = new mockfs_buf_out;
 		out0->header.unique = mkdir_unique;
 		SET_OUT_HEADER_LEN(out0, entry);
 		out0->body.create.entry.attr.mode = S_IFDIR | MODE;
 		out0->body.create.entry.nodeid = ino;
 		out.push_back(out0);
 
 		// Then, respond EAGAIN to the interrupt request
 		auto out1 = new mockfs_buf_out;
 		out1->header.unique = in->header.unique;
 		out1->header.error = -EAGAIN;
 		out1->header.len = sizeof(out1->header);
 		out.push_back(out1);
 	}));
 
 	setup_interruptor(self);
 	EXPECT_EQ(0, mkdir(FULLDIRPATH0, MODE)) << strerror(errno);
 }
 
 /*
  * If a FUSE file system returns ENOSYS for a FUSE_INTERRUPT operation, the
  * kernel should not attempt to interrupt any other operations on that mount
  * point.
  */
 TEST_F(Interrupt, enosys)
 {
 	uint64_t ino0 = 42, ino1 = 43;;
 	uint64_t mkdir_unique;
 	pthread_t self, th0;
 	sem_t sem0, sem1;
 	void *thr0_value;
 	Sequence seq;
 
 	self = pthread_self();
 	ASSERT_EQ(0, sem_init(&sem0, 0, 0)) << strerror(errno);
 	ASSERT_EQ(0, sem_init(&sem1, 0, 0)) << strerror(errno);
 
 	EXPECT_LOOKUP(1, RELDIRPATH1).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	EXPECT_LOOKUP(1, RELDIRPATH0).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	expect_mkdir(&mkdir_unique);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([&](auto in) {
 			return (in->header.opcode == FUSE_INTERRUPT &&
 				in->body.interrupt.unique == mkdir_unique);
 		}, Eq(true)),
 		_)
 	).InSequence(seq)
 	.WillOnce(Invoke([&](auto in, auto &out) {
 		// reject FUSE_INTERRUPT and respond to the FUSE_WRITE
 		auto out0 = new mockfs_buf_out;
 		auto out1 = new mockfs_buf_out;
 
 		out0->header.unique = in->header.unique;
 		out0->header.error = -ENOSYS;
 		out0->header.len = sizeof(out0->header);
 		out.push_back(out0);
 
 		SET_OUT_HEADER_LEN(out1, entry);
 		out1->body.create.entry.attr.mode = S_IFDIR | MODE;
 		out1->body.create.entry.nodeid = ino1;
 		out1->header.unique = mkdir_unique;
 		out.push_back(out1);
 	}));
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([&](auto in) {
 			return (in->header.opcode == FUSE_MKDIR);
 		}, Eq(true)),
 		_)
 	).InSequence(seq)
 	.WillOnce(Invoke([&](auto in, auto &out) {
 		auto out0 = new mockfs_buf_out;
 
 		sem_post(&sem0);
 		sem_wait(&sem1);
 
 		SET_OUT_HEADER_LEN(out0, entry);
 		out0->body.create.entry.attr.mode = S_IFDIR | MODE;
 		out0->body.create.entry.nodeid = ino0;
 		out0->header.unique = in->header.unique;
 		out.push_back(out0);
 	}));
 
 	setup_interruptor(self);
 	/* First mkdir operation should finish synchronously */
 	ASSERT_EQ(0, mkdir(FULLDIRPATH1, MODE)) << strerror(errno);
 
 	ASSERT_EQ(0, pthread_create(&th0, NULL, mkdir0, NULL))
 		<< strerror(errno);
 
 	sem_wait(&sem0);
 	/*
 	 * th0 should be blocked waiting for the fuse daemon thread.
 	 * Signal it.  No FUSE_INTERRUPT should result
 	 */
 	pthread_kill(th0, SIGUSR1);
 	/* Allow the daemon thread to proceed */
 	sem_post(&sem1);
 	pthread_join(th0, &thr0_value);
 	/* Second mkdir should've finished without error */
 	EXPECT_EQ(0, (intptr_t)thr0_value);
 }
 
 /*
  * Upon receipt of a fatal signal, fusefs should return ASAP after sending
  * FUSE_INTERRUPT.
  */
 TEST_F(Interrupt, fatal_signal)
 {
 	int status;
 	pthread_t self;
 	uint64_t mkdir_unique;
 
 	self = pthread_self();
 
 	EXPECT_LOOKUP(1, RELDIRPATH0).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	expect_mkdir(&mkdir_unique);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([&](auto in) {
 			return (in->header.opcode == FUSE_INTERRUPT &&
 				in->body.interrupt.unique == mkdir_unique);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke([&](auto in __unused, auto &out __unused) {
 		/* Don't respond.  The process should exit anyway */
 	}));
 
 	fork(false, &status, [&] {
 	}, [&]() {
 		struct sigaction sa;
 		int r;
 		pthread_t killer_th;
 		pthread_t self;
 
 		/* SIGUSR2 terminates the process by default */
 		bzero(&sa, sizeof(sa));
 		sa.sa_handler = SIG_DFL;
 		r = sigaction(SIGUSR2, &sa, NULL);
 		if (r != 0) {
 			perror("sigaction");
 			return 1;
 		}
 		self = pthread_self();
 		r = pthread_create(&killer_th, NULL, killer, (void*)self);
 		if (r != 0) {
 			perror("pthread_create");
 			return 1;
 		}
 
 		mkdir(FULLDIRPATH0, MODE);
 		return 1;
 	});
 	ASSERT_EQ(SIGUSR2, WTERMSIG(status));
 }
 
 /*
  * A FUSE filesystem is legally allowed to ignore INTERRUPT operations, and
  * complete the original operation whenever it damn well pleases.
  */
 /* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=236530 */
 TEST_F(Interrupt, ignore)
 {
 	uint64_t ino = 42;
 	pthread_t self;
 	uint64_t mkdir_unique;
 
 	self = pthread_self();
 
 	EXPECT_LOOKUP(1, RELDIRPATH0).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	expect_mkdir(&mkdir_unique);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([&](auto in) {
 			return (in->header.opcode == FUSE_INTERRUPT &&
 				in->body.interrupt.unique == mkdir_unique);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke([&](auto in __unused, auto &out) {
 		// Ignore FUSE_INTERRUPT; respond to the FUSE_MKDIR
 		auto out0 = new mockfs_buf_out;
 		out0->header.unique = mkdir_unique;
 		SET_OUT_HEADER_LEN(out0, entry);
 		out0->body.create.entry.attr.mode = S_IFDIR | MODE;
 		out0->body.create.entry.nodeid = ino;
 		out.push_back(out0);
 	}));
 
 	setup_interruptor(self);
 	ASSERT_EQ(0, mkdir(FULLDIRPATH0, MODE)) << strerror(errno);
 }
 
 /*
  * A restartable operation (basically, anything except write or setextattr)
  * that hasn't yet been sent to userland can be interrupted without sending
  * FUSE_INTERRUPT, and will be automatically restarted.
  */
 TEST_F(Interrupt, in_kernel_restartable)
 {
 	const char FULLPATH1[] = "mountpoint/other_file.txt";
 	const char RELPATH1[] = "other_file.txt";
 	uint64_t ino0 = 42, ino1 = 43;
 	int fd1;
 	pthread_t self, th0, th1;
 	sem_t sem0, sem1;
 	void *thr0_value, *thr1_value;
 
 	ASSERT_EQ(0, sem_init(&sem0, 0, 0)) << strerror(errno);
 	ASSERT_EQ(0, sem_init(&sem1, 0, 0)) << strerror(errno);
 	self = pthread_self();
 
 	EXPECT_LOOKUP(1, RELDIRPATH0).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	expect_lookup(RELPATH1, ino1);
 	expect_open(ino1, 0, 1);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_MKDIR);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnImmediate([&](auto in __unused, auto out) {
 		/* Let the next write proceed */
 		sem_post(&sem1);
 		/* Pause the daemon thread so it won't read the next op */
 		sem_wait(&sem0);
 
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.create.entry.attr.mode = S_IFDIR | MODE;
 		out->body.create.entry.nodeid = ino0;
 	})));
 	FuseTest::expect_read(ino1, 0, FILESIZE, 0, NULL);
 
 	fd1 = open(FULLPATH1, O_RDONLY);
 	ASSERT_LE(0, fd1) << strerror(errno);
 
 	/* Use a separate thread for each operation */
 	ASSERT_EQ(0, pthread_create(&th0, NULL, mkdir0, NULL))
 		<< strerror(errno);
 
 	sem_wait(&sem1);	/* Sequence the two operations */
 
 	ASSERT_EQ(0, pthread_create(&th1, NULL, read1, (void*)(intptr_t)fd1))
 		<< strerror(errno);
 
 	setup_interruptor(self, true);
 
 	pause();		/* Wait for signal */
 
 	/* Unstick the daemon */
 	ASSERT_EQ(0, sem_post(&sem0)) << strerror(errno);
 
 	/* Wait awhile to make sure the signal generates no FUSE_INTERRUPT */
-	usleep(250'000);
+	nap();
 
 	pthread_join(th1, &thr1_value);
 	pthread_join(th0, &thr0_value);
 	EXPECT_EQ(0, (intptr_t)thr1_value);
 	EXPECT_EQ(0, (intptr_t)thr0_value);
 	sem_destroy(&sem1);
 	sem_destroy(&sem0);
 }
 
 /*
  * An operation that hasn't yet been sent to userland can be interrupted
  * without sending FUSE_INTERRUPT.  If it's a non-restartable operation (write
  * or setextattr) it will return EINTR.
  */
 TEST_F(Interrupt, in_kernel_nonrestartable)
 {
 	const char FULLPATH1[] = "mountpoint/other_file.txt";
 	const char RELPATH1[] = "other_file.txt";
 	const char value[] = "whatever";
 	ssize_t value_len = strlen(value) + 1;
 	uint64_t ino0 = 42, ino1 = 43;
 	int ns = EXTATTR_NAMESPACE_USER;
 	int fd1;
 	pthread_t self, th0;
 	sem_t sem0, sem1;
 	void *thr0_value;
 	ssize_t r;
 
 	ASSERT_EQ(0, sem_init(&sem0, 0, 0)) << strerror(errno);
 	ASSERT_EQ(0, sem_init(&sem1, 0, 0)) << strerror(errno);
 	self = pthread_self();
 
 	EXPECT_LOOKUP(1, RELDIRPATH0).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	expect_lookup(RELPATH1, ino1);
 	expect_open(ino1, 0, 1);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_MKDIR);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnImmediate([&](auto in __unused, auto out) {
 		/* Let the next write proceed */
 		sem_post(&sem1);
 		/* Pause the daemon thread so it won't read the next op */
 		sem_wait(&sem0);
 
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.create.entry.attr.mode = S_IFDIR | MODE;
 		out->body.create.entry.nodeid = ino0;
 	})));
 
 	fd1 = open(FULLPATH1, O_WRONLY);
 	ASSERT_LE(0, fd1) << strerror(errno);
 
 	/* Use a separate thread for the first write */
 	ASSERT_EQ(0, pthread_create(&th0, NULL, mkdir0, NULL))
 		<< strerror(errno);
 
 	sem_wait(&sem1);	/* Sequence the two operations */
 
 	setup_interruptor(self, true);
 
 	r = extattr_set_fd(fd1, ns, "foo", (void*)value, value_len);
 	EXPECT_EQ(EINTR, errno);
 
 	/* Unstick the daemon */
 	ASSERT_EQ(0, sem_post(&sem0)) << strerror(errno);
 
 	/* Wait awhile to make sure the signal generates no FUSE_INTERRUPT */
-	usleep(250'000);
+	nap();
 
 	pthread_join(th0, &thr0_value);
 	EXPECT_EQ(0, (intptr_t)thr0_value);
 	sem_destroy(&sem1);
 	sem_destroy(&sem0);
 }
 
 /* 
  * A syscall that gets interrupted while blocking on FUSE I/O should send a
  * FUSE_INTERRUPT command to the fuse filesystem, which should then send EINTR
  * in response to the _original_ operation.  The kernel should ultimately
  * return EINTR to userspace
  */
 /* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=236530 */
 TEST_F(Interrupt, in_progress)
 {
 	pthread_t self;
 	uint64_t mkdir_unique;
 
 	self = pthread_self();
 
 	EXPECT_LOOKUP(1, RELDIRPATH0).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	expect_mkdir(&mkdir_unique);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([&](auto in) {
 			return (in->header.opcode == FUSE_INTERRUPT &&
 				in->body.interrupt.unique == mkdir_unique);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke([&](auto in __unused, auto &out) {
 		auto out0 = new mockfs_buf_out;
 		out0->header.error = -EINTR;
 		out0->header.unique = mkdir_unique;
 		out0->header.len = sizeof(out0->header);
 		out.push_back(out0);
 	}));
 
 	setup_interruptor(self);
 	ASSERT_EQ(-1, mkdir(FULLDIRPATH0, MODE));
 	EXPECT_EQ(EINTR, errno);
 }
 
 /* Reads should also be interruptible */
 TEST_F(Interrupt, in_progress_read)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const size_t bufsize = 80;
 	char buf[bufsize];
 	uint64_t ino = 42;
 	int fd;
 	pthread_t self;
 	uint64_t read_unique;
 
 	self = pthread_self();
 
 	expect_lookup(RELPATH, ino);
 	expect_open(ino, 0, 1);
 	expect_read(ino, &read_unique);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([&](auto in) {
 			return (in->header.opcode == FUSE_INTERRUPT &&
 				in->body.interrupt.unique == read_unique);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke([&](auto in __unused, auto &out) {
 		auto out0 = new mockfs_buf_out;
 		out0->header.error = -EINTR;
 		out0->header.unique = read_unique;
 		out0->header.len = sizeof(out0->header);
 		out.push_back(out0);
 	}));
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	setup_interruptor(self);
 	ASSERT_EQ(-1, read(fd, buf, bufsize));
 	EXPECT_EQ(EINTR, errno);
 }
 
 /* FUSE_INTERRUPT operations should take priority over other pending ops */
 TEST_F(Interrupt, priority)
 {
 	Sequence seq;
 	uint64_t ino1 = 43;
 	uint64_t mkdir_unique;
 	pthread_t self, th0;
 	sem_t sem0, sem1;
 
 	ASSERT_EQ(0, sem_init(&sem0, 0, 0)) << strerror(errno);
 	ASSERT_EQ(0, sem_init(&sem1, 0, 0)) << strerror(errno);
 	self = pthread_self();
 
 	EXPECT_LOOKUP(1, RELDIRPATH0).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	EXPECT_LOOKUP(1, RELDIRPATH1).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_MKDIR);
 		}, Eq(true)),
 		_)
 	).InSequence(seq)
 	.WillOnce(Invoke(ReturnImmediate([&](auto in, auto out) {
 		mkdir_unique = in->header.unique;
 
 		/* Let the next mkdir proceed */
 		sem_post(&sem1);
 
 		/* Pause the daemon thread so it won't read the next op */
 		sem_wait(&sem0);
 
 		/* Finally, interrupt the original op */
 		out->header.error = -EINTR;
 		out->header.unique = mkdir_unique;
 		out->header.len = sizeof(out->header);
 	})));
 	/* 
 	 * FUSE_INTERRUPT should be received before the second FUSE_MKDIR,
 	 * even though it was generated later
 	 */
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([&](auto in) {
 			return (in->header.opcode == FUSE_INTERRUPT &&
 				in->body.interrupt.unique == mkdir_unique);
 		}, Eq(true)),
 		_)
 	).InSequence(seq)
 	.WillOnce(Invoke(ReturnErrno(EAGAIN)));
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([&](auto in) {
 			return (in->header.opcode == FUSE_MKDIR);
 		}, Eq(true)),
 		_)
 	).InSequence(seq)
 	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.create.entry.attr.mode = S_IFDIR | MODE;
 		out->body.create.entry.nodeid = ino1;
 	})));
 
 	/* Use a separate thread for the first mkdir */
 	ASSERT_EQ(0, pthread_create(&th0, NULL, mkdir0, NULL))
 		<< strerror(errno);
 
 	signaled_semaphore = &sem0;
 
 	sem_wait(&sem1);	/* Sequence the two mkdirs */
 	setup_interruptor(th0, true);
 	ASSERT_EQ(0, mkdir(FULLDIRPATH1, MODE)) << strerror(errno);
 
 	/* Wait awhile to make sure the signal generates no FUSE_INTERRUPT */
-	usleep(250'000);
+	nap();
 
 	pthread_join(th0, NULL);
 	sem_destroy(&sem1);
 	sem_destroy(&sem0);
 }
 
 /*
  * If the FUSE filesystem receives the FUSE_INTERRUPT operation before
  * processing the original, then it should wait for "some timeout" for the
  * original operation to arrive.  If not, it should send EAGAIN to the
  * INTERRUPT operation, and the kernel should requeue the INTERRUPT.
  *
  * In this test, we'll pretend that the INTERRUPT arrives too soon, gets
  * EAGAINed, then the kernel requeues it, and the second time around it
  * successfully interrupts the original
  */
 /* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=236530 */
 TEST_F(Interrupt, too_soon)
 {
 	Sequence seq;
 	pthread_t self;
 	uint64_t mkdir_unique;
 
 	self = pthread_self();
 
 	EXPECT_LOOKUP(1, RELDIRPATH0).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	expect_mkdir(&mkdir_unique);
 
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([&](auto in) {
 			return (in->header.opcode == FUSE_INTERRUPT &&
 				in->body.interrupt.unique == mkdir_unique);
 		}, Eq(true)),
 		_)
 	).InSequence(seq)
 	.WillOnce(Invoke(ReturnErrno(EAGAIN)));
 
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([&](auto in) {
 			return (in->header.opcode == FUSE_INTERRUPT &&
 				in->body.interrupt.unique == mkdir_unique);
 		}, Eq(true)),
 		_)
 	).InSequence(seq)
 	.WillOnce(Invoke([&](auto in __unused, auto &out __unused) {
 		auto out0 = new mockfs_buf_out;
 		out0->header.error = -EINTR;
 		out0->header.unique = mkdir_unique;
 		out0->header.len = sizeof(out0->header);
 		out.push_back(out0);
 	}));
 
 	setup_interruptor(self);
 	ASSERT_EQ(-1, mkdir(FULLDIRPATH0, MODE));
 	EXPECT_EQ(EINTR, errno);
 }
 
 
 // TODO: add a test where write returns EWOULDBLOCK
Index: projects/fuse2/tests/sys/fs/fusefs/lookup.cc
===================================================================
--- projects/fuse2/tests/sys/fs/fusefs/lookup.cc	(revision 347402)
+++ projects/fuse2/tests/sys/fs/fusefs/lookup.cc	(revision 347403)
@@ -1,371 +1,357 @@
 /*-
  * 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.
  */
 
 extern "C" {
 #include <unistd.h>
 }
 
 #include "mockfs.hh"
 #include "utils.hh"
 
 using namespace testing;
 
 class Lookup: public FuseTest {};
 
 /*
  * If lookup returns a non-zero cache timeout, then subsequent VOP_GETATTRs
  * should use the cached attributes, rather than query the daemon
  */
 TEST_F(Lookup, attr_cache)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const uint64_t ino = 42;
 	const uint64_t generation = 13;
 	struct stat sb;
 
 	EXPECT_LOOKUP(1, RELPATH)
 	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.entry.nodeid = ino;
 		out->body.entry.attr_valid = UINT64_MAX;
 		out->body.entry.attr.ino = ino;	// Must match nodeid
 		out->body.entry.attr.mode = S_IFREG | 0644;
 		out->body.entry.attr.size = 1;
 		out->body.entry.attr.blocks = 2;
 		out->body.entry.attr.atime = 3;
 		out->body.entry.attr.mtime = 4;
 		out->body.entry.attr.ctime = 5;
 		out->body.entry.attr.atimensec = 6;
 		out->body.entry.attr.mtimensec = 7;
 		out->body.entry.attr.ctimensec = 8;
 		out->body.entry.attr.nlink = 9;
 		out->body.entry.attr.uid = 10;
 		out->body.entry.attr.gid = 11;
 		out->body.entry.attr.rdev = 12;
 		out->body.entry.generation = generation;
 	})));
 	/* stat(2) issues a VOP_LOOKUP followed by a VOP_GETATTR */
 	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);
 
 	// fuse(4) does not _yet_ support inode generations
 	//EXPECT_EQ(generation, sb.st_gen);
 
 	//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
 }
 
 /*
  * If lookup returns a finite but non-zero cache timeout, then we should discard
  * the cached attributes and requery the daemon.
  */
 TEST_F(Lookup, attr_cache_timeout)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const uint64_t ino = 42;
 	struct stat sb;
-	/* 
-	 * The timeout should be longer than the longest plausible time the
-	 * daemon would take to complete a write(2) to /dev/fuse, but no longer.
-	 */
-	long timeout_ns = 250'000'000;
 
 	EXPECT_LOOKUP(1, RELPATH)
 	.Times(2)
 	.WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.entry.nodeid = ino;
-		out->body.entry.attr_valid_nsec = timeout_ns;
+		out->body.entry.attr_valid_nsec = NAP_NS / 2;
 		out->body.entry.attr.ino = ino;	// Must match nodeid
 		out->body.entry.attr.mode = S_IFREG | 0644;
 	})));
 
 	/* access(2) will issue a VOP_LOOKUP and fill the attr cache */
 	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
 	/* Next access(2) will use the cached attributes */
-	usleep(2 * timeout_ns / 1000);
+	nap();
 	/* The cache has timed out; VOP_GETATTR should query the daemon*/
 	ASSERT_EQ(0, stat(FULLPATH, &sb)) << strerror(errno);
 }
 
 TEST_F(Lookup, dot)
 {
 	const char FULLPATH[] = "mountpoint/some_dir/.";
 	const char RELDIRPATH[] = "some_dir";
 	uint64_t ino = 42;
 
 	EXPECT_LOOKUP(1, RELDIRPATH)
 	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.entry.attr.mode = S_IFDIR | 0755;
 		out->body.entry.nodeid = ino;
 		out->body.entry.attr_valid = UINT64_MAX;
 		out->body.entry.entry_valid = UINT64_MAX;
 	})));
 
 	/*
 	 * access(2) is one of the few syscalls that will not (always) follow
 	 * up a successful VOP_LOOKUP with another VOP.
 	 */
 	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
 }
 
 TEST_F(Lookup, dotdot)
 {
 	const char FULLPATH[] = "mountpoint/some_dir/..";
 	const char RELDIRPATH[] = "some_dir";
 
 	EXPECT_LOOKUP(1, RELDIRPATH)
 	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.entry.attr.mode = S_IFDIR | 0755;
 		out->body.entry.nodeid = 14;
 		out->body.entry.attr_valid = UINT64_MAX;
 		out->body.entry.entry_valid = UINT64_MAX;
 	})));
 
 	/*
 	 * access(2) is one of the few syscalls that will not (always) follow
 	 * up a successful VOP_LOOKUP with another VOP.
 	 */
 	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
 }
 
 TEST_F(Lookup, enoent)
 {
 	const char FULLPATH[] = "mountpoint/does_not_exist";
 	const char RELPATH[] = "does_not_exist";
 
 	EXPECT_LOOKUP(1, RELPATH).WillOnce(Invoke(ReturnErrno(ENOENT)));
 	EXPECT_NE(0, access(FULLPATH, F_OK));
 	EXPECT_EQ(ENOENT, errno);
 }
 
 TEST_F(Lookup, enotdir)
 {
 	const char FULLPATH[] = "mountpoint/not_a_dir/some_file.txt";
 	const char RELPATH[] = "not_a_dir";
 
 	EXPECT_LOOKUP(1, RELPATH)
 	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.entry.entry_valid = UINT64_MAX;
 		out->body.entry.attr.mode = S_IFREG | 0644;
 		out->body.entry.nodeid = 42;
 	})));
 
 	ASSERT_EQ(-1, access(FULLPATH, F_OK));
 	ASSERT_EQ(ENOTDIR, errno);
 }
 
 /*
  * If lookup returns a non-zero entry timeout, then subsequent VOP_LOOKUPs
  * should use the cached inode rather than requery the daemon
  */
 TEST_F(Lookup, entry_cache)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 
 	EXPECT_LOOKUP(1, RELPATH)
 	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.entry.entry_valid = UINT64_MAX;
 		out->body.entry.attr.mode = S_IFREG | 0644;
 		out->body.entry.nodeid = 14;
 	})));
 	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
 	/* The second access(2) should use the cache */
 	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
 }
 
 /* 
  * If the daemon returns an error of 0 and an inode of 0, that's a flag for
  * "ENOENT and cache it" with the given entry_timeout
  */
 TEST_F(Lookup, entry_cache_negative)
 {
 	struct timespec entry_valid = {.tv_sec = TIME_T_MAX, .tv_nsec = 0};
 
 	EXPECT_LOOKUP(1, "does_not_exist").Times(1)
 	.WillOnce(Invoke(ReturnNegativeCache(&entry_valid)));
 
 	EXPECT_NE(0, access("mountpoint/does_not_exist", F_OK));
 	EXPECT_EQ(ENOENT, errno);
 	EXPECT_NE(0, access("mountpoint/does_not_exist", F_OK));
 	EXPECT_EQ(ENOENT, errno);
 }
 
 /* Negative entry caches should timeout, too */
 TEST_F(Lookup, entry_cache_negative_timeout)
 {
 	const char *RELPATH = "does_not_exist";
 	const char *FULLPATH = "mountpoint/does_not_exist";
-	/* 
-	 * The timeout should be longer than the longest plausible time the
-	 * daemon would take to complete a write(2) to /dev/fuse, but no longer.
-	 */
-	struct timespec entry_valid = {.tv_sec = 0, .tv_nsec = 250'000'000};
+	struct timespec entry_valid = {.tv_sec = 0, .tv_nsec = NAP_NS / 2};
 
 	EXPECT_LOOKUP(1, RELPATH).Times(2)
 	.WillRepeatedly(Invoke(ReturnNegativeCache(&entry_valid)));
 
 	EXPECT_NE(0, access(FULLPATH, F_OK));
 	EXPECT_EQ(ENOENT, errno);
 
-	usleep(2 * entry_valid.tv_nsec / 1000);
+	nap();
 
 	/* The cache has timed out; VOP_LOOKUP should requery the daemon*/
 	EXPECT_NE(0, access(FULLPATH, F_OK));
 	EXPECT_EQ(ENOENT, errno);
 }
 
 /*
  * If lookup returns a finite but non-zero entry cache timeout, then we should
  * discard the cached inode and requery the daemon
  */
 TEST_F(Lookup, entry_cache_timeout)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
-	/* 
-	 * The timeout should be longer than the longest plausible time the
-	 * daemon would take to complete a write(2) to /dev/fuse, but no longer.
-	 */
-	long timeout_ns = 250'000'000;
 
 	EXPECT_LOOKUP(1, RELPATH)
 	.Times(2)
 	.WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		SET_OUT_HEADER_LEN(out, entry);
-		out->body.entry.entry_valid_nsec = timeout_ns;
+		out->body.entry.entry_valid_nsec = NAP_NS / 2;
 		out->body.entry.attr.mode = S_IFREG | 0644;
 		out->body.entry.nodeid = 14;
 	})));
 
 	/* access(2) will issue a VOP_LOOKUP and fill the entry cache */
 	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
 	/* Next access(2) will use the cached entry */
 	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
-	usleep(2 * timeout_ns / 1000);
+	nap();
 	/* The cache has timed out; VOP_LOOKUP should requery the daemon*/
 	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
 }
 
 // TODO: export_support
 // After upgrading the protocol to 7.10, check that the kernel will only
 // attempt to lookup "." and ".." if the filesystem sets FUSE_EXPORT_SUPPORT in
 // the init flags.  If not, then all lookups for those entries will return
 // ESTALE.
 
 TEST_F(Lookup, ok)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 
 	EXPECT_LOOKUP(1, RELPATH)
 	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.entry.attr.mode = S_IFREG | 0644;
 		out->body.entry.nodeid = 14;
 	})));
 	/*
 	 * access(2) is one of the few syscalls that will not (always) follow
 	 * up a successful VOP_LOOKUP with another VOP.
 	 */
 	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
 }
 
 // Lookup in a subdirectory of the fuse mount
 TEST_F(Lookup, subdir)
 {
 	const char FULLPATH[] = "mountpoint/some_dir/some_file.txt";
 	const char DIRPATH[] = "some_dir";
 	const char RELPATH[] = "some_file.txt";
 	uint64_t dir_ino = 2;
 	uint64_t file_ino = 3;
 
 	EXPECT_LOOKUP(1, DIRPATH)
 	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.entry.attr.mode = S_IFDIR | 0755;
 		out->body.entry.nodeid = dir_ino;
 	})));
 	EXPECT_LOOKUP(dir_ino, RELPATH)
 	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		SET_OUT_HEADER_LEN(out, entry);
 		out->body.entry.attr.mode = S_IFREG | 0644;
 		out->body.entry.nodeid = file_ino;
 	})));
 	/*
 	 * access(2) is one of the few syscalls that will not (always) follow
 	 * up a successful VOP_LOOKUP with another VOP.
 	 */
 	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
 }
 
 /* 
  * The server returns two different vtypes for the same nodeid.  This is a bad
  * server!  But we shouldn't crash.
  */
 TEST_F(Lookup, vtype_conflict)
 {
 	const char FIRSTFULLPATH[] = "mountpoint/foo";
 	const char SECONDFULLPATH[] = "mountpoint/bar";
 	const char FIRSTRELPATH[] = "foo";
 	const char SECONDRELPATH[] = "bar";
 	uint64_t ino = 42;
 
 	expect_lookup(FIRSTRELPATH, ino, S_IFREG | 0644, 0, 1, UINT64_MAX);
 	expect_lookup(SECONDRELPATH, ino, S_IFDIR | 0755, 0, 1, UINT64_MAX);
 
 	ASSERT_EQ(0, access(FIRSTFULLPATH, F_OK)) << strerror(errno);
 	ASSERT_EQ(-1, access(SECONDFULLPATH, F_OK));
 	ASSERT_EQ(EAGAIN, errno);
 }
Index: projects/fuse2/tests/sys/fs/fusefs/read.cc
===================================================================
--- projects/fuse2/tests/sys/fs/fusefs/read.cc	(revision 347402)
+++ projects/fuse2/tests/sys/fs/fusefs/read.cc	(revision 347403)
@@ -1,738 +1,738 @@
 /*-
  * 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.
  */
 
 extern "C" {
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <sys/sysctl.h>
 #include <sys/uio.h>
 
 #include <aio.h>
 #include <fcntl.h>
 #include <unistd.h>
 }
 
 #include "mockfs.hh"
 #include "utils.hh"
 
 using namespace testing;
 
 class Read: public FuseTest {
 
 public:
 void expect_lookup(const char *relpath, uint64_t ino, uint64_t size)
 {
 	FuseTest::expect_lookup(relpath, ino, S_IFREG | 0644, size, 1);
 }
 };
 
 class AioRead: public Read {
 public:
 virtual void SetUp() {
 	const char *node = "vfs.aio.enable_unsafe";
 	int val = 0;
 	size_t size = sizeof(val);
 
 	FuseTest::SetUp();
 
 	ASSERT_EQ(0, sysctlbyname(node, &val, &size, NULL, 0))
 		<< strerror(errno);
 	if (!val)
 		GTEST_SKIP() <<
 			"vfs.aio.enable_unsafe must be set for this test";
 }
 };
 
 class AsyncRead: public AioRead {
 	virtual void SetUp() {
 		m_init_flags = FUSE_ASYNC_READ;
 		AioRead::SetUp();
 	}
 };
 
 class ReadCacheable: public Read {
 public:
 virtual void SetUp() {
 	const char *node = "vfs.fusefs.data_cache_mode";
 	int val = 0;
 	size_t size = sizeof(val);
 
 	FuseTest::SetUp();
 
 	ASSERT_EQ(0, sysctlbyname(node, &val, &size, NULL, 0))
 		<< strerror(errno);
 	if (val == 0)
 		GTEST_SKIP() <<
 			"fusefs data caching must be enabled for this test";
 }
 };
 
 class ReadAhead: public ReadCacheable, public WithParamInterface<uint32_t> {
 	virtual void SetUp() {
 		m_maxreadahead = GetParam();
 		Read::SetUp();
 	}
 };
 
 /* AIO reads need to set the header's pid field correctly */
 /* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=236379 */
 TEST_F(AioRead, aio_read)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefgh";
 	uint64_t ino = 42;
 	int fd;
 	ssize_t bufsize = strlen(CONTENTS);
 	char buf[bufsize];
 	struct aiocb iocb, *piocb;
 
 	expect_lookup(RELPATH, ino, bufsize);
 	expect_open(ino, 0, 1);
 	expect_read(ino, 0, bufsize, bufsize, CONTENTS);
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	iocb.aio_nbytes = bufsize;
 	iocb.aio_fildes = fd;
 	iocb.aio_buf = buf;
 	iocb.aio_offset = 0;
 	iocb.aio_sigevent.sigev_notify = SIGEV_NONE;
 	ASSERT_EQ(0, aio_read(&iocb)) << strerror(errno);
 	ASSERT_EQ(bufsize, aio_waitcomplete(&piocb, NULL)) << strerror(errno);
 	ASSERT_EQ(0, memcmp(buf, CONTENTS, bufsize));
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 /* 
  * Without the FUSE_ASYNC_READ mount option, fuse(4) should ensure that there
  * is at most one outstanding read operation per file handle
  */
 TEST_F(AioRead, async_read_disabled)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	uint64_t ino = 42;
 	int fd;
 	ssize_t bufsize = 50;
 	char buf0[bufsize], buf1[bufsize];
 	off_t off0 = 0;
 	off_t off1 = 4096;
 	struct aiocb iocb0, iocb1;
 
 	expect_lookup(RELPATH, ino, bufsize);
 	expect_open(ino, 0, 1);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_READ &&
 				in->header.nodeid == ino &&
 				in->body.read.fh == FH &&
 				in->body.read.offset == (uint64_t)off0 &&
 				in->body.read.size == bufsize);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke([](auto in __unused, auto &out __unused) {
 		/* Filesystem is slow to respond */
 	}));
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_READ &&
 				in->header.nodeid == ino &&
 				in->body.read.fh == FH &&
 				in->body.read.offset == (uint64_t)off1 &&
 				in->body.read.size == bufsize);
 		}, Eq(true)),
 		_)
 	).Times(0);
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	/* 
 	 * Submit two AIO read requests, and respond to neither.  If the
 	 * filesystem ever gets the second read request, then we failed to
 	 * limit outstanding reads.
 	 */
 	iocb0.aio_nbytes = bufsize;
 	iocb0.aio_fildes = fd;
 	iocb0.aio_buf = buf0;
 	iocb0.aio_offset = off0;
 	iocb0.aio_sigevent.sigev_notify = SIGEV_NONE;
 	ASSERT_EQ(0, aio_read(&iocb0)) << strerror(errno);
 
 	iocb1.aio_nbytes = bufsize;
 	iocb1.aio_fildes = fd;
 	iocb1.aio_buf = buf1;
 	iocb1.aio_offset = off1;
 	iocb1.aio_sigevent.sigev_notify = SIGEV_NONE;
 	ASSERT_EQ(0, aio_read(&iocb1)) << strerror(errno);
 
 	/* 
 	 * Sleep for awhile to make sure the kernel has had a chance to issue
 	 * the second read, even though the first has not yet returned
 	 */
-	usleep(250'000);
+	nap();
 	
 	/* Deliberately leak iocbs */
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 /* 
  * With the FUSE_ASYNC_READ mount option, fuse(4) may issue multiple
  * simultaneous read requests on the same file handle.
  */
 /* 
  * Disabled because we don't yet implement FUSE_ASYNC_READ.  No bugzilla
  * entry, because that's a feature request, not a bug.
  */
 TEST_F(AsyncRead, DISABLED_async_read)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	uint64_t ino = 42;
 	int fd;
 	ssize_t bufsize = 50;
 	char buf0[bufsize], buf1[bufsize];
 	off_t off0 = 0;
 	off_t off1 = 4096;
 	struct aiocb iocb0, iocb1;
 
 	expect_lookup(RELPATH, ino, bufsize);
 	expect_open(ino, 0, 1);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_READ &&
 				in->header.nodeid == ino &&
 				in->body.read.fh == FH &&
 				in->body.read.offset == (uint64_t)off0 &&
 				in->body.read.size == bufsize);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke([](auto in __unused, auto &out __unused) {
 		/* Filesystem is slow to respond */
 	}));
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_READ &&
 				in->header.nodeid == ino &&
 				in->body.read.fh == FH &&
 				in->body.read.offset == (uint64_t)off1 &&
 				in->body.read.size == bufsize);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke([](auto in __unused, auto &out __unused) {
 		/* Filesystem is slow to respond */
 	}));
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	/* 
 	 * Submit two AIO read requests, but respond to neither.  Ensure that
 	 * we received both.
 	 */
 	iocb0.aio_nbytes = bufsize;
 	iocb0.aio_fildes = fd;
 	iocb0.aio_buf = buf0;
 	iocb0.aio_offset = off0;
 	iocb0.aio_sigevent.sigev_notify = SIGEV_NONE;
 	ASSERT_EQ(0, aio_read(&iocb0)) << strerror(errno);
 
 	iocb1.aio_nbytes = bufsize;
 	iocb1.aio_fildes = fd;
 	iocb1.aio_buf = buf1;
 	iocb1.aio_offset = off1;
 	iocb1.aio_sigevent.sigev_notify = SIGEV_NONE;
 	ASSERT_EQ(0, aio_read(&iocb1)) << strerror(errno);
 
 	/* 
 	 * Sleep for awhile to make sure the kernel has had a chance to issue
 	 * both reads.
 	 */
-	usleep(250'000);
+	nap();
 	
 	/* Deliberately leak iocbs */
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 /* 0-length reads shouldn't cause any confusion */
 TEST_F(Read, direct_io_read_nothing)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	uint64_t ino = 42;
 	int fd;
 	uint64_t offset = 100;
 	char buf[80];
 
 	expect_lookup(RELPATH, ino, offset + 1000);
 	expect_open(ino, FOPEN_DIRECT_IO, 1);
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	ASSERT_EQ(0, pread(fd, buf, 0, offset)) << strerror(errno);
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 /* 
  * With direct_io, reads should not fill the cache.  They should go straight to
  * the daemon
  */
 TEST_F(Read, direct_io_pread)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefgh";
 	uint64_t ino = 42;
 	int fd;
 	uint64_t offset = 100;
 	ssize_t bufsize = strlen(CONTENTS);
 	char buf[bufsize];
 
 	expect_lookup(RELPATH, ino, offset + bufsize);
 	expect_open(ino, FOPEN_DIRECT_IO, 1);
 	expect_read(ino, offset, bufsize, bufsize, CONTENTS);
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	ASSERT_EQ(bufsize, pread(fd, buf, bufsize, offset)) << strerror(errno);
 	ASSERT_EQ(0, memcmp(buf, CONTENTS, bufsize));
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 /* 
  * With direct_io, filesystems are allowed to return less data than is
  * requested.  fuse(4) should return a short read to userland.
  */
 TEST_F(Read, direct_io_short_read)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefghijklmnop";
 	uint64_t ino = 42;
 	int fd;
 	uint64_t offset = 100;
 	ssize_t bufsize = strlen(CONTENTS);
 	ssize_t halfbufsize = bufsize / 2;
 	char buf[bufsize];
 
 	expect_lookup(RELPATH, ino, offset + bufsize);
 	expect_open(ino, FOPEN_DIRECT_IO, 1);
 	expect_read(ino, offset, bufsize, halfbufsize, CONTENTS);
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	ASSERT_EQ(halfbufsize, pread(fd, buf, bufsize, offset))
 		<< strerror(errno);
 	ASSERT_EQ(0, memcmp(buf, CONTENTS, halfbufsize));
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 TEST_F(Read, eio)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefgh";
 	uint64_t ino = 42;
 	int fd;
 	ssize_t bufsize = strlen(CONTENTS);
 	char buf[bufsize];
 
 	expect_lookup(RELPATH, ino, bufsize);
 	expect_open(ino, 0, 1);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_READ);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnErrno(EIO)));
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	ASSERT_EQ(-1, read(fd, buf, bufsize)) << strerror(errno);
 	ASSERT_EQ(EIO, errno);
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 /* 
  * With the keep_cache option, the kernel may keep its read cache across
  * multiple open(2)s.
  */
 TEST_F(ReadCacheable, keep_cache)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefgh";
 	uint64_t ino = 42;
 	int fd0, fd1;
 	ssize_t bufsize = strlen(CONTENTS);
 	char buf[bufsize];
 
 	FuseTest::expect_lookup(RELPATH, ino, S_IFREG | 0644, bufsize, 2);
 	expect_open(ino, FOPEN_KEEP_CACHE, 2);
 	expect_read(ino, 0, bufsize, bufsize, CONTENTS);
 
 	fd0 = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd0) << strerror(errno);
 	ASSERT_EQ(bufsize, read(fd0, buf, bufsize)) << strerror(errno);
 
 	fd1 = open(FULLPATH, O_RDWR);
 	ASSERT_LE(0, fd1) << strerror(errno);
 
 	/*
 	 * This read should be serviced by cache, even though it's on the other
 	 * file descriptor
 	 */
 	ASSERT_EQ(bufsize, read(fd1, buf, bufsize)) << strerror(errno);
 
 	/* Deliberately leak fd0 and fd1. */
 }
 
 /* 
  * Without the keep_cache option, the kernel should drop its read caches on
  * every open
  */
 TEST_F(Read, keep_cache_disabled)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefgh";
 	uint64_t ino = 42;
 	int fd0, fd1;
 	ssize_t bufsize = strlen(CONTENTS);
 	char buf[bufsize];
 
 	FuseTest::expect_lookup(RELPATH, ino, S_IFREG | 0644, bufsize, 2);
 	expect_open(ino, 0, 2);
 	expect_read(ino, 0, bufsize, bufsize, CONTENTS);
 
 	fd0 = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd0) << strerror(errno);
 	ASSERT_EQ(bufsize, read(fd0, buf, bufsize)) << strerror(errno);
 
 	fd1 = open(FULLPATH, O_RDWR);
 	ASSERT_LE(0, fd1) << strerror(errno);
 
 	/*
 	 * This read should not be serviced by cache, even though it's on the
 	 * original file descriptor
 	 */
 	expect_read(ino, 0, bufsize, bufsize, CONTENTS);
 	ASSERT_EQ(0, lseek(fd0, 0, SEEK_SET)) << strerror(errno);
 	ASSERT_EQ(bufsize, read(fd0, buf, bufsize)) << strerror(errno);
 
 	/* Deliberately leak fd0 and fd1. */
 }
 
 TEST_F(ReadCacheable, mmap)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefgh";
 	uint64_t ino = 42;
 	int fd;
 	ssize_t len;
 	ssize_t bufsize = strlen(CONTENTS);
 	void *p;
 	//char buf[bufsize];
 
 	len = getpagesize();
 
 	expect_lookup(RELPATH, ino, bufsize);
 	expect_open(ino, 0, 1);
 	/* mmap may legitimately try to read more data than is available */
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_READ &&
 				in->header.nodeid == ino &&
 				in->body.read.fh == Read::FH &&
 				in->body.read.offset == 0 &&
 				in->body.read.size >= bufsize);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		out->header.len = sizeof(struct fuse_out_header) + bufsize;
 		memmove(out->body.bytes, CONTENTS, bufsize);
 	})));
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	p = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, 0);
 	ASSERT_NE(MAP_FAILED, p) << strerror(errno);
 
 	ASSERT_EQ(0, memcmp(p, CONTENTS, bufsize));
 
 	ASSERT_EQ(0, munmap(p, len)) << strerror(errno);
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 /*
  * Just as when FOPEN_DIRECT_IO is used, reads with O_DIRECT should bypass
  * cache and to straight to the daemon
  */
 TEST_F(Read, o_direct)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefgh";
 	uint64_t ino = 42;
 	int fd;
 	ssize_t bufsize = strlen(CONTENTS);
 	char buf[bufsize];
 
 	expect_lookup(RELPATH, ino, bufsize);
 	expect_open(ino, 0, 1);
 	expect_read(ino, 0, bufsize, bufsize, CONTENTS);
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	// Fill the cache
 	ASSERT_EQ(bufsize, read(fd, buf, bufsize)) << strerror(errno);
 	ASSERT_EQ(0, memcmp(buf, CONTENTS, bufsize));
 
 	// Reads with o_direct should bypass the cache
 	expect_read(ino, 0, bufsize, bufsize, CONTENTS);
 	ASSERT_EQ(0, fcntl(fd, F_SETFL, O_DIRECT)) << strerror(errno);
 	ASSERT_EQ(0, lseek(fd, 0, SEEK_SET)) << strerror(errno);
 	ASSERT_EQ(bufsize, read(fd, buf, bufsize)) << strerror(errno);
 	ASSERT_EQ(0, memcmp(buf, CONTENTS, bufsize));
 	
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 TEST_F(Read, pread)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefgh";
 	uint64_t ino = 42;
 	int fd;
 	/* 
 	 * Set offset to a maxbcachebuf boundary so we'll be sure what offset
 	 * to read from.  Without this, the read might start at a lower offset.
 	 */
 	uint64_t offset = m_maxbcachebuf;
 	ssize_t bufsize = strlen(CONTENTS);
 	char buf[bufsize];
 
 	expect_lookup(RELPATH, ino, offset + bufsize);
 	expect_open(ino, 0, 1);
 	expect_read(ino, offset, bufsize, bufsize, CONTENTS);
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	ASSERT_EQ(bufsize, pread(fd, buf, bufsize, offset)) << strerror(errno);
 	ASSERT_EQ(0, memcmp(buf, CONTENTS, bufsize));
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 TEST_F(Read, read)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefgh";
 	uint64_t ino = 42;
 	int fd;
 	ssize_t bufsize = strlen(CONTENTS);
 	char buf[bufsize];
 
 	expect_lookup(RELPATH, ino, bufsize);
 	expect_open(ino, 0, 1);
 	expect_read(ino, 0, bufsize, bufsize, CONTENTS);
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	ASSERT_EQ(bufsize, read(fd, buf, bufsize)) << strerror(errno);
 	ASSERT_EQ(0, memcmp(buf, CONTENTS, bufsize));
 
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 /* If the filesystem allows it, the kernel should try to readahead */
 TEST_F(ReadCacheable, default_readahead)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS0 = "abcdefghijklmnop";
 	uint64_t ino = 42;
 	int fd;
 	ssize_t bufsize = 8;
 	/* hard-coded in fuse_internal.c */
 	size_t default_maxreadahead = 65536;
 	ssize_t filesize = default_maxreadahead * 2;
 	char *contents;
 	char buf[bufsize];
 	const char *contents1 = CONTENTS0 + bufsize;
 
 	contents = (char*)calloc(1, filesize);
 	ASSERT_NE(NULL, contents);
 	memmove(contents, CONTENTS0, strlen(CONTENTS0));
 
 	expect_lookup(RELPATH, ino, filesize);
 	expect_open(ino, 0, 1);
 	expect_read(ino, 0, default_maxreadahead, default_maxreadahead,
 		contents);
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	ASSERT_EQ(bufsize, read(fd, buf, bufsize)) << strerror(errno);
 	ASSERT_EQ(0, memcmp(buf, CONTENTS0, bufsize));
 
 	/* A subsequent read should be serviced by cache */
 	ASSERT_EQ(bufsize, read(fd, buf, bufsize)) << strerror(errno);
 	ASSERT_EQ(0, memcmp(buf, contents1, bufsize));
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 /* Reading with sendfile should work (though it obviously won't be 0-copy) */
 TEST_F(ReadCacheable, sendfile)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefgh";
 	uint64_t ino = 42;
 	int fd;
 	ssize_t bufsize = strlen(CONTENTS);
 	char buf[bufsize];
 	int sp[2];
 	off_t sbytes;
 
 	expect_lookup(RELPATH, ino, bufsize);
 	expect_open(ino, 0, 1);
 	/* Like mmap, sendfile may request more data than is available */
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_READ &&
 				in->header.nodeid == ino &&
 				in->body.read.fh == Read::FH &&
 				in->body.read.offset == 0 &&
 				in->body.read.size >= bufsize);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) {
 		out->header.len = sizeof(struct fuse_out_header) + bufsize;
 		memmove(out->body.bytes, CONTENTS, bufsize);
 	})));
 
 	ASSERT_EQ(0, socketpair(PF_LOCAL, SOCK_STREAM, 0, sp))
 		<< strerror(errno);
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	ASSERT_EQ(0, sendfile(fd, sp[1], 0, bufsize, NULL, &sbytes, 0))
 		<< strerror(errno);
 	ASSERT_EQ(bufsize, read(sp[0], buf, bufsize)) << strerror(errno);
 	ASSERT_EQ(0, memcmp(buf, CONTENTS, bufsize));
 
 	close(sp[1]);
 	close(sp[0]);
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 /* sendfile should fail gracefully if fuse declines the read */
 /* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=236466 */
 TEST_F(ReadCacheable, DISABLED_sendfile_eio)
 {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS = "abcdefgh";
 	uint64_t ino = 42;
 	int fd;
 	ssize_t bufsize = strlen(CONTENTS);
 	int sp[2];
 	off_t sbytes;
 
 	expect_lookup(RELPATH, ino, bufsize);
 	expect_open(ino, 0, 1);
 	EXPECT_CALL(*m_mock, process(
 		ResultOf([=](auto in) {
 			return (in->header.opcode == FUSE_READ);
 		}, Eq(true)),
 		_)
 	).WillOnce(Invoke(ReturnErrno(EIO)));
 
 	ASSERT_EQ(0, socketpair(PF_LOCAL, SOCK_STREAM, 0, sp))
 		<< strerror(errno);
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	ASSERT_NE(0, sendfile(fd, sp[1], 0, bufsize, NULL, &sbytes, 0));
 
 	close(sp[1]);
 	close(sp[0]);
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 /* fuse(4) should honor the filesystem's requested m_readahead parameter */
 /* https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=236472 */
 TEST_P(ReadAhead, DISABLED_readahead) {
 	const char FULLPATH[] = "mountpoint/some_file.txt";
 	const char RELPATH[] = "some_file.txt";
 	const char *CONTENTS0 = "abcdefghijklmnop";
 	uint64_t ino = 42;
 	int fd;
 	ssize_t bufsize = 8;
 	ssize_t filesize = m_maxbcachebuf * 2;
 	char *contents;
 	char buf[bufsize];
 
 	ASSERT_TRUE(GetParam() < (uint32_t)m_maxbcachebuf)
 		<< "Test assumes that max_readahead < maxbcachebuf";
 
 	contents = (char*)calloc(1, filesize);
 	ASSERT_NE(NULL, contents);
 	memmove(contents, CONTENTS0, strlen(CONTENTS0));
 
 	expect_lookup(RELPATH, ino, filesize);
 	expect_open(ino, 0, 1);
 	/* fuse(4) should only read ahead the allowed amount */
 	expect_read(ino, 0, GetParam(), GetParam(), contents);
 
 	fd = open(FULLPATH, O_RDONLY);
 	ASSERT_LE(0, fd) << strerror(errno);
 
 	ASSERT_EQ(bufsize, read(fd, buf, bufsize)) << strerror(errno);
 	ASSERT_EQ(0, memcmp(buf, CONTENTS0, bufsize));
 
 	/* Deliberately leak fd.  close(2) will be tested in release.cc */
 }
 
 INSTANTIATE_TEST_CASE_P(RA, ReadAhead, ::testing::Values(0u, 2048u));
Index: projects/fuse2/tests/sys/fs/fusefs/utils.hh
===================================================================
--- projects/fuse2/tests/sys/fs/fusefs/utils.hh	(revision 347402)
+++ projects/fuse2/tests/sys/fs/fusefs/utils.hh	(revision 347403)
@@ -1,174 +1,181 @@
 /*-
  * 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.
  */
 
 /*
  * TODO: remove FUSE_WRITE_CACHE definition when upgrading to protocol 7.9.
  * This bit was actually part of kernel protocol version 7.2, but never
  * documented until 7.9
  */
 #ifndef FUSE_WRITE_CACHE
 #define FUSE_WRITE_CACHE 1
 #endif
 
+/* Nanoseconds to sleep, for tests that must */
+#define NAP_NS	(100'000'000)
+
 void get_unprivileged_id(uid_t *uid, gid_t *gid);
+inline void nap()
+{
+	usleep(NAP_NS / 1000);
+}
 
 class FuseTest : public ::testing::Test {
 	protected:
 	uint32_t m_maxreadahead;
 	uint32_t m_init_flags;
 	bool m_allow_other;
 	bool m_default_permissions;
 	bool m_push_symlinks_in;
 	bool m_ro;
 	MockFS *m_mock = NULL;
 	const static uint64_t FH = 0xdeadbeef1a7ebabe;
 
 	public:
 	int m_maxbcachebuf;
 
 	FuseTest():
 		/*
 		 * libfuse's default max_readahead is UINT_MAX, though it can
 		 * be lowered
 		 */
 		m_maxreadahead(UINT_MAX),
 		m_init_flags(0),
 		m_allow_other(false),
 		m_default_permissions(false),
 		m_push_symlinks_in(false),
 		m_ro(false)
 	{}
 
 	virtual void SetUp();
 
 	virtual void TearDown() {
 		if (m_mock)
 			delete m_mock;
 	}
 
 	/*
 	 * Create an expectation that FUSE_ACCESS will be called once for the
 	 * given inode with the given access_mode, returning the given errno
 	 */
 	void expect_access(uint64_t ino, mode_t access_mode, int error);
 
 	/*
 	 * Create an expectation that FUSE_FLUSH will be called times times for
 	 * the given inode
 	 */
 	void expect_flush(uint64_t ino, int times, ProcessMockerT r);
 
 	/*
 	 * Create an expectation that FUSE_FORGET will be called for the given
 	 * inode.  There will be no response
 	 */
 	void expect_forget(uint64_t ino, uint64_t nlookup);
 
 	/*
 	 * Create an expectation that FUSE_GETATTR will be called for the given
 	 * inode any number of times.  It will respond with a few basic
 	 * attributes, like the given size and the mode S_IFREG | 0644
 	 */
 	void expect_getattr(uint64_t ino, uint64_t size);
 
 	/*
 	 * Create an expectation that FUSE_LOOKUP will be called for the given
 	 * path exactly times times and cache validity period.  It will respond
 	 * with inode ino, mode mode, filesize size.
 	 */
 	void expect_lookup(const char *relpath, uint64_t ino, mode_t mode,
 		uint64_t size, int times, uint64_t attr_valid = UINT64_MAX,
 		uid_t uid = 0, gid_t gid = 0);
 
 	/*
 	 * Create an expectation that FUSE_OPEN will be called for the given
 	 * inode exactly times times.  It will return with open_flags flags and
 	 * file handle FH.
 	 */
 	void expect_open(uint64_t ino, uint32_t flags, int times);
 
 	/*
 	 * Create an expectation that FUSE_OPENDIR will be called exactly once
 	 * for inode ino.
 	 */
 	void expect_opendir(uint64_t ino);
 
 	/*
 	 * Create an expectation that FUSE_READ will be called exactly once for
 	 * the given inode, at offset offset and with size isize.  It will
 	 * return the first osize bytes from contents
 	 */
 	void expect_read(uint64_t ino, uint64_t offset, uint64_t isize,
 		uint64_t osize, const void *contents);
 
 	/* 
 	 * Create an expectation that FUSE_RELEASE will be called exactly once
 	 * for the given inode and filehandle, returning success
 	 */
 	void expect_release(uint64_t ino, uint64_t fh);
 
 	/*
 	 * Create an expectation that FUSE_RELEASEDIR will be called exactly
 	 * once for the given inode
 	 */
 	void expect_releasedir(uint64_t ino, ProcessMockerT r);
 
 	/*
 	 * Create an expectation that FUSE_UNLINK will be called exactly once
 	 * for the given path, returning an errno
 	 */
 	void expect_unlink(uint64_t parent, const char *path, int error);
 
 	/*
 	 * Create an expectation that FUSE_WRITE will be called exactly once
 	 * for the given inode, at offset offset, with write_flags flags, 
 	 * size isize and buffer contents.  It will return osize
 	 */
 	void expect_write(uint64_t ino, uint64_t offset, uint64_t isize,
 		uint64_t osize, uint32_t flags, const void *contents);
 
 	/*
 	 * Helper that runs code in a child process.
 	 *
 	 * First, parent_func runs in the parent process.
 	 * Then, child_func runs in the child process, dropping privileges if
 	 * desired.
 	 * Finally, fusetest_fork returns.
 	 *
 	 * # Returns
 	 *
 	 * fusetest_fork may SKIP the test, which the caller should detect with
 	 * the IsSkipped() method.  If not, then the child's exit status will
 	 * be returned in status.
 	 */
 	void fork(bool drop_privs, int *status,
 		std::function<void()> parent_func,
 		std::function<int()> child_func);
 };