1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2019 The FreeBSD Foundation 5 * 6 * This software was developed by BFF Storage Systems, LLC under sponsorship 7 * from the FreeBSD Foundation. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 extern "C" { 32 #include <dirent.h> 33 34 #include <fcntl.h> 35 #include <semaphore.h> 36 } 37 38 #include "mockfs.hh" 39 #include "utils.hh" 40 41 using namespace testing; 42 43 class Opendir: public FuseTest { 44 public: 45 void expect_lookup(const char *relpath, uint64_t ino) 46 { 47 FuseTest::expect_lookup(relpath, ino, S_IFDIR | 0755, 0, 1); 48 } 49 50 void expect_opendir(uint64_t ino, uint32_t flags, ProcessMockerT r) 51 { 52 /* opendir(3) calls fstatfs */ 53 EXPECT_CALL(*m_mock, process( 54 ResultOf([](auto in) { 55 return (in.header.opcode == FUSE_STATFS); 56 }, Eq(true)), 57 _) 58 ).WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) { 59 SET_OUT_HEADER_LEN(out, statfs); 60 }))); 61 62 EXPECT_CALL(*m_mock, process( 63 ResultOf([=](auto in) { 64 return (in.header.opcode == FUSE_OPENDIR && 65 in.header.nodeid == ino && 66 in.body.opendir.flags == flags); 67 }, Eq(true)), 68 _) 69 ).WillOnce(Invoke(r)); 70 } 71 72 }; 73 74 75 /* 76 * The fuse daemon fails the request with enoent. This usually indicates a 77 * race condition: some other FUSE client removed the file in between when the 78 * kernel checked for it with lookup and tried to open it 79 */ 80 TEST_F(Opendir, enoent) 81 { 82 const char FULLPATH[] = "mountpoint/some_dir"; 83 const char RELPATH[] = "some_dir"; 84 uint64_t ino = 42; 85 sem_t sem; 86 87 ASSERT_EQ(0, sem_init(&sem, 0, 0)) << strerror(errno); 88 89 expect_lookup(RELPATH, ino); 90 expect_opendir(ino, O_RDONLY, ReturnErrno(ENOENT)); 91 // Since FUSE_OPENDIR returns ENOENT, the kernel will reclaim the vnode 92 // and send a FUSE_FORGET 93 expect_forget(ino, 1, &sem); 94 95 ASSERT_EQ(-1, open(FULLPATH, O_DIRECTORY)); 96 EXPECT_EQ(ENOENT, errno); 97 98 sem_wait(&sem); 99 sem_destroy(&sem); 100 } 101 102 /* 103 * The daemon is responsible for checking file permissions (unless the 104 * default_permissions mount option was used) 105 */ 106 TEST_F(Opendir, eperm) 107 { 108 const char FULLPATH[] = "mountpoint/some_dir"; 109 const char RELPATH[] = "some_dir"; 110 uint64_t ino = 42; 111 112 expect_lookup(RELPATH, ino); 113 expect_opendir(ino, O_RDONLY, ReturnErrno(EPERM)); 114 115 EXPECT_EQ(-1, open(FULLPATH, O_DIRECTORY)); 116 EXPECT_EQ(EPERM, errno); 117 } 118 119 TEST_F(Opendir, open) 120 { 121 const char FULLPATH[] = "mountpoint/some_dir"; 122 const char RELPATH[] = "some_dir"; 123 uint64_t ino = 42; 124 int fd; 125 126 expect_lookup(RELPATH, ino); 127 expect_opendir(ino, O_RDONLY, 128 ReturnImmediate([=](auto in __unused, auto& out) { 129 SET_OUT_HEADER_LEN(out, open); 130 })); 131 132 fd = open(FULLPATH, O_DIRECTORY); 133 ASSERT_LE(0, fd) << strerror(errno); 134 135 leak(fd); 136 } 137 138 /* Directories can be opened O_EXEC for stuff like fchdir(2) */ 139 TEST_F(Opendir, open_exec) 140 { 141 const char FULLPATH[] = "mountpoint/some_dir"; 142 const char RELPATH[] = "some_dir"; 143 uint64_t ino = 42; 144 int fd; 145 146 expect_lookup(RELPATH, ino); 147 expect_opendir(ino, O_EXEC, 148 ReturnImmediate([=](auto in __unused, auto& out) { 149 SET_OUT_HEADER_LEN(out, open); 150 })); 151 152 fd = open(FULLPATH, O_EXEC | O_DIRECTORY); 153 ASSERT_LE(0, fd) << strerror(errno); 154 155 leak(fd); 156 } 157 158 TEST_F(Opendir, opendir) 159 { 160 const char FULLPATH[] = "mountpoint/some_dir"; 161 const char RELPATH[] = "some_dir"; 162 uint64_t ino = 42; 163 164 expect_lookup(RELPATH, ino); 165 expect_opendir(ino, O_RDONLY, 166 ReturnImmediate([=](auto in __unused, auto& out) { 167 SET_OUT_HEADER_LEN(out, open); 168 })); 169 170 errno = 0; 171 EXPECT_NE(nullptr, opendir(FULLPATH)) << strerror(errno); 172 } 173 174 /* 175 * If a fuse server returns ENOSYS to a 176 * FUSE_OPENDIR, then it and subsequent FUSE_OPENDIR and FUSE_RELEASEDIR 177 * operations will also succeed automatically without being sent to the server. 178 */ 179 TEST_F(Opendir, enosys) 180 { 181 const char FULLPATH[] = "mountpoint/some_file.txt"; 182 const char RELPATH[] = "some_file.txt"; 183 uint64_t ino = 42; 184 int fd; 185 186 FuseTest::expect_lookup(RELPATH, ino, S_IFDIR | 0755, 0, 2); 187 expect_opendir(ino, O_RDONLY, ReturnErrno(ENOSYS)); 188 189 fd = open(FULLPATH, O_DIRECTORY); 190 ASSERT_LE(0, fd) << strerror(errno); 191 close(fd); 192 193 fd = open(FULLPATH, O_DIRECTORY); 194 ASSERT_LE(0, fd) << strerror(errno); 195 196 leak(fd); 197 } 198