5 files changed, 153 insertions, 6 deletions

diff --git a/tests/sys/file/closefrom_test.c b/tests/sys/file/closefrom_test.c
index 7dccf858c772..212d048d7566 100644
--- a/tests/sys/file/closefrom_test.c
+++ b/tests/sys/file/closefrom_test.c
@@ -148,7 +148,7 @@ main(void)
 
 	/* We'd better start up with fd's 0, 1, and 2 open. */
 	start = devnull();
-	if (start == -1)
+	if (start < 3)
 		fail("open", "bad descriptor %d", start);
 	ok("open");
 
@@ -159,9 +159,9 @@ main(void)
 	ok("highest_fd");
 
 	/* Try to use closefrom() for just closing fd 3. */
-	closefrom(start + 1);
+	closefrom(start);
 	fd = highest_fd();
-	if (fd != start)
+	if (fd != start - 1)
 		fail("closefrom", "highest fd %d", fd);
 	ok("closefrom");
 
@@ -169,7 +169,7 @@ main(void)
 	for (i = 0; i < 16; i++)
 		(void)devnull();
 	fd = highest_fd();
-	if (fd != start + 16)
+	if (fd != start + 15)
 		fail("open 16", "highest fd %d", fd);
 	ok("open 16");
 
diff --git a/tests/sys/fs/fusefs/bmap.cc b/tests/sys/fs/fusefs/bmap.cc
index 30612079657d..e61dadb6d79e 100644
--- a/tests/sys/fs/fusefs/bmap.cc
+++ b/tests/sys/fs/fusefs/bmap.cc
@@ -178,6 +178,93 @@ TEST_F(Bmap, default_)
 }
 
 /*
+ * The server returns an error for some reason for FUSE_BMAP.  fusefs should
+ * faithfully report that error up to the caller.
+ */
+TEST_F(Bmap, einval)
+{
+	struct fiobmap2_arg arg;
+	const off_t filesize = 1 << 30;
+	int64_t lbn = 100;
+	const ino_t ino = 42;
+	int fd;
+
+	expect_lookup(RELPATH, 42, filesize);
+	expect_open(ino, 0, 1);
+	EXPECT_CALL(*m_mock, process(
+		ResultOf([=](auto in) {
+			return (in.header.opcode == FUSE_BMAP &&
+				in.header.nodeid == ino);
+		}, Eq(true)),
+		_)
+	).WillOnce(Invoke(ReturnErrno(EINVAL)));
+
+	fd = open(FULLPATH, O_RDWR);
+	ASSERT_LE(0, fd) << strerror(errno);
+
+	arg.bn = lbn;
+	arg.runp = -1;
+	arg.runb = -1;
+	ASSERT_EQ(-1, ioctl(fd, FIOBMAP2, &arg));
+	EXPECT_EQ(EINVAL, errno);
+
+	leak(fd);
+}
+
+/*
+ * Even if the server returns EINVAL during VOP_BMAP, we should still be able
+ * to successfully read a block.  This is a regression test for
+ * https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=264196 .  The bug did not
+ * lie in fusefs, but this is a convenient place for a regression test.
+ */
+TEST_F(Bmap, spurious_einval)
+{
+	const off_t filesize = 4ull << 30;
+	const ino_t ino = 42;
+	int fd, r;
+	char buf[1];
+
+	expect_lookup(RELPATH, 42, filesize);
+	expect_open(ino, 0, 1);
+	EXPECT_CALL(*m_mock, process(
+		ResultOf([=](auto in) {
+			return (in.header.opcode == FUSE_BMAP &&
+				in.header.nodeid == ino);
+		}, Eq(true)),
+		_)
+	).WillRepeatedly(Invoke(ReturnErrno(EINVAL)));
+	EXPECT_CALL(*m_mock, process(
+	ResultOf([=](auto in) {
+		return (in.header.opcode == FUSE_READ &&
+			in.header.nodeid == ino &&
+			in.body.read.offset == 0 &&
+			in.body.read.size == (uint64_t)m_maxbcachebuf);
+		}, Eq(true)),
+		_)
+	).WillOnce(Invoke(ReturnImmediate([=](auto in, auto& out) {
+		size_t osize = in.body.read.size;
+
+		assert(osize < sizeof(out.body.bytes));
+		out.header.len = sizeof(struct fuse_out_header) + osize;
+		bzero(out.body.bytes, osize);
+	})));
+
+	fd = open(FULLPATH, O_RDWR);
+	ASSERT_LE(0, fd) << strerror(errno);
+
+	/*
+	 * Read the same block multiple times.  On a system affected by PR
+	 * 264196 , the second read will fail.
+	 */
+	r = read(fd, buf, sizeof(buf));
+	EXPECT_EQ(r, 1) << strerror(errno);
+	r = read(fd, buf, sizeof(buf));
+	EXPECT_EQ(r, 1) << strerror(errno);
+	r = read(fd, buf, sizeof(buf));
+	EXPECT_EQ(r, 1) << strerror(errno);
+}
+
+/*
  * VOP_BMAP should not query the server for the file's size, even if its cached
  * attributes have expired.
  * Regression test for https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=256937
diff --git a/tests/sys/fs/fusefs/mockfs.cc b/tests/sys/fs/fusefs/mockfs.cc
index e8081dea9604..55c191716629 100644
--- a/tests/sys/fs/fusefs/mockfs.cc
+++ b/tests/sys/fs/fusefs/mockfs.cc
@@ -827,10 +827,12 @@ void MockFS::loop() {
 	}
 }
 
-int MockFS::notify_inval_entry(ino_t parent, const char *name, size_t namelen)
+int MockFS::notify_inval_entry(ino_t parent, const char *name, size_t namelen,
+		int expected_errno)
 {
 	std::unique_ptr<mockfs_buf_out> out(new mockfs_buf_out);
 
+	out->expected_errno = expected_errno;
 	out->header.unique = 0;	/* 0 means asynchronous notification */
 	out->header.error = FUSE_NOTIFY_INVAL_ENTRY;
 	out->body.inval_entry.parent = parent;
