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