1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2020 Alan Somers
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD$
28 */
29
30 extern "C" {
31 #include <sys/param.h>
32 #include <fcntl.h>
33 }
34
35 #include "mockfs.hh"
36 #include "utils.hh"
37
38 /*
39 * Tests for thorny cache problems not specific to any one opcode
40 */
41
42 using namespace testing;
43
44 /*
45 * Parameters
46 * - reopen file - If true, close and reopen the file between reads
47 * - cache lookups - If true, allow lookups to be cached
48 * - cache attrs - If true, allow file attributes to be cached
49 * - cache_mode - uncached, writeback, or writethrough
50 * - initial size - File size before truncation
51 * - truncated size - File size after truncation
52 */
53 typedef tuple<tuple<bool, bool, bool>, cache_mode, ssize_t, ssize_t> CacheParam;
54
55 class Cache: public FuseTest, public WithParamInterface<CacheParam> {
56 public:
57 bool m_direct_io;
58
Cache()59 Cache(): m_direct_io(false) {};
60
SetUp()61 virtual void SetUp() {
62 int cache_mode = get<1>(GetParam());
63 switch (cache_mode) {
64 case Uncached:
65 m_direct_io = true;
66 break;
67 case WritebackAsync:
68 m_async = true;
69 /* FALLTHROUGH */
70 case Writeback:
71 m_init_flags |= FUSE_WRITEBACK_CACHE;
72 /* FALLTHROUGH */
73 case Writethrough:
74 break;
75 default:
76 FAIL() << "Unknown cache mode";
77 }
78 m_noatime = true; // To prevent SETATTR for atime on close
79
80 FuseTest::SetUp();
81 if (IsSkipped())
82 return;
83 }
84
expect_getattr(uint64_t ino,int times,uint64_t size,uint64_t attr_valid)85 void expect_getattr(uint64_t ino, int times, uint64_t size, uint64_t attr_valid)
86 {
87 EXPECT_CALL(*m_mock, process(
88 ResultOf([=](auto in) {
89 return (in.header.opcode == FUSE_GETATTR &&
90 in.header.nodeid == ino);
91 }, Eq(true)),
92 _)
93 ).Times(times)
94 .WillRepeatedly(Invoke(ReturnImmediate([=](auto i __unused, auto& out) {
95 SET_OUT_HEADER_LEN(out, attr);
96 out.body.attr.attr_valid = attr_valid;
97 out.body.attr.attr.ino = ino;
98 out.body.attr.attr.mode = S_IFREG | 0644;
99 out.body.attr.attr.size = size;
100 })));
101 }
102
expect_lookup(const char * relpath,uint64_t ino,uint64_t size,uint64_t entry_valid,uint64_t attr_valid)103 void expect_lookup(const char *relpath, uint64_t ino,
104 uint64_t size, uint64_t entry_valid, uint64_t attr_valid)
105 {
106 EXPECT_LOOKUP(FUSE_ROOT_ID, relpath)
107 .WillRepeatedly(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
108 SET_OUT_HEADER_LEN(out, entry);
109 out.body.entry.attr.mode = S_IFREG | 0644;
110 out.body.entry.nodeid = ino;
111 out.body.entry.attr.nlink = 1;
112 out.body.entry.attr_valid = attr_valid;
113 out.body.entry.attr.size = size;
114 out.body.entry.entry_valid = entry_valid;
115 })));
116 }
117
expect_open(uint64_t ino,int times)118 void expect_open(uint64_t ino, int times)
119 {
120 FuseTest::expect_open(ino, m_direct_io ? FOPEN_DIRECT_IO: 0, times);
121 }
122
expect_release(uint64_t ino,ProcessMockerT r)123 void expect_release(uint64_t ino, ProcessMockerT r)
124 {
125 EXPECT_CALL(*m_mock, process(
126 ResultOf([=](auto in) {
127 return (in.header.opcode == FUSE_RELEASE &&
128 in.header.nodeid == ino);
129 }, Eq(true)),
130 _)
131 ).WillRepeatedly(Invoke(r));
132 }
133
134 };
135
136 // If the server truncates the file behind the kernel's back, the kernel should
137 // invalidate cached pages beyond the new EOF
TEST_P(Cache,truncate_by_surprise_invalidates_cache)138 TEST_P(Cache, truncate_by_surprise_invalidates_cache)
139 {
140 const char FULLPATH[] = "mountpoint/some_file.txt";
141 const char RELPATH[] = "some_file.txt";
142 const char *CONTENTS = "abcdefghijklmnopqrstuvwxyz";
143 uint64_t ino = 42;
144 uint64_t attr_valid, entry_valid;
145 int fd;
146 ssize_t bufsize = strlen(CONTENTS);
147 uint8_t buf[bufsize];
148 bool reopen = get<0>(get<0>(GetParam()));
149 bool cache_lookups = get<1>(get<0>(GetParam()));
150 bool cache_attrs = get<2>(get<0>(GetParam()));
151 ssize_t osize = get<2>(GetParam());
152 ssize_t nsize = get<3>(GetParam());
153
154 ASSERT_LE(osize, bufsize);
155 ASSERT_LE(nsize, bufsize);
156 if (cache_attrs)
157 attr_valid = UINT64_MAX;
158 else
159 attr_valid = 0;
160 if (cache_lookups)
161 entry_valid = UINT64_MAX;
162 else
163 entry_valid = 0;
164
165 expect_lookup(RELPATH, ino, osize, entry_valid, attr_valid);
166 expect_open(ino, 1);
167 if (!cache_attrs)
168 expect_getattr(ino, 2, osize, attr_valid);
169 expect_read(ino, 0, osize, osize, CONTENTS);
170
171 fd = open(FULLPATH, O_RDONLY);
172 ASSERT_LE(0, fd) << strerror(errno);
173
174 ASSERT_EQ(osize, read(fd, buf, bufsize)) << strerror(errno);
175 ASSERT_EQ(0, memcmp(buf, CONTENTS, osize));
176
177 // Now truncate the file behind the kernel's back. The next read
178 // should discard cache and fetch from disk again.
179 if (reopen) {
180 // Close and reopen the file
181 expect_flush(ino, 1, ReturnErrno(ENOSYS));
182 expect_release(ino, ReturnErrno(0));
183 ASSERT_EQ(0, close(fd));
184 expect_lookup(RELPATH, ino, nsize, entry_valid, attr_valid);
185 expect_open(ino, 1);
186 fd = open(FULLPATH, O_RDONLY);
187 ASSERT_LE(0, fd) << strerror(errno);
188 }
189
190 if (!cache_attrs)
191 expect_getattr(ino, 1, nsize, attr_valid);
192 expect_read(ino, 0, nsize, nsize, CONTENTS);
193 ASSERT_EQ(0, lseek(fd, 0, SEEK_SET));
194 ASSERT_EQ(nsize, read(fd, buf, bufsize)) << strerror(errno);
195 ASSERT_EQ(0, memcmp(buf, CONTENTS, nsize));
196
197 leak(fd);
198 }
199
200 INSTANTIATE_TEST_CASE_P(Cache, Cache,
201 Combine(
202 /* Test every combination that:
203 * - does not cache at least one of entries and attrs
204 * - either doesn't cache attrs, or reopens the file
205 * In the other combinations, the kernel will never learn that
206 * the file's size has changed.
207 */
208 Values(
209 std::make_tuple(false, false, false),
210 std::make_tuple(false, true, false),
211 std::make_tuple(true, false, false),
212 std::make_tuple(true, false, true),
213 std::make_tuple(true, true, false)
214 ),
215 Values(Writethrough, Writeback),
216 /* Test both reductions and extensions to file size */
217 Values(20),
218 Values(10, 25)
219 )
220 );
221