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 3809c01e67SAlan Somers #include <pwd.h> 3909c01e67SAlan Somers #include <semaphore.h> 4009c01e67SAlan Somers #include <unistd.h> 4109c01e67SAlan Somers } 429821f1d3SAlan Somers 439821f1d3SAlan Somers #include <gtest/gtest.h> 449821f1d3SAlan Somers 459821f1d3SAlan Somers #include "mockfs.hh" 469821f1d3SAlan Somers #include "utils.hh" 479821f1d3SAlan Somers 489821f1d3SAlan Somers using namespace testing; 499821f1d3SAlan Somers 509821f1d3SAlan Somers /* Check that fusefs(4) is accessible and the current user can mount(2) */ 519821f1d3SAlan Somers void check_environment() 529821f1d3SAlan Somers { 539821f1d3SAlan Somers const char *devnode = "/dev/fuse"; 549821f1d3SAlan Somers const char *usermount_node = "vfs.usermount"; 559821f1d3SAlan Somers int usermount_val = 0; 569821f1d3SAlan Somers size_t usermount_size = sizeof(usermount_val); 579821f1d3SAlan Somers if (eaccess(devnode, R_OK | W_OK)) { 589821f1d3SAlan Somers if (errno == ENOENT) { 599821f1d3SAlan Somers GTEST_SKIP() << devnode << " does not exist"; 609821f1d3SAlan Somers } else if (errno == EACCES) { 619821f1d3SAlan Somers GTEST_SKIP() << devnode << 629821f1d3SAlan Somers " is not accessible by the current user"; 639821f1d3SAlan Somers } else { 649821f1d3SAlan Somers GTEST_SKIP() << strerror(errno); 659821f1d3SAlan Somers } 669821f1d3SAlan Somers } 679821f1d3SAlan Somers sysctlbyname(usermount_node, &usermount_val, &usermount_size, 689821f1d3SAlan Somers NULL, 0); 699821f1d3SAlan Somers if (geteuid() != 0 && !usermount_val) 709821f1d3SAlan Somers GTEST_SKIP() << "current user is not allowed to mount"; 719821f1d3SAlan Somers } 729821f1d3SAlan Somers 739821f1d3SAlan Somers class FuseEnv: public Environment { 749821f1d3SAlan Somers virtual void SetUp() { 759821f1d3SAlan Somers } 769821f1d3SAlan Somers }; 779821f1d3SAlan Somers 789821f1d3SAlan Somers void FuseTest::SetUp() { 799821f1d3SAlan Somers const char *node = "vfs.maxbcachebuf"; 809821f1d3SAlan Somers int val = 0; 819821f1d3SAlan Somers size_t size = sizeof(val); 829821f1d3SAlan Somers 839821f1d3SAlan Somers /* 849821f1d3SAlan Somers * XXX check_environment should be called from FuseEnv::SetUp, but 859821f1d3SAlan Somers * can't due to https://github.com/google/googletest/issues/2189 869821f1d3SAlan Somers */ 879821f1d3SAlan Somers check_environment(); 889821f1d3SAlan Somers if (IsSkipped()) 899821f1d3SAlan Somers return; 909821f1d3SAlan Somers 919821f1d3SAlan Somers ASSERT_EQ(0, sysctlbyname(node, &val, &size, NULL, 0)) 929821f1d3SAlan Somers << strerror(errno); 939821f1d3SAlan Somers m_maxbcachebuf = val; 949821f1d3SAlan Somers 959821f1d3SAlan Somers try { 9691ff3a0dSAlan Somers m_mock = new MockFS(m_maxreadahead, m_allow_other, 9791ff3a0dSAlan Somers m_default_permissions, m_push_symlinks_in, 9891ff3a0dSAlan Somers m_init_flags); 999821f1d3SAlan Somers } catch (std::system_error err) { 1009821f1d3SAlan Somers FAIL() << err.what(); 1019821f1d3SAlan Somers } 1029821f1d3SAlan Somers } 1039821f1d3SAlan Somers 10491ff3a0dSAlan Somers void 10591ff3a0dSAlan Somers FuseTest::expect_access(uint64_t ino, mode_t access_mode, int error) 10691ff3a0dSAlan Somers { 10791ff3a0dSAlan Somers EXPECT_CALL(*m_mock, process( 10891ff3a0dSAlan Somers ResultOf([=](auto in) { 10991ff3a0dSAlan Somers return (in->header.opcode == FUSE_ACCESS && 11091ff3a0dSAlan Somers in->header.nodeid == ino && 11191ff3a0dSAlan Somers in->body.access.mask == access_mode); 11291ff3a0dSAlan Somers }, Eq(true)), 11391ff3a0dSAlan Somers _) 11491ff3a0dSAlan Somers ).WillOnce(Invoke(ReturnErrno(error))); 11591ff3a0dSAlan Somers } 11691ff3a0dSAlan Somers 1179821f1d3SAlan Somers void FuseTest::expect_getattr(uint64_t ino, uint64_t size) 1189821f1d3SAlan Somers { 1199821f1d3SAlan Somers /* Until the attr cache is working, we may send an additional GETATTR */ 1209821f1d3SAlan Somers EXPECT_CALL(*m_mock, process( 1219821f1d3SAlan Somers ResultOf([=](auto in) { 1229821f1d3SAlan Somers return (in->header.opcode == FUSE_GETATTR && 1239821f1d3SAlan Somers in->header.nodeid == ino); 1249821f1d3SAlan Somers }, Eq(true)), 1259821f1d3SAlan Somers _) 1269821f1d3SAlan Somers ).WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { 1279821f1d3SAlan Somers SET_OUT_HEADER_LEN(out, attr); 1289821f1d3SAlan Somers out->body.attr.attr.ino = ino; // Must match nodeid 1299821f1d3SAlan Somers out->body.attr.attr.mode = S_IFREG | 0644; 1309821f1d3SAlan Somers out->body.attr.attr.size = size; 1319821f1d3SAlan Somers out->body.attr.attr_valid = UINT64_MAX; 1329821f1d3SAlan Somers }))); 1339821f1d3SAlan Somers } 1349821f1d3SAlan Somers 1359821f1d3SAlan Somers void FuseTest::expect_lookup(const char *relpath, uint64_t ino, mode_t mode, 1369821f1d3SAlan Somers uint64_t size, int times) 1379821f1d3SAlan Somers { 1389821f1d3SAlan Somers EXPECT_LOOKUP(1, relpath) 1399821f1d3SAlan Somers .Times(times) 1409821f1d3SAlan Somers .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { 1419821f1d3SAlan Somers SET_OUT_HEADER_LEN(out, entry); 1429821f1d3SAlan Somers out->body.entry.attr.mode = mode; 1439821f1d3SAlan Somers out->body.entry.nodeid = ino; 1449821f1d3SAlan Somers out->body.entry.attr.nlink = 1; 1459821f1d3SAlan Somers out->body.entry.attr_valid = UINT64_MAX; 1469821f1d3SAlan Somers out->body.entry.attr.size = size; 1479821f1d3SAlan Somers }))); 1489821f1d3SAlan Somers } 1499821f1d3SAlan Somers 1509821f1d3SAlan Somers void FuseTest::expect_open(uint64_t ino, uint32_t flags, int times) 1519821f1d3SAlan Somers { 1529821f1d3SAlan Somers EXPECT_CALL(*m_mock, process( 1539821f1d3SAlan Somers ResultOf([=](auto in) { 1549821f1d3SAlan Somers return (in->header.opcode == FUSE_OPEN && 1559821f1d3SAlan Somers in->header.nodeid == ino); 1569821f1d3SAlan Somers }, Eq(true)), 1579821f1d3SAlan Somers _) 1589821f1d3SAlan Somers ).Times(times) 1599821f1d3SAlan Somers .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto out) { 1609821f1d3SAlan Somers out->header.len = sizeof(out->header); 1619821f1d3SAlan Somers SET_OUT_HEADER_LEN(out, open); 1629821f1d3SAlan Somers out->body.open.fh = FH; 1639821f1d3SAlan Somers out->body.open.open_flags = flags; 1649821f1d3SAlan Somers }))); 1659821f1d3SAlan Somers } 1669821f1d3SAlan Somers 1679821f1d3SAlan Somers void FuseTest::expect_opendir(uint64_t ino) 1689821f1d3SAlan Somers { 169*363a7416SAlan Somers /* opendir(3) calls fstatfs */ 1709821f1d3SAlan Somers EXPECT_CALL(*m_mock, process( 1719821f1d3SAlan Somers ResultOf([](auto in) { 1729821f1d3SAlan Somers return (in->header.opcode == FUSE_STATFS); 1739821f1d3SAlan Somers }, Eq(true)), 1749821f1d3SAlan Somers _) 1759821f1d3SAlan Somers ).WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto out) { 1769821f1d3SAlan Somers SET_OUT_HEADER_LEN(out, statfs); 1779821f1d3SAlan Somers }))); 1789821f1d3SAlan Somers 1799821f1d3SAlan Somers EXPECT_CALL(*m_mock, process( 1809821f1d3SAlan Somers ResultOf([=](auto in) { 1819821f1d3SAlan Somers return (in->header.opcode == FUSE_OPENDIR && 1829821f1d3SAlan Somers in->header.nodeid == ino); 1839821f1d3SAlan Somers }, Eq(true)), 1849821f1d3SAlan Somers _) 1859821f1d3SAlan Somers ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { 1869821f1d3SAlan Somers out->header.len = sizeof(out->header); 1879821f1d3SAlan Somers SET_OUT_HEADER_LEN(out, open); 1889821f1d3SAlan Somers out->body.open.fh = FH; 1899821f1d3SAlan Somers }))); 1909821f1d3SAlan Somers } 1919821f1d3SAlan Somers 1929821f1d3SAlan Somers void FuseTest::expect_read(uint64_t ino, uint64_t offset, uint64_t isize, 1939821f1d3SAlan Somers uint64_t osize, const void *contents) 1949821f1d3SAlan Somers { 1959821f1d3SAlan Somers EXPECT_CALL(*m_mock, process( 1969821f1d3SAlan Somers ResultOf([=](auto in) { 1979821f1d3SAlan Somers return (in->header.opcode == FUSE_READ && 1989821f1d3SAlan Somers in->header.nodeid == ino && 1999821f1d3SAlan Somers in->body.read.fh == FH && 2009821f1d3SAlan Somers in->body.read.offset == offset && 2019821f1d3SAlan Somers in->body.read.size == isize); 2029821f1d3SAlan Somers }, Eq(true)), 2039821f1d3SAlan Somers _) 2049821f1d3SAlan Somers ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { 2059821f1d3SAlan Somers out->header.len = sizeof(struct fuse_out_header) + osize; 2069821f1d3SAlan Somers memmove(out->body.bytes, contents, osize); 2079821f1d3SAlan Somers }))).RetiresOnSaturation(); 2089821f1d3SAlan Somers } 2099821f1d3SAlan Somers 21042d50d16SAlan Somers void FuseTest::expect_release(uint64_t ino, uint64_t fh) 2119821f1d3SAlan Somers { 2129821f1d3SAlan Somers EXPECT_CALL(*m_mock, process( 2139821f1d3SAlan Somers ResultOf([=](auto in) { 2149821f1d3SAlan Somers return (in->header.opcode == FUSE_RELEASE && 2159821f1d3SAlan Somers in->header.nodeid == ino && 21642d50d16SAlan Somers in->body.release.fh == fh); 2179821f1d3SAlan Somers }, Eq(true)), 2189821f1d3SAlan Somers _) 219e0bec057SAlan Somers ).WillOnce(Invoke(ReturnErrno(0))); 2209821f1d3SAlan Somers } 221e0bec057SAlan Somers 2229821f1d3SAlan Somers void FuseTest::expect_write(uint64_t ino, uint64_t offset, uint64_t isize, 2239821f1d3SAlan Somers uint64_t osize, uint32_t flags, const void *contents) 2249821f1d3SAlan Somers { 2259821f1d3SAlan Somers EXPECT_CALL(*m_mock, process( 2269821f1d3SAlan Somers ResultOf([=](auto in) { 2279821f1d3SAlan Somers const char *buf = (const char*)in->body.bytes + 2289821f1d3SAlan Somers sizeof(struct fuse_write_in); 2299821f1d3SAlan Somers bool pid_ok; 2309821f1d3SAlan Somers 2319821f1d3SAlan Somers if (in->body.write.write_flags & FUSE_WRITE_CACHE) 2329821f1d3SAlan Somers pid_ok = true; 2339821f1d3SAlan Somers else 2349821f1d3SAlan Somers pid_ok = (pid_t)in->header.pid == getpid(); 2359821f1d3SAlan Somers 2369821f1d3SAlan Somers return (in->header.opcode == FUSE_WRITE && 2379821f1d3SAlan Somers in->header.nodeid == ino && 2389821f1d3SAlan Somers in->body.write.fh == FH && 2399821f1d3SAlan Somers in->body.write.offset == offset && 2409821f1d3SAlan Somers in->body.write.size == isize && 2419821f1d3SAlan Somers pid_ok && 2429821f1d3SAlan Somers in->body.write.write_flags == flags && 2439821f1d3SAlan Somers 0 == bcmp(buf, contents, isize)); 2449821f1d3SAlan Somers }, Eq(true)), 2459821f1d3SAlan Somers _) 2469821f1d3SAlan Somers ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto out) { 2479821f1d3SAlan Somers SET_OUT_HEADER_LEN(out, write); 2489821f1d3SAlan Somers out->body.write.size = osize; 2499821f1d3SAlan Somers }))); 2509821f1d3SAlan Somers } 2519821f1d3SAlan Somers 25209c01e67SAlan Somers static void 25309c01e67SAlan Somers get_unprivileged_uid(uid_t *uid) 25409c01e67SAlan Somers { 25509c01e67SAlan Somers struct passwd *pw; 25609c01e67SAlan Somers 25709c01e67SAlan Somers /* 25809c01e67SAlan Somers * First try "tests", Kyua's default unprivileged user. XXX after 25909c01e67SAlan Somers * GoogleTest gains a proper Kyua wrapper, get this with the Kyua API 26009c01e67SAlan Somers */ 26109c01e67SAlan Somers pw = getpwnam("tests"); 26209c01e67SAlan Somers if (pw == NULL) { 26309c01e67SAlan Somers /* Fall back to "nobody" */ 26409c01e67SAlan Somers pw = getpwnam("nobody"); 26509c01e67SAlan Somers } 26609c01e67SAlan Somers if (pw == NULL) 26709c01e67SAlan Somers GTEST_SKIP() << "Test requires an unprivileged user"; 26809c01e67SAlan Somers *uid = pw->pw_uid; 26909c01e67SAlan Somers } 27009c01e67SAlan Somers 27109c01e67SAlan Somers void 27209c01e67SAlan Somers FuseTest::fork(bool drop_privs, std::function<void()> parent_func, 27309c01e67SAlan Somers std::function<int()> child_func) 27409c01e67SAlan Somers { 27509c01e67SAlan Somers sem_t *sem; 27609c01e67SAlan Somers int mprot = PROT_READ | PROT_WRITE; 27709c01e67SAlan Somers int mflags = MAP_ANON | MAP_SHARED; 27809c01e67SAlan Somers pid_t child; 27909c01e67SAlan Somers uid_t uid; 28009c01e67SAlan Somers 28109c01e67SAlan Somers if (drop_privs) { 28209c01e67SAlan Somers get_unprivileged_uid(&uid); 28309c01e67SAlan Somers if (IsSkipped()) 28409c01e67SAlan Somers return; 28509c01e67SAlan Somers } 28609c01e67SAlan Somers 28709c01e67SAlan Somers sem = (sem_t*)mmap(NULL, sizeof(*sem), mprot, mflags, -1, 0); 28809c01e67SAlan Somers ASSERT_NE(MAP_FAILED, sem) << strerror(errno); 28909c01e67SAlan Somers ASSERT_EQ(0, sem_init(sem, 1, 0)) << strerror(errno); 29009c01e67SAlan Somers 29109c01e67SAlan Somers if ((child = ::fork()) == 0) { 29209c01e67SAlan Somers /* In child */ 29309c01e67SAlan Somers int err = 0; 29409c01e67SAlan Somers 29509c01e67SAlan Somers if (sem_wait(sem)) { 29609c01e67SAlan Somers perror("sem_wait"); 29709c01e67SAlan Somers err = 1; 29809c01e67SAlan Somers goto out; 29909c01e67SAlan Somers } 30009c01e67SAlan Somers 30109c01e67SAlan Somers if (drop_privs && 0 != setreuid(-1, uid)) { 30209c01e67SAlan Somers perror("setreuid"); 30309c01e67SAlan Somers err = 1; 30409c01e67SAlan Somers goto out; 30509c01e67SAlan Somers } 30609c01e67SAlan Somers err = child_func(); 30709c01e67SAlan Somers 30809c01e67SAlan Somers out: 30909c01e67SAlan Somers sem_destroy(sem); 31009c01e67SAlan Somers _exit(err); 31109c01e67SAlan Somers } else if (child > 0) { 31209c01e67SAlan Somers int child_status; 31309c01e67SAlan Somers 31409c01e67SAlan Somers /* 31509c01e67SAlan Somers * In parent. Cleanup must happen here, because it's still 31609c01e67SAlan Somers * privileged. 31709c01e67SAlan Somers */ 31809c01e67SAlan Somers m_mock->m_child_pid = child; 31909c01e67SAlan Somers ASSERT_NO_FATAL_FAILURE(parent_func()); 32009c01e67SAlan Somers 32109c01e67SAlan Somers /* Signal the child process to go */ 32209c01e67SAlan Somers ASSERT_EQ(0, sem_post(sem)) << strerror(errno); 32309c01e67SAlan Somers 32409c01e67SAlan Somers wait(&child_status); 32509c01e67SAlan Somers ASSERT_EQ(0, WEXITSTATUS(child_status)); 32609c01e67SAlan Somers } else { 32709c01e67SAlan Somers FAIL() << strerror(errno); 32809c01e67SAlan Somers } 32909c01e67SAlan Somers munmap(sem, sizeof(*sem)); 33009c01e67SAlan Somers } 33109c01e67SAlan Somers 3329821f1d3SAlan Somers static void usage(char* progname) { 3339821f1d3SAlan Somers fprintf(stderr, "Usage: %s [-v]\n\t-v increase verbosity\n", progname); 3349821f1d3SAlan Somers exit(2); 3359821f1d3SAlan Somers } 3369821f1d3SAlan Somers 3379821f1d3SAlan Somers int main(int argc, char **argv) { 3389821f1d3SAlan Somers int ch; 3399821f1d3SAlan Somers FuseEnv *fuse_env = new FuseEnv; 3409821f1d3SAlan Somers 3419821f1d3SAlan Somers InitGoogleTest(&argc, argv); 3429821f1d3SAlan Somers AddGlobalTestEnvironment(fuse_env); 3439821f1d3SAlan Somers 3449821f1d3SAlan Somers while ((ch = getopt(argc, argv, "v")) != -1) { 3459821f1d3SAlan Somers switch (ch) { 3469821f1d3SAlan Somers case 'v': 3479821f1d3SAlan Somers verbosity++; 3489821f1d3SAlan Somers break; 3499821f1d3SAlan Somers default: 3509821f1d3SAlan Somers usage(argv[0]); 3519821f1d3SAlan Somers break; 3529821f1d3SAlan Somers } 3539821f1d3SAlan Somers } 3549821f1d3SAlan Somers 3559821f1d3SAlan Somers return (RUN_ALL_TESTS()); 3569821f1d3SAlan Somers } 357