xref: /freebsd/tests/sys/fs/fusefs/io.cc (revision 9768746b)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
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  * $FreeBSD$
31  */
32 
33 extern "C" {
34 #include <sys/types.h>
35 #include <sys/mman.h>
36 #include <sys/sysctl.h>
37 
38 #include <fcntl.h>
39 #include <stdlib.h>
40 #include <unistd.h>
41 }
42 
43 #include "mockfs.hh"
44 #include "utils.hh"
45 
46 /*
47  * For testing I/O like fsx does, but deterministically and without a real
48  * underlying file system
49  */
50 
51 using namespace testing;
52 
53 const char FULLPATH[] = "mountpoint/some_file.txt";
54 const char RELPATH[] = "some_file.txt";
55 const uint64_t ino = 42;
56 
57 static void compare(const void *tbuf, const void *controlbuf, off_t baseofs,
58 	ssize_t size)
59 {
60 	int i;
61 
62 	for (i = 0; i < size; i++) {
63 		if (((const char*)tbuf)[i] != ((const char*)controlbuf)[i]) {
64 			off_t ofs = baseofs + i;
65 			FAIL() << "miscompare at offset "
66 			       << std::hex
67 			       << std::showbase
68 			       << ofs
69 			       << ".  expected = "
70 			       << std::setw(2)
71 			       << (unsigned)((const uint8_t*)controlbuf)[i]
72 			       << " got = "
73 			       << (unsigned)((const uint8_t*)tbuf)[i];
74 		}
75 	}
76 }
77 
78 typedef tuple<bool, uint32_t, cache_mode> IoParam;
79 
80 class Io: public FuseTest, public WithParamInterface<IoParam> {
81 public:
82 int m_backing_fd, m_control_fd, m_test_fd;
83 off_t m_filesize;
84 bool m_direct_io;
85 
86 Io(): m_backing_fd(-1), m_control_fd(-1), m_test_fd(-1), m_filesize(0),
87 	m_direct_io(false) {};
88 
89 void SetUp()
90 {
91 	m_backing_fd = open("backing_file", O_RDWR | O_CREAT | O_TRUNC, 0644);
92 	if (m_backing_fd < 0)
93 		FAIL() << strerror(errno);
94 	m_control_fd = open("control", O_RDWR | O_CREAT | O_TRUNC, 0644);
95 	if (m_control_fd < 0)
96 		FAIL() << strerror(errno);
97 	srandom(22'9'1982);	// Seed with my birthday
98 
99 	if (get<0>(GetParam()))
100 		m_init_flags |= FUSE_ASYNC_READ;
101 	m_maxwrite = get<1>(GetParam());
102 	switch (get<2>(GetParam())) {
103 		case Uncached:
104 			m_direct_io = true;
105 			break;
106 		case WritebackAsync:
107 			m_async = true;
108 			/* FALLTHROUGH */
109 		case Writeback:
110 			m_init_flags |= FUSE_WRITEBACK_CACHE;
111 			/* FALLTHROUGH */
112 		case Writethrough:
113 			break;
114 		default:
115 			FAIL() << "Unknown cache mode";
116 	}
117 	m_noatime = true;	// To prevent SETATTR for atime on close
118 
119 	FuseTest::SetUp();
120 	if (IsSkipped())
121 		return;
122 
123 	if (verbosity > 0) {
124 		printf("Test Parameters: init_flags=%#x maxwrite=%#x "
125 		    "%sasync cache=%s\n",
126 		    m_init_flags, m_maxwrite, m_async? "" : "no",
127 		    cache_mode_to_s(get<2>(GetParam())));
128 	}
129 
130 	expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 1);
131 	expect_open(ino, m_direct_io ? FOPEN_DIRECT_IO : 0, 1);
132 	EXPECT_CALL(*m_mock, process(
133 		ResultOf([=](auto in) {
134 			return (in.header.opcode == FUSE_WRITE &&
135 				in.header.nodeid == ino);
136 		}, Eq(true)),
137 		_)
138 	).WillRepeatedly(Invoke(ReturnImmediate([=](auto in, auto& out) {
139 		const char *buf = (const char*)in.body.bytes +
140 			sizeof(struct fuse_write_in);
141 		ssize_t isize = in.body.write.size;
142 		off_t iofs = in.body.write.offset;
143 
144 		ASSERT_EQ(isize, pwrite(m_backing_fd, buf, isize, iofs))
145 			<< strerror(errno);
146 		SET_OUT_HEADER_LEN(out, write);
147 		out.body.write.size = isize;
148 	})));
149 	EXPECT_CALL(*m_mock, process(
150 		ResultOf([=](auto in) {
151 			return (in.header.opcode == FUSE_READ &&
152 				in.header.nodeid == ino);
153 		}, Eq(true)),
154 		_)
155 	).WillRepeatedly(Invoke(ReturnImmediate([=](auto in, auto& out) {
156 		ssize_t isize = in.body.write.size;
157 		off_t iofs = in.body.write.offset;
158 		void *buf = out.body.bytes;
159 		ssize_t osize;
160 
161 		osize = pread(m_backing_fd, buf, isize, iofs);
162 		ASSERT_LE(0, osize) << strerror(errno);
163 		out.header.len = sizeof(struct fuse_out_header) + osize;
164 	})));
165 	EXPECT_CALL(*m_mock, process(
166 		ResultOf([=](auto in) {
167 			return (in.header.opcode == FUSE_SETATTR &&
168 				in.header.nodeid == ino &&
169 				(in.body.setattr.valid & FATTR_SIZE));
170 
171 		}, Eq(true)),
172 		_)
173 	).WillRepeatedly(Invoke(ReturnImmediate([=](auto in, auto& out) {
174 		ASSERT_EQ(0, ftruncate(m_backing_fd, in.body.setattr.size))
175 			<< strerror(errno);
176 		SET_OUT_HEADER_LEN(out, attr);
177 		out.body.attr.attr.ino = ino;
178 		out.body.attr.attr.mode = S_IFREG | 0755;
179 		out.body.attr.attr.size = in.body.setattr.size;
180 		out.body.attr.attr_valid = UINT64_MAX;
181 	})));
182 	/* Any test that close()s will send FUSE_FLUSH and FUSE_RELEASE */
183 	EXPECT_CALL(*m_mock, process(
184 		ResultOf([=](auto in) {
185 			return (in.header.opcode == FUSE_FLUSH &&
186 				in.header.nodeid == ino);
187 		}, Eq(true)),
188 		_)
189 	).WillRepeatedly(Invoke(ReturnErrno(0)));
190 	EXPECT_CALL(*m_mock, process(
191 		ResultOf([=](auto in) {
192 			return (in.header.opcode == FUSE_RELEASE &&
193 				in.header.nodeid == ino);
194 		}, Eq(true)),
195 		_)
196 	).WillRepeatedly(Invoke(ReturnErrno(0)));
197 
198 	m_test_fd = open(FULLPATH, O_RDWR );
199 	EXPECT_LE(0, m_test_fd) << strerror(errno);
200 }
201 
202 void TearDown()
203 {
204 	if (m_test_fd >= 0)
205 		close(m_test_fd);
206 	if (m_backing_fd >= 0)
207 		close(m_backing_fd);
208 	if (m_control_fd >= 0)
209 		close(m_control_fd);
210 	FuseTest::TearDown();
211 	leak(m_test_fd);
212 }
213 
214 void do_closeopen()
215 {
216 	ASSERT_EQ(0, close(m_test_fd)) << strerror(errno);
217 	m_test_fd = open("backing_file", O_RDWR);
218 	ASSERT_LE(0, m_test_fd) << strerror(errno);
219 
220 	ASSERT_EQ(0, close(m_control_fd)) << strerror(errno);
221 	m_control_fd = open("control", O_RDWR);
222 	ASSERT_LE(0, m_control_fd) << strerror(errno);
223 }
224 
225 void do_ftruncate(off_t offs)
226 {
227 	ASSERT_EQ(0, ftruncate(m_test_fd, offs)) << strerror(errno);
228 	ASSERT_EQ(0, ftruncate(m_control_fd, offs)) << strerror(errno);
229 	m_filesize = offs;
230 }
231 
232 void do_mapread(ssize_t size, off_t offs)
233 {
234 	void *control_buf, *p;
235 	off_t pg_offset, page_mask;
236 	size_t map_size;
237 
238 	page_mask = getpagesize() - 1;
239 	pg_offset = offs & page_mask;
240 	map_size = pg_offset + size;
241 
242 	p = mmap(NULL, map_size, PROT_READ, MAP_FILE | MAP_SHARED, m_test_fd,
243 	    offs - pg_offset);
244 	ASSERT_NE(p, MAP_FAILED) << strerror(errno);
245 
246 	control_buf = malloc(size);
247 	ASSERT_NE(nullptr, control_buf) << strerror(errno);
248 
249 	ASSERT_EQ(size, pread(m_control_fd, control_buf, size, offs))
250 		<< strerror(errno);
251 
252 	compare((void*)((char*)p + pg_offset), control_buf, offs, size);
253 
254 	ASSERT_EQ(0, munmap(p, map_size)) << strerror(errno);
255 	free(control_buf);
256 }
257 
258 void do_read(ssize_t size, off_t offs)
259 {
260 	void *test_buf, *control_buf;
261 	ssize_t r;
262 
263 	test_buf = malloc(size);
264 	ASSERT_NE(nullptr, test_buf) << strerror(errno);
265 	control_buf = malloc(size);
266 	ASSERT_NE(nullptr, control_buf) << strerror(errno);
267 
268 	errno = 0;
269 	r = pread(m_test_fd, test_buf, size, offs);
270 	ASSERT_NE(-1, r) << strerror(errno);
271 	ASSERT_EQ(size, r) << "unexpected short read";
272 	r = pread(m_control_fd, control_buf, size, offs);
273 	ASSERT_NE(-1, r) << strerror(errno);
274 	ASSERT_EQ(size, r) << "unexpected short read";
275 
276 	compare(test_buf, control_buf, offs, size);
277 
278 	free(control_buf);
279 	free(test_buf);
280 }
281 
282 void do_mapwrite(ssize_t size, off_t offs)
283 {
284 	char *buf;
285 	void *p;
286 	off_t pg_offset, page_mask;
287 	size_t map_size;
288 	long i;
289 
290 	page_mask = getpagesize() - 1;
291 	pg_offset = offs & page_mask;
292 	map_size = pg_offset + size;
293 
294 	buf = (char*)malloc(size);
295 	ASSERT_NE(nullptr, buf) << strerror(errno);
296 	for (i=0; i < size; i++)
297 		buf[i] = random();
298 
299 	if (offs + size > m_filesize) {
300 		/*
301 		 * Must manually extend.  vm_mmap_vnode will not implicitly
302 		 * extend a vnode
303 		 */
304 		do_ftruncate(offs + size);
305 	}
306 
307 	p = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
308 	    MAP_FILE | MAP_SHARED, m_test_fd, offs - pg_offset);
309 	ASSERT_NE(p, MAP_FAILED) << strerror(errno);
310 
311 	bcopy(buf, (char*)p + pg_offset, size);
312 	ASSERT_EQ(size, pwrite(m_control_fd, buf, size, offs))
313 		<< strerror(errno);
314 
315 	free(buf);
316 	ASSERT_EQ(0, munmap(p, map_size)) << strerror(errno);
317 }
318 
319 void do_write(ssize_t size, off_t offs)
320 {
321 	char *buf;
322 	long i;
323 
324 	buf = (char*)malloc(size);
325 	ASSERT_NE(nullptr, buf) << strerror(errno);
326 	for (i=0; i < size; i++)
327 		buf[i] = random();
328 
329 	ASSERT_EQ(size, pwrite(m_test_fd, buf, size, offs ))
330 		<< strerror(errno);
331 	ASSERT_EQ(size, pwrite(m_control_fd, buf, size, offs))
332 		<< strerror(errno);
333 	m_filesize = std::max(m_filesize, offs + size);
334 
335 	free(buf);
336 }
337 
338 };
339 
340 class IoCacheable: public Io {
341 public:
342 virtual void SetUp() {
343 	Io::SetUp();
344 }
345 };
346 
347 /*
348  * Extend a file with dirty data in the last page of the last block.
349  *
350  * fsx -WR -P /tmp -S8 -N3 fsx.bin
351  */
352 TEST_P(Io, extend_from_dirty_page)
353 {
354 	off_t wofs = 0x21a0;
355 	ssize_t wsize = 0xf0a8;
356 	off_t rofs = 0xb284;
357 	ssize_t rsize = 0x9b22;
358 	off_t truncsize = 0x28702;
359 
360 	do_write(wsize, wofs);
361 	do_ftruncate(truncsize);
362 	do_read(rsize, rofs);
363 }
364 
365 /*
366  * mapwrite into a newly extended part of a file.
367  *
368  * fsx -c 100 -i 100 -l 524288 -o 131072 -N5 -P /tmp -S19 fsx.bin
369  */
370 TEST_P(IoCacheable, extend_by_mapwrite)
371 {
372 	do_mapwrite(0x849e, 0x29a3a);	/* [0x29a3a, 0x31ed7] */
373 	do_mapwrite(0x3994, 0x3c7d8);	/* [0x3c7d8, 0x4016b] */
374 	do_read(0xf556, 0x30c16);	/* [0x30c16, 0x4016b] */
375 }
376 
377 /*
378  * When writing the last page of a file, it must be written synchronously.
379  * Otherwise the cached page can become invalid by a subsequent extend
380  * operation.
381  *
382  * fsx -WR -P /tmp -S642 -N3 fsx.bin
383  */
384 TEST_P(Io, last_page)
385 {
386 	do_write(0xcc77, 0x1134f);	/* [0x1134f, 0x1dfc5] */
387 	do_write(0xdfa7, 0x2096a);	/* [0x2096a, 0x2e910] */
388 	do_read(0xb5b7, 0x1a3aa);	/* [0x1a3aa, 0x25960] */
389 }
390 
391 /*
392  * Read a hole using mmap
393  *
394  * fsx -c 100 -i 100 -l 524288 -o 131072 -N11 -P /tmp  -S14 fsx.bin
395  */
396 TEST_P(IoCacheable, mapread_hole)
397 {
398 	do_write(0x123b7, 0xf205);	/* [0xf205, 0x215bb] */
399 	do_mapread(0xeeea, 0x2f4c);	/* [0x2f4c, 0x11e35] */
400 }
401 
402 /*
403  * Read a hole from a block that contains some cached data.
404  *
405  * fsx -WR -P /tmp -S55  fsx.bin
406  */
407 TEST_P(Io, read_hole_from_cached_block)
408 {
409 	off_t wofs = 0x160c5;
410 	ssize_t wsize = 0xa996;
411 	off_t rofs = 0x472e;
412 	ssize_t rsize = 0xd8d5;
413 
414 	do_write(wsize, wofs);
415 	do_read(rsize, rofs);
416 }
417 
418 /*
419  * Truncating a file into a dirty buffer should not causing anything untoward
420  * to happen when that buffer is eventually flushed.
421  *
422  * fsx -WR -P /tmp -S839 -d -N6 fsx.bin
423  */
424 TEST_P(Io, truncate_into_dirty_buffer)
425 {
426 	off_t wofs0 = 0x3bad7;
427 	ssize_t wsize0 = 0x4529;
428 	off_t wofs1 = 0xc30d;
429 	ssize_t wsize1 = 0x5f77;
430 	off_t truncsize0 = 0x10916;
431 	off_t rofs = 0xdf17;
432 	ssize_t rsize = 0x29ff;
433 	off_t truncsize1 = 0x152b4;
434 
435 	do_write(wsize0, wofs0);
436 	do_write(wsize1, wofs1);
437 	do_ftruncate(truncsize0);
438 	do_read(rsize, rofs);
439 	do_ftruncate(truncsize1);
440 	close(m_test_fd);
441 }
442 
443 /*
444  * Truncating a file into a dirty buffer should not causing anything untoward
445  * to happen when that buffer is eventually flushed, even when the buffer's
446  * dirty_off is > 0.
447  *
448  * Based on this command with a few steps removed:
449  * fsx -WR -P /tmp -S677 -d -N8 fsx.bin
450  */
451 TEST_P(Io, truncate_into_dirty_buffer2)
452 {
453 	off_t truncsize0 = 0x344f3;
454 	off_t wofs = 0x2790c;
455 	ssize_t wsize = 0xd86a;
456 	off_t truncsize1 = 0x2de38;
457 	off_t rofs2 = 0x1fd7a;
458 	ssize_t rsize2 = 0xc594;
459 	off_t truncsize2 = 0x31e71;
460 
461 	/* Sets the file size to something larger than the next write */
462 	do_ftruncate(truncsize0);
463 	/*
464 	 * Creates a dirty buffer.  The part in lbn 2 doesn't flush
465 	 * synchronously.
466 	 */
467 	do_write(wsize, wofs);
468 	/* Truncates part of the dirty buffer created in step 2 */
469 	do_ftruncate(truncsize1);
470 	/* XXX ?I don't know why this is necessary? */
471 	do_read(rsize2, rofs2);
472 	/* Truncates the dirty buffer */
473 	do_ftruncate(truncsize2);
474 	close(m_test_fd);
475 }
476 
477 /*
478  * Regression test for a bug introduced in r348931
479  *
480  * Sequence of operations:
481  * 1) The first write reads lbn so it can modify it
482  * 2) The first write flushes lbn 3 immediately because it's the end of file
483  * 3) The first write then flushes lbn 4 because it's the end of the file
484  * 4) The second write modifies the cached versions of lbn 3 and 4
485  * 5) The third write's getblkx invalidates lbn 4's B_CACHE because it's
486  *    extending the buffer.  Then it flushes lbn 4 because B_DELWRI was set but
487  *    B_CACHE was clear.
488  * 6) fuse_write_biobackend erroneously called vfs_bio_clrbuf, putting the
489  *    buffer into a weird write-only state.  All read operations would return
490  *    0.  Writes were apparently still processed, because the buffer's contents
491  *    were correct when examined in a core dump.
492  * 7) The third write reads lbn 4 because cache is clear
493  * 9) uiomove dutifully copies new data into the buffer
494  * 10) The buffer's dirty is flushed to lbn 4
495  * 11) The read returns all zeros because of step 6.
496  *
497  * Based on:
498  * fsx -WR -l 524388 -o 131072 -P /tmp -S6456 -q  fsx.bin
499  */
500 TEST_P(Io, resize_a_valid_buffer_while_extending)
501 {
502 	do_write(0x14530, 0x36ee6);	/* [0x36ee6, 0x4b415] */
503 	do_write(0x1507c, 0x33256);	/* [0x33256, 0x482d1] */
504 	do_write(0x175c, 0x4c03d);	/* [0x4c03d, 0x4d798] */
505 	do_read(0xe277, 0x3599c);	/* [0x3599c, 0x43c12] */
506 	close(m_test_fd);
507 }
508 
509 INSTANTIATE_TEST_CASE_P(Io, Io,
510 	Combine(Bool(),					/* async read */
511 		Values(0x1000, 0x10000, 0x20000),	/* m_maxwrite */
512 		Values(Uncached, Writethrough, Writeback, WritebackAsync)
513 	)
514 );
515 
516 INSTANTIATE_TEST_CASE_P(Io, IoCacheable,
517 	Combine(Bool(),					/* async read */
518 		Values(0x1000, 0x10000, 0x20000),	/* m_maxwrite */
519 		Values(Writethrough, Writeback, WritebackAsync)
520 	)
521 );
522