diff --git a/tests/sys/fs/fusefs/mockfs.hh b/tests/sys/fs/fusefs/mockfs.hh
index ba6f7fded9d0..4b0628d34dd7 100644
--- a/tests/sys/fs/fusefs/mockfs.hh
+++ b/tests/sys/fs/fusefs/mockfs.hh
@@ -390,8 +390,10 @@ class MockFS {
 	 * @param	parent	Parent directory's inode number
 	 * @param	name	name of dirent to invalidate
 	 * @param	namelen	size of name, including the NUL
+	 * @param	expected_errno The error that write() should return
 	 */
-	int notify_inval_entry(ino_t parent, const char *name, size_t namelen);
+	int notify_inval_entry(ino_t parent, const char *name, size_t namelen,
+			int expected_errno = 0);
 
 	/*
 	 * Send an asynchronous notification to invalidate an inode's cached
diff --git a/tests/sys/fs/fusefs/notify.cc b/tests/sys/fs/fusefs/notify.cc
index 1e22bde13db7..d370a1e6e706 100644
--- a/tests/sys/fs/fusefs/notify.cc
+++ b/tests/sys/fs/fusefs/notify.cc
@@ -385,6 +385,27 @@ TEST_F(Notify, inval_inode_with_clean_cache)
 	leak(fd);
 }
 
+/*
+ * Attempting to invalidate an entry or inode after unmounting should fail, but
+ * nothing bad should happen.
+ * https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=290519
+ */
+TEST_F(Notify, notify_after_unmount)
+{
+	const static char *name = "foo";
+	struct inval_entry_args iea;
+
+	expect_destroy(0);
+
+	m_mock->unmount();
+
+	iea.mock = m_mock;
+	iea.parent = FUSE_ROOT_ID;
+	iea.name = name;
+	iea.namelen = strlen(name);
+	iea.mock->notify_inval_entry(iea.parent, iea.name, iea.namelen, ENODEV);
+}
+
 /* FUSE_NOTIFY_STORE with a file that's not in the entry cache */
 /* disabled because FUSE_NOTIFY_STORE is not yet implemented */
 TEST_F(Notify, DISABLED_store_nonexistent)
@@ -544,3 +565,38 @@ TEST_F(NotifyWriteback, inval_inode_attrs_only)
 
 	leak(fd);
 }
+
+/*
+ * Attempting asynchronous invalidation of an Entry before mounting the file
+ * system should fail, but nothing bad should happen.
+ *
+ * Note that invalidating an inode before mount goes through the same path, and
+ * is not separately tested.
+ *
+ * https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=290519
+ */
+TEST(PreMount, inval_entry_before_mount)
+{
+	const static char name[] = "foo";
+	size_t namelen = strlen(name);
+	struct mockfs_buf_out *out;
+	int r;
+	int fuse_fd;
+
+	fuse_fd = open("/dev/fuse", O_CLOEXEC | O_RDWR);
+	ASSERT_GE(fuse_fd, 0) << strerror(errno);
+
+	out = new mockfs_buf_out;
+	out->header.unique = 0;	/* 0 means asynchronous notification */
+	out->header.error = FUSE_NOTIFY_INVAL_ENTRY;
+	out->body.inval_entry.parent = FUSE_ROOT_ID;
+	out->body.inval_entry.namelen = namelen;
+	strlcpy((char*)&out->body.bytes + sizeof(out->body.inval_entry),
+		name, sizeof(out->body.bytes) - sizeof(out->body.inval_entry));
+	out->header.len = sizeof(out->header) + sizeof(out->body.inval_entry) +
+		namelen;
+	r = write(fuse_fd, out, out->header.len);
+	EXPECT_EQ(-1, r);
+	EXPECT_EQ(ENODEV, errno);
+	delete out;
+}