xref: /freebsd/tests/sys/fs/fusefs/utils.cc (revision a34cdd26d02ffdb4134e5945b902921697b6ceff)
19821f1d3SAlan Somers /*-
29821f1d3SAlan Somers  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
39821f1d3SAlan Somers  *
49821f1d3SAlan Somers  * Copyright (c) 2019 The FreeBSD Foundation
59821f1d3SAlan Somers  *
69821f1d3SAlan Somers  * This software was developed by BFF Storage Systems, LLC under sponsorship
79821f1d3SAlan Somers  * from the FreeBSD Foundation.
89821f1d3SAlan Somers  *
99821f1d3SAlan Somers  * Redistribution and use in source and binary forms, with or without
109821f1d3SAlan Somers  * modification, are permitted provided that the following conditions
119821f1d3SAlan Somers  * are met:
129821f1d3SAlan Somers  * 1. Redistributions of source code must retain the above copyright
139821f1d3SAlan Somers  *    notice, this list of conditions and the following disclaimer.
149821f1d3SAlan Somers  * 2. Redistributions in binary form must reproduce the above copyright
159821f1d3SAlan Somers  *    notice, this list of conditions and the following disclaimer in the
169821f1d3SAlan Somers  *    documentation and/or other materials provided with the distribution.
179821f1d3SAlan Somers  *
189821f1d3SAlan Somers  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
199821f1d3SAlan Somers  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
209821f1d3SAlan Somers  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
219821f1d3SAlan Somers  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
229821f1d3SAlan Somers  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
239821f1d3SAlan Somers  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
249821f1d3SAlan Somers  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
259821f1d3SAlan Somers  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
269821f1d3SAlan Somers  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
279821f1d3SAlan Somers  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
289821f1d3SAlan Somers  * SUCH DAMAGE.
299821f1d3SAlan Somers  */
309821f1d3SAlan Somers 
3109c01e67SAlan Somers extern "C" {
329821f1d3SAlan Somers #include <sys/param.h>
3309c01e67SAlan Somers #include <sys/mman.h>
349821f1d3SAlan Somers #include <sys/module.h>
359821f1d3SAlan Somers #include <sys/sysctl.h>
3609c01e67SAlan Somers #include <sys/wait.h>
3709c01e67SAlan Somers 
38e5b50fe7SAlan Somers #include <dirent.h>
39d4fd0c81SAlan Somers #include <fcntl.h>
4061b0a927SAlan Somers #include <grp.h>
4109c01e67SAlan Somers #include <pwd.h>
4209c01e67SAlan Somers #include <semaphore.h>
4309c01e67SAlan Somers #include <unistd.h>
4409c01e67SAlan Somers }
459821f1d3SAlan Somers 
469821f1d3SAlan Somers #include <gtest/gtest.h>
479821f1d3SAlan Somers 
489821f1d3SAlan Somers #include "mockfs.hh"
499821f1d3SAlan Somers #include "utils.hh"
509821f1d3SAlan Somers 
519821f1d3SAlan Somers using namespace testing;
529821f1d3SAlan Somers 
539821f1d3SAlan Somers /* Check that fusefs(4) is accessible and the current user can mount(2) */
549821f1d3SAlan Somers void check_environment()
559821f1d3SAlan Somers {
569821f1d3SAlan Somers 	const char *devnode = "/dev/fuse";
579821f1d3SAlan Somers 	const char *usermount_node = "vfs.usermount";
589821f1d3SAlan Somers 	int usermount_val = 0;
599821f1d3SAlan Somers 	size_t usermount_size = sizeof(usermount_val);
609821f1d3SAlan Somers 	if (eaccess(devnode, R_OK | W_OK)) {
619821f1d3SAlan Somers 		if (errno == ENOENT) {
629821f1d3SAlan Somers 			GTEST_SKIP() << devnode << " does not exist";
639821f1d3SAlan Somers 		} else if (errno == EACCES) {
649821f1d3SAlan Somers 			GTEST_SKIP() << devnode <<
659821f1d3SAlan Somers 			    " is not accessible by the current user";
669821f1d3SAlan Somers 		} else {
679821f1d3SAlan Somers 			GTEST_SKIP() << strerror(errno);
689821f1d3SAlan Somers 		}
699821f1d3SAlan Somers 	}
709821f1d3SAlan Somers 	sysctlbyname(usermount_node, &usermount_val, &usermount_size,
719821f1d3SAlan Somers 		     NULL, 0);
729821f1d3SAlan Somers 	if (geteuid() != 0 && !usermount_val)
739821f1d3SAlan Somers 		GTEST_SKIP() << "current user is not allowed to mount";
749821f1d3SAlan Somers }
759821f1d3SAlan Somers 
769821f1d3SAlan Somers class FuseEnv: public Environment {
779821f1d3SAlan Somers 	virtual void SetUp() {
789821f1d3SAlan Somers 	}
799821f1d3SAlan Somers };
809821f1d3SAlan Somers 
819821f1d3SAlan Somers void FuseTest::SetUp() {
829821f1d3SAlan Somers 	const char *node = "vfs.maxbcachebuf";
839821f1d3SAlan Somers 	int val = 0;
849821f1d3SAlan Somers 	size_t size = sizeof(val);
859821f1d3SAlan Somers 
869821f1d3SAlan Somers 	/*
879821f1d3SAlan Somers 	 * XXX check_environment should be called from FuseEnv::SetUp, but
889821f1d3SAlan Somers 	 * can't due to https://github.com/google/googletest/issues/2189
899821f1d3SAlan Somers 	 */
909821f1d3SAlan Somers 	check_environment();
919821f1d3SAlan Somers 	if (IsSkipped())
929821f1d3SAlan Somers 		return;
939821f1d3SAlan Somers 
949821f1d3SAlan Somers 	ASSERT_EQ(0, sysctlbyname(node, &val, &size, NULL, 0))
959821f1d3SAlan Somers 		<< strerror(errno);
969821f1d3SAlan Somers 	m_maxbcachebuf = val;
979821f1d3SAlan Somers 
989821f1d3SAlan Somers 	try {
9991ff3a0dSAlan Somers 		m_mock = new MockFS(m_maxreadahead, m_allow_other,
100140bb492SAlan Somers 			m_default_permissions, m_push_symlinks_in, m_ro,
10116bd2d47SAlan Somers 			m_pm, m_init_flags, m_kernel_minor_version);
102caf5f57dSAlan Somers 		/*
103caf5f57dSAlan Somers 		 * FUSE_ACCESS is called almost universally.  Expecting it in
104caf5f57dSAlan Somers 		 * each test case would be super-annoying.  Instead, set a
105caf5f57dSAlan Somers 		 * default expectation for FUSE_ACCESS and return ENOSYS.
106caf5f57dSAlan Somers 		 *
107caf5f57dSAlan Somers 		 * Individual test cases can override this expectation since
108caf5f57dSAlan Somers 		 * googlemock evaluates expectations in LIFO order.
109caf5f57dSAlan Somers 		 */
110caf5f57dSAlan Somers 		EXPECT_CALL(*m_mock, process(
111caf5f57dSAlan Somers 			ResultOf([=](auto in) {
11229edc611SAlan Somers 				return (in.header.opcode == FUSE_ACCESS);
113caf5f57dSAlan Somers 			}, Eq(true)),
114caf5f57dSAlan Somers 			_)
115caf5f57dSAlan Somers 		).Times(AnyNumber())
116caf5f57dSAlan Somers 		.WillRepeatedly(Invoke(ReturnErrno(ENOSYS)));
1179821f1d3SAlan Somers 	} catch (std::system_error err) {
1189821f1d3SAlan Somers 		FAIL() << err.what();
1199821f1d3SAlan Somers 	}
1209821f1d3SAlan Somers }
1219821f1d3SAlan Somers 
12291ff3a0dSAlan Somers void
12391ff3a0dSAlan Somers FuseTest::expect_access(uint64_t ino, mode_t access_mode, int error)
12491ff3a0dSAlan Somers {
12591ff3a0dSAlan Somers 	EXPECT_CALL(*m_mock, process(
12691ff3a0dSAlan Somers 		ResultOf([=](auto in) {
12729edc611SAlan Somers 			return (in.header.opcode == FUSE_ACCESS &&
12829edc611SAlan Somers 				in.header.nodeid == ino &&
12929edc611SAlan Somers 				in.body.access.mask == access_mode);
13091ff3a0dSAlan Somers 		}, Eq(true)),
13191ff3a0dSAlan Somers 		_)
13291ff3a0dSAlan Somers 	).WillOnce(Invoke(ReturnErrno(error)));
13391ff3a0dSAlan Somers }
13491ff3a0dSAlan Somers 
1359f10f423SAlan Somers void
1363429092cSAlan Somers FuseTest::expect_destroy(int error)
1373429092cSAlan Somers {
1383429092cSAlan Somers 	EXPECT_CALL(*m_mock, process(
1393429092cSAlan Somers 		ResultOf([=](auto in) {
14029edc611SAlan Somers 			return (in.header.opcode == FUSE_DESTROY);
1413429092cSAlan Somers 		}, Eq(true)),
1423429092cSAlan Somers 		_)
14329edc611SAlan Somers 	).WillOnce(Invoke( ReturnImmediate([&](auto in, auto& out) {
1443429092cSAlan Somers 		m_mock->m_quit = true;
14529edc611SAlan Somers 		out.header.len = sizeof(out.header);
14629edc611SAlan Somers 		out.header.unique = in.header.unique;
14729edc611SAlan Somers 		out.header.error = -error;
1483429092cSAlan Somers 	})));
1493429092cSAlan Somers }
1503429092cSAlan Somers 
1513429092cSAlan Somers void
1529f10f423SAlan Somers FuseTest::expect_flush(uint64_t ino, int times, ProcessMockerT r)
1539f10f423SAlan Somers {
1549f10f423SAlan Somers 	EXPECT_CALL(*m_mock, process(
1559f10f423SAlan Somers 		ResultOf([=](auto in) {
15629edc611SAlan Somers 			return (in.header.opcode == FUSE_FLUSH &&
15729edc611SAlan Somers 				in.header.nodeid == ino);
1589f10f423SAlan Somers 		}, Eq(true)),
1599f10f423SAlan Somers 		_)
1609f10f423SAlan Somers 	).Times(times)
1619f10f423SAlan Somers 	.WillRepeatedly(Invoke(r));
1629f10f423SAlan Somers }
1639f10f423SAlan Somers 
164ff4fbdf5SAlan Somers void
165ff4fbdf5SAlan Somers FuseTest::expect_forget(uint64_t ino, uint64_t nlookup)
166ff4fbdf5SAlan Somers {
167ff4fbdf5SAlan Somers 	EXPECT_CALL(*m_mock, process(
168ff4fbdf5SAlan Somers 		ResultOf([=](auto in) {
16929edc611SAlan Somers 			return (in.header.opcode == FUSE_FORGET &&
17029edc611SAlan Somers 				in.header.nodeid == ino &&
17129edc611SAlan Somers 				in.body.forget.nlookup == nlookup);
172ff4fbdf5SAlan Somers 		}, Eq(true)),
173ff4fbdf5SAlan Somers 		_)
174ff4fbdf5SAlan Somers 	).WillOnce(Invoke([](auto in __unused, auto &out __unused) {
175ff4fbdf5SAlan Somers 		/* FUSE_FORGET has no response! */
176ff4fbdf5SAlan Somers 	}));
177ff4fbdf5SAlan Somers }
178ff4fbdf5SAlan Somers 
1799821f1d3SAlan Somers void FuseTest::expect_getattr(uint64_t ino, uint64_t size)
1809821f1d3SAlan Somers {
1819821f1d3SAlan Somers 	EXPECT_CALL(*m_mock, process(
1829821f1d3SAlan Somers 		ResultOf([=](auto in) {
18329edc611SAlan Somers 			return (in.header.opcode == FUSE_GETATTR &&
18429edc611SAlan Somers 				in.header.nodeid == ino);
1859821f1d3SAlan Somers 		}, Eq(true)),
1869821f1d3SAlan Somers 		_)
18729edc611SAlan Somers 	).WillOnce(Invoke(ReturnImmediate([=](auto i __unused, auto& out) {
1889821f1d3SAlan Somers 		SET_OUT_HEADER_LEN(out, attr);
18929edc611SAlan Somers 		out.body.attr.attr.ino = ino;	// Must match nodeid
19029edc611SAlan Somers 		out.body.attr.attr.mode = S_IFREG | 0644;
19129edc611SAlan Somers 		out.body.attr.attr.size = size;
19229edc611SAlan Somers 		out.body.attr.attr_valid = UINT64_MAX;
1939821f1d3SAlan Somers 	})));
1949821f1d3SAlan Somers }
1959821f1d3SAlan Somers 
1969821f1d3SAlan Somers void FuseTest::expect_lookup(const char *relpath, uint64_t ino, mode_t mode,
197474ba6faSAlan Somers 	uint64_t size, int times, uint64_t attr_valid, uid_t uid, gid_t gid)
1989821f1d3SAlan Somers {
199*a34cdd26SAlan Somers 	EXPECT_LOOKUP(FUSE_ROOT_ID, relpath)
2009821f1d3SAlan Somers 	.Times(times)
20129edc611SAlan Somers 	.WillRepeatedly(Invoke(
20229edc611SAlan Somers 		ReturnImmediate([=](auto in __unused, auto& out) {
2039821f1d3SAlan Somers 		SET_OUT_HEADER_LEN(out, entry);
20429edc611SAlan Somers 		out.body.entry.attr.mode = mode;
20529edc611SAlan Somers 		out.body.entry.nodeid = ino;
20629edc611SAlan Somers 		out.body.entry.attr.nlink = 1;
20729edc611SAlan Somers 		out.body.entry.attr_valid = attr_valid;
20829edc611SAlan Somers 		out.body.entry.attr.size = size;
20929edc611SAlan Somers 		out.body.entry.attr.uid = uid;
21029edc611SAlan Somers 		out.body.entry.attr.gid = gid;
2119821f1d3SAlan Somers 	})));
2129821f1d3SAlan Somers }
2139821f1d3SAlan Somers 
21416bd2d47SAlan Somers void FuseTest::expect_lookup_7_8(const char *relpath, uint64_t ino, mode_t mode,
21516bd2d47SAlan Somers 	uint64_t size, int times, uint64_t attr_valid, uid_t uid, gid_t gid)
21616bd2d47SAlan Somers {
217*a34cdd26SAlan Somers 	EXPECT_LOOKUP(FUSE_ROOT_ID, relpath)
21816bd2d47SAlan Somers 	.Times(times)
21929edc611SAlan Somers 	.WillRepeatedly(Invoke(
22029edc611SAlan Somers 		ReturnImmediate([=](auto in __unused, auto& out) {
22116bd2d47SAlan Somers 		SET_OUT_HEADER_LEN(out, entry_7_8);
22229edc611SAlan Somers 		out.body.entry.attr.mode = mode;
22329edc611SAlan Somers 		out.body.entry.nodeid = ino;
22429edc611SAlan Somers 		out.body.entry.attr.nlink = 1;
22529edc611SAlan Somers 		out.body.entry.attr_valid = attr_valid;
22629edc611SAlan Somers 		out.body.entry.attr.size = size;
22729edc611SAlan Somers 		out.body.entry.attr.uid = uid;
22829edc611SAlan Somers 		out.body.entry.attr.gid = gid;
22916bd2d47SAlan Somers 	})));
23016bd2d47SAlan Somers }
23116bd2d47SAlan Somers 
2329821f1d3SAlan Somers void FuseTest::expect_open(uint64_t ino, uint32_t flags, int times)
2339821f1d3SAlan Somers {
2349821f1d3SAlan Somers 	EXPECT_CALL(*m_mock, process(
2359821f1d3SAlan Somers 		ResultOf([=](auto in) {
23629edc611SAlan Somers 			return (in.header.opcode == FUSE_OPEN &&
23729edc611SAlan Somers 				in.header.nodeid == ino);
2389821f1d3SAlan Somers 		}, Eq(true)),
2399821f1d3SAlan Somers 		_)
2409821f1d3SAlan Somers 	).Times(times)
24129edc611SAlan Somers 	.WillRepeatedly(Invoke(
24229edc611SAlan Somers 		ReturnImmediate([=](auto in __unused, auto& out) {
24329edc611SAlan Somers 		out.header.len = sizeof(out.header);
2449821f1d3SAlan Somers 		SET_OUT_HEADER_LEN(out, open);
24529edc611SAlan Somers 		out.body.open.fh = FH;
24629edc611SAlan Somers 		out.body.open.open_flags = flags;
2479821f1d3SAlan Somers 	})));
2489821f1d3SAlan Somers }
2499821f1d3SAlan Somers 
2509821f1d3SAlan Somers void FuseTest::expect_opendir(uint64_t ino)
2519821f1d3SAlan Somers {
252363a7416SAlan Somers 	/* opendir(3) calls fstatfs */
2539821f1d3SAlan Somers 	EXPECT_CALL(*m_mock, process(
2549821f1d3SAlan Somers 		ResultOf([](auto in) {
25529edc611SAlan Somers 			return (in.header.opcode == FUSE_STATFS);
2569821f1d3SAlan Somers 		}, Eq(true)),
2579821f1d3SAlan Somers 		_)
25829edc611SAlan Somers 	).WillRepeatedly(Invoke(
25929edc611SAlan Somers 	ReturnImmediate([=](auto i __unused, auto& out) {
2609821f1d3SAlan Somers 		SET_OUT_HEADER_LEN(out, statfs);
2619821f1d3SAlan Somers 	})));
2629821f1d3SAlan Somers 
2639821f1d3SAlan Somers 	EXPECT_CALL(*m_mock, process(
2649821f1d3SAlan Somers 		ResultOf([=](auto in) {
26529edc611SAlan Somers 			return (in.header.opcode == FUSE_OPENDIR &&
26629edc611SAlan Somers 				in.header.nodeid == ino);
2679821f1d3SAlan Somers 		}, Eq(true)),
2689821f1d3SAlan Somers 		_)
26929edc611SAlan Somers 	).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
27029edc611SAlan Somers 		out.header.len = sizeof(out.header);
2719821f1d3SAlan Somers 		SET_OUT_HEADER_LEN(out, open);
27229edc611SAlan Somers 		out.body.open.fh = FH;
2739821f1d3SAlan Somers 	})));
2749821f1d3SAlan Somers }
2759821f1d3SAlan Somers 
2769821f1d3SAlan Somers void FuseTest::expect_read(uint64_t ino, uint64_t offset, uint64_t isize,
277d4fd0c81SAlan Somers 	uint64_t osize, const void *contents, int flags)
2789821f1d3SAlan Somers {
2799821f1d3SAlan Somers 	EXPECT_CALL(*m_mock, process(
2809821f1d3SAlan Somers 		ResultOf([=](auto in) {
28129edc611SAlan Somers 			return (in.header.opcode == FUSE_READ &&
28229edc611SAlan Somers 				in.header.nodeid == ino &&
28329edc611SAlan Somers 				in.body.read.fh == FH &&
28429edc611SAlan Somers 				in.body.read.offset == offset &&
285d4fd0c81SAlan Somers 				in.body.read.size == isize &&
286d4fd0c81SAlan Somers 				flags == -1 ?
287d4fd0c81SAlan Somers 					(in.body.read.flags == O_RDONLY ||
288d4fd0c81SAlan Somers 					 in.body.read.flags == O_RDWR)
289d4fd0c81SAlan Somers 				: in.body.read.flags == (uint32_t)flags);
2909821f1d3SAlan Somers 		}, Eq(true)),
2919821f1d3SAlan Somers 		_)
29229edc611SAlan Somers 	).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
29329edc611SAlan Somers 		out.header.len = sizeof(struct fuse_out_header) + osize;
29429edc611SAlan Somers 		memmove(out.body.bytes, contents, osize);
2959821f1d3SAlan Somers 	}))).RetiresOnSaturation();
2969821f1d3SAlan Somers }
2979821f1d3SAlan Somers 
298e5b50fe7SAlan Somers void FuseTest::expect_readdir(uint64_t ino, uint64_t off,
299e5b50fe7SAlan Somers 	std::vector<struct dirent> &ents)
300e5b50fe7SAlan Somers {
301e5b50fe7SAlan Somers 	EXPECT_CALL(*m_mock, process(
302e5b50fe7SAlan Somers 		ResultOf([=](auto in) {
30329edc611SAlan Somers 			return (in.header.opcode == FUSE_READDIR &&
30429edc611SAlan Somers 				in.header.nodeid == ino &&
30529edc611SAlan Somers 				in.body.readdir.fh == FH &&
30629edc611SAlan Somers 				in.body.readdir.offset == off);
307e5b50fe7SAlan Somers 		}, Eq(true)),
308e5b50fe7SAlan Somers 		_)
30929edc611SAlan Somers 	).WillRepeatedly(Invoke(ReturnImmediate([=](auto in, auto& out) {
31029edc611SAlan Somers 		struct fuse_dirent *fde = (struct fuse_dirent*)&(out.body);
311e5b50fe7SAlan Somers 		int i = 0;
312e5b50fe7SAlan Somers 
31329edc611SAlan Somers 		out.header.error = 0;
31429edc611SAlan Somers 		out.header.len = 0;
315e5b50fe7SAlan Somers 
316e5b50fe7SAlan Somers 		for (const auto& it: ents) {
317e5b50fe7SAlan Somers 			size_t entlen, entsize;
318e5b50fe7SAlan Somers 
319e5b50fe7SAlan Somers 			fde->ino = it.d_fileno;
320e5b50fe7SAlan Somers 			fde->off = it.d_off;
321e5b50fe7SAlan Somers 			fde->type = it.d_type;
322e5b50fe7SAlan Somers 			fde->namelen = it.d_namlen;
323e5b50fe7SAlan Somers 			strncpy(fde->name, it.d_name, it.d_namlen);
324e5b50fe7SAlan Somers 			entlen = FUSE_NAME_OFFSET + fde->namelen;
325e5b50fe7SAlan Somers 			entsize = FUSE_DIRENT_SIZE(fde);
326e5b50fe7SAlan Somers 			/*
327e5b50fe7SAlan Somers 			 * The FUSE protocol does not require zeroing out the
328e5b50fe7SAlan Somers 			 * unused portion of the name.  But it's a good
329e5b50fe7SAlan Somers 			 * practice to prevent information disclosure to the
330e5b50fe7SAlan Somers 			 * FUSE client, even though the client is usually the
331e5b50fe7SAlan Somers 			 * kernel
332e5b50fe7SAlan Somers 			 */
333e5b50fe7SAlan Somers 			memset(fde->name + fde->namelen, 0, entsize - entlen);
33429edc611SAlan Somers 			if (out.header.len + entsize > in.body.read.size) {
335e5b50fe7SAlan Somers 				printf("Overflow in readdir expectation: i=%d\n"
336e5b50fe7SAlan Somers 					, i);
337e5b50fe7SAlan Somers 				break;
338e5b50fe7SAlan Somers 			}
33929edc611SAlan Somers 			out.header.len += entsize;
340e5b50fe7SAlan Somers 			fde = (struct fuse_dirent*)
341b7774b82SAlan Somers 				((intmax_t*)fde + entsize / sizeof(intmax_t));
342e5b50fe7SAlan Somers 			i++;
343e5b50fe7SAlan Somers 		}
34429edc611SAlan Somers 		out.header.len += sizeof(out.header);
345e5b50fe7SAlan Somers 	})));
346e5b50fe7SAlan Somers 
347e5b50fe7SAlan Somers }
34842d50d16SAlan Somers void FuseTest::expect_release(uint64_t ino, uint64_t fh)
3499821f1d3SAlan Somers {
3509821f1d3SAlan Somers 	EXPECT_CALL(*m_mock, process(
3519821f1d3SAlan Somers 		ResultOf([=](auto in) {
35229edc611SAlan Somers 			return (in.header.opcode == FUSE_RELEASE &&
35329edc611SAlan Somers 				in.header.nodeid == ino &&
35429edc611SAlan Somers 				in.body.release.fh == fh);
3559821f1d3SAlan Somers 		}, Eq(true)),
3569821f1d3SAlan Somers 		_)
357e0bec057SAlan Somers 	).WillOnce(Invoke(ReturnErrno(0)));
3589821f1d3SAlan Somers }
359e0bec057SAlan Somers 
36035cf0e7eSAlan Somers void FuseTest::expect_releasedir(uint64_t ino, ProcessMockerT r)
36135cf0e7eSAlan Somers {
36235cf0e7eSAlan Somers 	EXPECT_CALL(*m_mock, process(
36335cf0e7eSAlan Somers 		ResultOf([=](auto in) {
36429edc611SAlan Somers 			return (in.header.opcode == FUSE_RELEASEDIR &&
36529edc611SAlan Somers 				in.header.nodeid == ino &&
36629edc611SAlan Somers 				in.body.release.fh == FH);
36735cf0e7eSAlan Somers 		}, Eq(true)),
36835cf0e7eSAlan Somers 		_)
36935cf0e7eSAlan Somers 	).WillOnce(Invoke(r));
37035cf0e7eSAlan Somers }
37135cf0e7eSAlan Somers 
372ff4fbdf5SAlan Somers void FuseTest::expect_unlink(uint64_t parent, const char *path, int error)
373ff4fbdf5SAlan Somers {
374ff4fbdf5SAlan Somers 	EXPECT_CALL(*m_mock, process(
375ff4fbdf5SAlan Somers 		ResultOf([=](auto in) {
37629edc611SAlan Somers 			return (in.header.opcode == FUSE_UNLINK &&
37729edc611SAlan Somers 				0 == strcmp(path, in.body.unlink) &&
37829edc611SAlan Somers 				in.header.nodeid == parent);
379ff4fbdf5SAlan Somers 		}, Eq(true)),
380ff4fbdf5SAlan Somers 		_)
381ff4fbdf5SAlan Somers 	).WillOnce(Invoke(ReturnErrno(error)));
382ff4fbdf5SAlan Somers }
383ff4fbdf5SAlan Somers 
3849821f1d3SAlan Somers void FuseTest::expect_write(uint64_t ino, uint64_t offset, uint64_t isize,
385bda39894SAlan Somers 	uint64_t osize, uint32_t flags_set, uint32_t flags_unset,
386bda39894SAlan Somers 	const void *contents)
3879821f1d3SAlan Somers {
3889821f1d3SAlan Somers 	EXPECT_CALL(*m_mock, process(
3899821f1d3SAlan Somers 		ResultOf([=](auto in) {
39029edc611SAlan Somers 			const char *buf = (const char*)in.body.bytes +
3919821f1d3SAlan Somers 				sizeof(struct fuse_write_in);
3929821f1d3SAlan Somers 			bool pid_ok;
393bda39894SAlan Somers 			uint32_t wf = in.body.write.write_flags;
3949821f1d3SAlan Somers 
395bda39894SAlan Somers 			if (wf & FUSE_WRITE_CACHE)
3969821f1d3SAlan Somers 				pid_ok = true;
3979821f1d3SAlan Somers 			else
39829edc611SAlan Somers 				pid_ok = (pid_t)in.header.pid == getpid();
3999821f1d3SAlan Somers 
40029edc611SAlan Somers 			return (in.header.opcode == FUSE_WRITE &&
40129edc611SAlan Somers 				in.header.nodeid == ino &&
40229edc611SAlan Somers 				in.body.write.fh == FH &&
40329edc611SAlan Somers 				in.body.write.offset == offset  &&
40429edc611SAlan Somers 				in.body.write.size == isize &&
4059821f1d3SAlan Somers 				pid_ok &&
406bda39894SAlan Somers 				(wf & flags_set) == flags_set &&
407bda39894SAlan Somers 				(wf & flags_unset) == 0 &&
408d4fd0c81SAlan Somers 				(in.body.write.flags == O_WRONLY ||
409d4fd0c81SAlan Somers 				 in.body.write.flags == O_RDWR) &&
4109821f1d3SAlan Somers 				0 == bcmp(buf, contents, isize));
4119821f1d3SAlan Somers 		}, Eq(true)),
4129821f1d3SAlan Somers 		_)
41329edc611SAlan Somers 	).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
4149821f1d3SAlan Somers 		SET_OUT_HEADER_LEN(out, write);
41529edc611SAlan Somers 		out.body.write.size = osize;
4169821f1d3SAlan Somers 	})));
4179821f1d3SAlan Somers }
4189821f1d3SAlan Somers 
41916bd2d47SAlan Somers void FuseTest::expect_write_7_8(uint64_t ino, uint64_t offset, uint64_t isize,
420bda39894SAlan Somers 	uint64_t osize, const void *contents)
42116bd2d47SAlan Somers {
42216bd2d47SAlan Somers 	EXPECT_CALL(*m_mock, process(
42316bd2d47SAlan Somers 		ResultOf([=](auto in) {
42429edc611SAlan Somers 			const char *buf = (const char*)in.body.bytes +
42516bd2d47SAlan Somers 				FUSE_COMPAT_WRITE_IN_SIZE;
42629edc611SAlan Somers 			bool pid_ok = (pid_t)in.header.pid == getpid();
42729edc611SAlan Somers 			return (in.header.opcode == FUSE_WRITE &&
42829edc611SAlan Somers 				in.header.nodeid == ino &&
42929edc611SAlan Somers 				in.body.write.fh == FH &&
43029edc611SAlan Somers 				in.body.write.offset == offset  &&
43129edc611SAlan Somers 				in.body.write.size == isize &&
43216bd2d47SAlan Somers 				pid_ok &&
43316bd2d47SAlan Somers 				0 == bcmp(buf, contents, isize));
43416bd2d47SAlan Somers 		}, Eq(true)),
43516bd2d47SAlan Somers 		_)
43629edc611SAlan Somers 	).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
43716bd2d47SAlan Somers 		SET_OUT_HEADER_LEN(out, write);
43829edc611SAlan Somers 		out.body.write.size = osize;
43916bd2d47SAlan Somers 	})));
44016bd2d47SAlan Somers }
44116bd2d47SAlan Somers 
44261b0a927SAlan Somers void
44361b0a927SAlan Somers get_unprivileged_id(uid_t *uid, gid_t *gid)
44409c01e67SAlan Somers {
44509c01e67SAlan Somers 	struct passwd *pw;
44661b0a927SAlan Somers 	struct group *gr;
44709c01e67SAlan Somers 
44809c01e67SAlan Somers 	/*
44909c01e67SAlan Somers 	 * First try "tests", Kyua's default unprivileged user.  XXX after
45009c01e67SAlan Somers 	 * GoogleTest gains a proper Kyua wrapper, get this with the Kyua API
45109c01e67SAlan Somers 	 */
45209c01e67SAlan Somers 	pw = getpwnam("tests");
45309c01e67SAlan Somers 	if (pw == NULL) {
45409c01e67SAlan Somers 		/* Fall back to "nobody" */
45509c01e67SAlan Somers 		pw = getpwnam("nobody");
45609c01e67SAlan Somers 	}
45709c01e67SAlan Somers 	if (pw == NULL)
45809c01e67SAlan Somers 		GTEST_SKIP() << "Test requires an unprivileged user";
45961b0a927SAlan Somers 	/* Use group "nobody", which is Kyua's default unprivileged group */
46061b0a927SAlan Somers 	gr = getgrnam("nobody");
46161b0a927SAlan Somers 	if (gr == NULL)
46261b0a927SAlan Somers 		GTEST_SKIP() << "Test requires an unprivileged group";
46309c01e67SAlan Somers 	*uid = pw->pw_uid;
46461b0a927SAlan Somers 	*gid = gr->gr_gid;
46509c01e67SAlan Somers }
46609c01e67SAlan Somers 
46709c01e67SAlan Somers void
468a1542146SAlan Somers FuseTest::fork(bool drop_privs, int *child_status,
469a1542146SAlan Somers 	std::function<void()> parent_func,
47009c01e67SAlan Somers 	std::function<int()> child_func)
47109c01e67SAlan Somers {
47209c01e67SAlan Somers 	sem_t *sem;
47309c01e67SAlan Somers 	int mprot = PROT_READ | PROT_WRITE;
47409c01e67SAlan Somers 	int mflags = MAP_ANON | MAP_SHARED;
47509c01e67SAlan Somers 	pid_t child;
47609c01e67SAlan Somers 	uid_t uid;
47761b0a927SAlan Somers 	gid_t gid;
47809c01e67SAlan Somers 
47909c01e67SAlan Somers 	if (drop_privs) {
48061b0a927SAlan Somers 		get_unprivileged_id(&uid, &gid);
48109c01e67SAlan Somers 		if (IsSkipped())
48209c01e67SAlan Somers 			return;
48309c01e67SAlan Somers 	}
48409c01e67SAlan Somers 
48509c01e67SAlan Somers 	sem = (sem_t*)mmap(NULL, sizeof(*sem), mprot, mflags, -1, 0);
48609c01e67SAlan Somers 	ASSERT_NE(MAP_FAILED, sem) << strerror(errno);
48709c01e67SAlan Somers 	ASSERT_EQ(0, sem_init(sem, 1, 0)) << strerror(errno);
48809c01e67SAlan Somers 
48909c01e67SAlan Somers 	if ((child = ::fork()) == 0) {
49009c01e67SAlan Somers 		/* In child */
49109c01e67SAlan Somers 		int err = 0;
49209c01e67SAlan Somers 
49309c01e67SAlan Somers 		if (sem_wait(sem)) {
49409c01e67SAlan Somers 			perror("sem_wait");
49509c01e67SAlan Somers 			err = 1;
49609c01e67SAlan Somers 			goto out;
49709c01e67SAlan Somers 		}
49809c01e67SAlan Somers 
49961b0a927SAlan Somers 		if (drop_privs && 0 != setegid(gid)) {
50061b0a927SAlan Somers 			perror("setegid");
50161b0a927SAlan Somers 			err = 1;
50261b0a927SAlan Somers 			goto out;
50361b0a927SAlan Somers 		}
50409c01e67SAlan Somers 		if (drop_privs && 0 != setreuid(-1, uid)) {
50509c01e67SAlan Somers 			perror("setreuid");
50609c01e67SAlan Somers 			err = 1;
50709c01e67SAlan Somers 			goto out;
50809c01e67SAlan Somers 		}
50909c01e67SAlan Somers 		err = child_func();
51009c01e67SAlan Somers 
51109c01e67SAlan Somers out:
51209c01e67SAlan Somers 		sem_destroy(sem);
51309c01e67SAlan Somers 		_exit(err);
51409c01e67SAlan Somers 	} else if (child > 0) {
51509c01e67SAlan Somers 		/*
51609c01e67SAlan Somers 		 * In parent.  Cleanup must happen here, because it's still
51709c01e67SAlan Somers 		 * privileged.
51809c01e67SAlan Somers 		 */
51909c01e67SAlan Somers 		m_mock->m_child_pid = child;
52009c01e67SAlan Somers 		ASSERT_NO_FATAL_FAILURE(parent_func());
52109c01e67SAlan Somers 
52209c01e67SAlan Somers 		/* Signal the child process to go */
52309c01e67SAlan Somers 		ASSERT_EQ(0, sem_post(sem)) << strerror(errno);
52409c01e67SAlan Somers 
525a1542146SAlan Somers 		ASSERT_LE(0, wait(child_status)) << strerror(errno);
52609c01e67SAlan Somers 	} else {
52709c01e67SAlan Somers 		FAIL() << strerror(errno);
52809c01e67SAlan Somers 	}
52909c01e67SAlan Somers 	munmap(sem, sizeof(*sem));
530a1542146SAlan Somers 	return;
53109c01e67SAlan Somers }
53209c01e67SAlan Somers 
5339821f1d3SAlan Somers static void usage(char* progname) {
5349821f1d3SAlan Somers 	fprintf(stderr, "Usage: %s [-v]\n\t-v increase verbosity\n", progname);
5359821f1d3SAlan Somers 	exit(2);
5369821f1d3SAlan Somers }
5379821f1d3SAlan Somers 
5389821f1d3SAlan Somers int main(int argc, char **argv) {
5399821f1d3SAlan Somers 	int ch;
5409821f1d3SAlan Somers 	FuseEnv *fuse_env = new FuseEnv;
5419821f1d3SAlan Somers 
5429821f1d3SAlan Somers 	InitGoogleTest(&argc, argv);
5439821f1d3SAlan Somers 	AddGlobalTestEnvironment(fuse_env);
5449821f1d3SAlan Somers 
5459821f1d3SAlan Somers 	while ((ch = getopt(argc, argv, "v")) != -1) {
5469821f1d3SAlan Somers 		switch (ch) {
5479821f1d3SAlan Somers 			case 'v':
5489821f1d3SAlan Somers 				verbosity++;
5499821f1d3SAlan Somers 				break;
5509821f1d3SAlan Somers 			default:
5519821f1d3SAlan Somers 				usage(argv[0]);
5529821f1d3SAlan Somers 				break;
5539821f1d3SAlan Somers 		}
5549821f1d3SAlan Somers 	}
5559821f1d3SAlan Somers 
5569821f1d3SAlan Somers 	return (RUN_ALL_TESTS());
5579821f1d3SAlan Somers }
558