2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2019 The FreeBSD Foundation
6 * This software was developed by BFF Storage Systems, LLC under sponsorship
7 * from the FreeBSD Foundation.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
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.
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
40 using namespace testing;
42 class Mkdir: public FuseTest {};
43 class Mkdir_7_8: public FuseTest {
45 virtual void SetUp() {
46 m_kernel_minor_version = 8;
52 * EMLINK is possible on filesystems that limit the number of hard links to a
53 * single file, like early versions of BtrFS
57 const char FULLPATH[] = "mountpoint/some_dir";
58 const char RELPATH[] = "some_dir";
61 EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
62 .WillOnce(Invoke(ReturnErrno(ENOENT)));
64 EXPECT_CALL(*m_mock, process(
65 ResultOf([=](auto in) {
66 const char *name = (const char*)in.body.bytes +
67 sizeof(fuse_mkdir_in);
68 return (in.header.opcode == FUSE_MKDIR &&
69 in.body.mkdir.mode == (S_IFDIR | mode) &&
70 (0 == strcmp(RELPATH, name)));
73 ).WillOnce(Invoke(ReturnErrno(EMLINK)));
75 ASSERT_NE(1, mkdir(FULLPATH, mode));
76 ASSERT_EQ(EMLINK, errno);
80 * Creating a new directory after FUSE_LOOKUP returned a negative cache entry
82 TEST_F(Mkdir, entry_cache_negative)
84 const char FULLPATH[] = "mountpoint/some_file.txt";
85 const char RELPATH[] = "some_file.txt";
89 * Set entry_valid = 0 because this test isn't concerned with whether
90 * or not we actually cache negative entries, only with whether we
91 * interpret negative cache responses correctly.
93 struct timespec entry_valid = {.tv_sec = 0, .tv_nsec = 0};
95 /* mkdir will first do a LOOKUP, adding a negative cache entry */
96 EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
97 .WillOnce(ReturnNegativeCache(&entry_valid));
99 EXPECT_CALL(*m_mock, process(
100 ResultOf([=](auto in) {
101 const char *name = (const char*)in.body.bytes +
102 sizeof(fuse_open_in);
103 return (in.header.opcode == FUSE_MKDIR &&
104 in.body.mkdir.mode == (S_IFDIR | mode) &&
105 (0 == strcmp(RELPATH, name)));
108 ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
109 SET_OUT_HEADER_LEN(out, entry);
110 out.body.create.entry.attr.mode = S_IFDIR | mode;
111 out.body.create.entry.nodeid = ino;
112 out.body.create.entry.entry_valid = UINT64_MAX;
113 out.body.create.entry.attr_valid = UINT64_MAX;
116 ASSERT_EQ(0, mkdir(FULLPATH, mode)) << strerror(errno);
120 * Creating a new directory should purge any negative namecache entries
122 TEST_F(Mkdir, entry_cache_negative_purge)
124 const char FULLPATH[] = "mountpoint/some_file.txt";
125 const char RELPATH[] = "some_file.txt";
128 struct timespec entry_valid = {.tv_sec = TIME_T_MAX, .tv_nsec = 0};
130 /* mkdir will first do a LOOKUP, adding a negative cache entry */
131 EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
133 .WillOnce(Invoke(ReturnNegativeCache(&entry_valid)))
134 .RetiresOnSaturation();
136 /* Then the MKDIR should purge the negative cache entry */
137 EXPECT_CALL(*m_mock, process(
138 ResultOf([=](auto in) {
139 const char *name = (const char*)in.body.bytes +
140 sizeof(fuse_open_in);
141 return (in.header.opcode == FUSE_MKDIR &&
142 in.body.mkdir.mode == (S_IFDIR | mode) &&
143 (0 == strcmp(RELPATH, name)));
146 ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
147 SET_OUT_HEADER_LEN(out, entry);
148 out.body.entry.attr.mode = S_IFDIR | mode;
149 out.body.entry.nodeid = ino;
150 out.body.entry.attr_valid = UINT64_MAX;
153 ASSERT_EQ(0, mkdir(FULLPATH, mode)) << strerror(errno);
155 /* Finally, a subsequent lookup should query the daemon */
156 expect_lookup(RELPATH, ino, S_IFDIR | mode, 0, 1);
158 ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
163 const char FULLPATH[] = "mountpoint/some_dir";
164 const char RELPATH[] = "some_dir";
172 EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
173 .WillOnce(Invoke(ReturnErrno(ENOENT)));
175 EXPECT_CALL(*m_mock, process(
176 ResultOf([=](auto in) {
177 const char *name = (const char*)in.body.bytes +
178 sizeof(fuse_mkdir_in);
179 return (in.header.opcode == FUSE_MKDIR &&
180 in.body.mkdir.mode == (S_IFDIR | mode) &&
181 in.body.mkdir.umask == mask &&
182 (0 == strcmp(RELPATH, name)));
185 ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
186 SET_OUT_HEADER_LEN(out, entry);
187 out.body.create.entry.attr.mode = S_IFDIR | mode;
188 out.body.create.entry.nodeid = ino;
189 out.body.create.entry.entry_valid = UINT64_MAX;
190 out.body.create.entry.attr_valid = UINT64_MAX;
193 ASSERT_EQ(0, mkdir(FULLPATH, mode)) << strerror(errno);
197 * Nothing bad should happen if the server returns the parent's inode number
198 * for the newly created directory. Regression test for bug 263662.
199 * https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=263662
201 TEST_F(Mkdir, parent_inode)
203 const char FULLPATH[] = "mountpoint/parent/some_dir";
204 const char PPATH[] = "parent";
205 const char RELPATH[] = "some_dir";
213 expect_lookup(PPATH, ino, S_IFDIR | 0755, 0, 1);
214 EXPECT_LOOKUP(ino, RELPATH)
215 .WillOnce(Invoke(ReturnErrno(ENOENT)));
217 EXPECT_CALL(*m_mock, process(
218 ResultOf([=](auto in) {
219 const char *name = (const char*)in.body.bytes +
220 sizeof(fuse_mkdir_in);
221 return (in.header.opcode == FUSE_MKDIR &&
222 in.body.mkdir.mode == (S_IFDIR | mode) &&
223 in.body.mkdir.umask == mask &&
224 (0 == strcmp(RELPATH, name)));
227 ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
228 SET_OUT_HEADER_LEN(out, entry);
229 out.body.create.entry.attr.mode = S_IFDIR | mode;
230 out.body.create.entry.nodeid = ino;
231 out.body.create.entry.entry_valid = UINT64_MAX;
232 out.body.create.entry.attr_valid = UINT64_MAX;
234 // FUSE_FORGET happens asynchronously, so it may or may not arrive
235 // before the test completes.
236 EXPECT_CALL(*m_mock, process(
237 ResultOf([=](auto in) {
238 return (in.header.opcode == FUSE_FORGET);
242 .WillOnce(Invoke([=](auto in __unused, auto &out __unused) { }));
244 ASSERT_EQ(-1, mkdir(FULLPATH, mode));
245 ASSERT_EQ(EIO, errno);
249 TEST_F(Mkdir_7_8, ok)
251 const char FULLPATH[] = "mountpoint/some_dir";
252 const char RELPATH[] = "some_dir";
256 EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
257 .WillOnce(Invoke(ReturnErrno(ENOENT)));
259 EXPECT_CALL(*m_mock, process(
260 ResultOf([=](auto in) {
261 const char *name = (const char*)in.body.bytes +
262 sizeof(fuse_mkdir_in);
263 return (in.header.opcode == FUSE_MKDIR &&
264 in.body.mkdir.mode == (S_IFDIR | mode) &&
265 (0 == strcmp(RELPATH, name)));
268 ).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
269 SET_OUT_HEADER_LEN(out, entry_7_8);
270 out.body.create.entry.attr.mode = S_IFDIR | mode;
271 out.body.create.entry.nodeid = ino;
272 out.body.create.entry.entry_valid = UINT64_MAX;
273 out.body.create.entry.attr_valid = UINT64_MAX;
276 ASSERT_EQ(0, mkdir(FULLPATH, mode)) << strerror(errno);