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
33extern "C" {
34#include <sys/types.h>
35
36#include <pthread.h>
37
38#include "fuse_kernel.h"
39}
40
41#include <gmock/gmock.h>
42
43#define TIME_T_MAX (std::numeric_limits<time_t>::max())
44
45/*
46 * A pseudo-fuse errno used indicate that a fuse operation should have no
47 * response, at least not immediately
48 */
49#define FUSE_NORESPONSE 9999
50
51#define SET_OUT_HEADER_LEN(out, variant) { \
52	(out).header.len = (sizeof((out).header) + \
53			    sizeof((out).body.variant)); \
54}
55
56/*
57 * Create an expectation on FUSE_LOOKUP and return it so the caller can set
58 * actions.
59 *
60 * This must be a macro instead of a method because EXPECT_CALL returns a type
61 * with a deleted constructor.
62 */
63#define EXPECT_LOOKUP(parent, path)					\
64	EXPECT_CALL(*m_mock, process(					\
65		ResultOf([=](auto in) {					\
66			return (in.header.opcode == FUSE_LOOKUP &&	\
67				in.header.nodeid == (parent) &&	\
68				strcmp(in.body.lookup, (path)) == 0);	\
69		}, Eq(true)),						\
70		_)							\
71	)
72
73extern int verbosity;
74
75/*
76 * The maximum that a test case can set max_write, limited by the buffer
77 * supplied when reading from /dev/fuse.  This limitation is imposed by
78 * fusefs-libs, but not by the FUSE protocol.
79 */
80const uint32_t max_max_write = 0x20000;
81
82
83/* This struct isn't defined by fuse_kernel.h or libfuse, but it should be */
84struct fuse_create_out {
85	struct fuse_entry_out	entry;
86	struct fuse_open_out	open;
87};
88
89/* Protocol 7.8 version of struct fuse_attr */
90struct fuse_attr_7_8
91{
92	uint64_t	ino;
93	uint64_t	size;
94	uint64_t	blocks;
95	uint64_t	atime;
96	uint64_t	mtime;
97	uint64_t	ctime;
98	uint32_t	atimensec;
99	uint32_t	mtimensec;
100	uint32_t	ctimensec;
101	uint32_t	mode;
102	uint32_t	nlink;
103	uint32_t	uid;
104	uint32_t	gid;
105	uint32_t	rdev;
106};
107
108/* Protocol 7.8 version of struct fuse_attr_out */
109struct fuse_attr_out_7_8
110{
111	uint64_t	attr_valid;
112	uint32_t	attr_valid_nsec;
113	uint32_t	dummy;
114	struct fuse_attr_7_8 attr;
115};
116
117/* Protocol 7.8 version of struct fuse_entry_out */
118struct fuse_entry_out_7_8 {
119	uint64_t	nodeid;		/* Inode ID */
120	uint64_t	generation;	/* Inode generation: nodeid:gen must
121				   be unique for the fs's lifetime */
122	uint64_t	entry_valid;	/* Cache timeout for the name */
123	uint64_t	attr_valid;	/* Cache timeout for the attributes */
124	uint32_t	entry_valid_nsec;
125	uint32_t	attr_valid_nsec;
126	struct fuse_attr_7_8 attr;
127};
128
129/* Output struct for FUSE_CREATE for protocol 7.8 servers */
130struct fuse_create_out_7_8 {
131	struct fuse_entry_out_7_8	entry;
132	struct fuse_open_out	open;
133};
134
135/* Output struct for FUSE_INIT for protocol 7.22 and earlier servers */
136struct fuse_init_out_7_22 {
137	uint32_t	major;
138	uint32_t	minor;
139	uint32_t	max_readahead;
140	uint32_t	flags;
141	uint16_t	max_background;
142	uint16_t	congestion_threshold;
143	uint32_t	max_write;
144};
145
146union fuse_payloads_in {
147	fuse_access_in	access;
148	fuse_bmap_in	bmap;
149	/*
150	 * In fusefs-libs 3.4.2 and below the buffer size is fixed at 0x21000
151	 * minus the header sizes.  fusefs-libs 3.4.3 (and FUSE Protocol 7.29)
152	 * add a FUSE_MAX_PAGES option that allows it to be greater.
153	 *
154	 * See fuse_kern_chan.c in fusefs-libs 2.9.9 and below, or
155	 * FUSE_DEFAULT_MAX_PAGES_PER_REQ in fusefs-libs 3.4.3 and above.
156	 */
157	uint8_t		bytes[
158	    max_max_write + 0x1000 - sizeof(struct fuse_in_header)
159	];
160	fuse_copy_file_range_in	copy_file_range;
161	fuse_create_in	create;
162	fuse_flush_in	flush;
163	fuse_fsync_in	fsync;
164	fuse_fsync_in	fsyncdir;
165	fuse_forget_in	forget;
166	fuse_getattr_in	getattr;
167	fuse_interrupt_in interrupt;
168	fuse_lk_in	getlk;
169	fuse_getxattr_in getxattr;
170	fuse_init_in	init;
171	fuse_link_in	link;
172	fuse_listxattr_in listxattr;
173	char		lookup[0];
174	fuse_lseek_in	lseek;
175	fuse_mkdir_in	mkdir;
176	fuse_mknod_in	mknod;
177	fuse_open_in	open;
178	fuse_open_in	opendir;
179	fuse_read_in	read;
180	fuse_read_in	readdir;
181	fuse_release_in	release;
182	fuse_release_in	releasedir;
183	fuse_rename_in	rename;
184	char		rmdir[0];
185	fuse_setattr_in	setattr;
186	fuse_setxattr_in setxattr;
187	fuse_lk_in	setlk;
188	fuse_lk_in	setlkw;
189	char		unlink[0];
190	fuse_write_in	write;
191};
192
193struct mockfs_buf_in {
194	fuse_in_header		header;
195	union fuse_payloads_in	body;
196};
197
198union fuse_payloads_out {
199	fuse_attr_out		attr;
200	fuse_attr_out_7_8	attr_7_8;
201	fuse_bmap_out		bmap;
202	fuse_create_out		create;
203	fuse_create_out_7_8	create_7_8;
204	/*
205	 * The protocol places no limits on the size of bytes.  Choose
206	 * a size big enough for anything we'll test.
207	 */
208	uint8_t			bytes[0x20000];
209	fuse_entry_out		entry;
210	fuse_entry_out_7_8	entry_7_8;
211	fuse_lk_out		getlk;
212	fuse_getxattr_out	getxattr;
213	fuse_init_out		init;
214	fuse_init_out_7_22	init_7_22;
215	fuse_lseek_out		lseek;
216	/* The inval_entry structure should be followed by the entry's name */
217	fuse_notify_inval_entry_out	inval_entry;
218	fuse_notify_inval_inode_out	inval_inode;
219	/* The store structure should be followed by the data to store */
220	fuse_notify_store_out		store;
221	fuse_listxattr_out	listxattr;
222	fuse_open_out		open;
223	fuse_statfs_out		statfs;
224	/*
225	 * The protocol places no limits on the length of the string.  This is
226	 * merely convenient for testing.
227	 */
228	char			str[80];
229	fuse_write_out		write;
230};
231
232struct mockfs_buf_out {
233	fuse_out_header		header;
234	union fuse_payloads_out	body;
235
236	/* Default constructor: zero everything */
237	mockfs_buf_out() {
238		memset(this, 0, sizeof(*this));
239	}
240};
241
242/* A function that can be invoked in place of MockFS::process */
243typedef std::function<void (const mockfs_buf_in& in,
244			    std::vector<std::unique_ptr<mockfs_buf_out>> &out)>
245ProcessMockerT;
246
247/*
248 * Helper function used for setting an error expectation for any fuse operation.
249 * The operation will return the supplied error
250 */
251ProcessMockerT ReturnErrno(int error);
252
253/* Helper function used for returning negative cache entries for LOOKUP */
254ProcessMockerT ReturnNegativeCache(const struct timespec *entry_valid);
255
256/* Helper function used for returning a single immediate response */
257ProcessMockerT ReturnImmediate(
258	std::function<void(const mockfs_buf_in& in,
259			   struct mockfs_buf_out &out)> f);
260
261/* How the daemon should check /dev/fuse for readiness */
262enum poll_method {
263	BLOCKING,
264	SELECT,
265	POLL,
266	KQ
267};
268
269/*
270 * Fake FUSE filesystem
271 *
272 * "Mounts" a filesystem to a temporary directory and services requests
273 * according to the programmed expectations.
274 *
275 * Operates directly on the fusefs(4) kernel API, not the libfuse(3) user api.
276 */
277class MockFS {
278	/*
279	 * thread id of the fuse daemon thread
280	 *
281	 * It must run in a separate thread so it doesn't deadlock with the
282	 * client test code.
283	 */
284	pthread_t m_daemon_id;
285
286	/* file descriptor of /dev/fuse control device */
287	int m_fuse_fd;
288
289	/* The minor version of the kernel API that this mock daemon targets */
290	uint32_t m_kernel_minor_version;
291
292	int m_kq;
293
294	/* The max_readahead file system option */
295	uint32_t m_maxreadahead;
296
297	/* pid of the test process */
298	pid_t m_pid;
299
300	/* Method the daemon should use for I/O to and from /dev/fuse */
301	enum poll_method m_pm;
302
303	/* Timestamp granularity in nanoseconds */
304	unsigned m_time_gran;
305
306	void audit_request(const mockfs_buf_in &in, ssize_t buflen);
307	void debug_request(const mockfs_buf_in&, ssize_t buflen);
308	void debug_response(const mockfs_buf_out&);
309
310	/* Initialize a session after mounting */
311	void init(uint32_t flags);
312
313	/* Is pid from a process that might be involved in the test? */
314	bool pid_ok(pid_t pid);
315
316	/* Default request handler */
317	void process_default(const mockfs_buf_in&,
318		std::vector<std::unique_ptr<mockfs_buf_out>>&);
319
320	/* Entry point for the daemon thread */
321	static void* service(void*);
322
323	/*
324	 * Read, but do not process, a single request from the kernel
325	 *
326	 * @param in	Return storage for the FUSE request
327	 * @param res	Return value of read(2).  If positive, the amount of
328	 *		data read from the fuse device.
329	 */
330	void read_request(mockfs_buf_in& in, ssize_t& res);
331
332	/* Write a single response back to the kernel */
333	void write_response(const mockfs_buf_out &out);
334
335	public:
336	/* pid of child process, for two-process test cases */
337	pid_t m_child_pid;
338
339	/* Maximum size of a FUSE_WRITE write */
340	uint32_t m_maxwrite;
341
342	/*
343	 * Number of events that were available from /dev/fuse after the last
344	 * kevent call.  Only valid when m_pm = KQ.
345	 */
346	int m_nready;
347
348	/* Tell the daemon to shut down ASAP */
349	bool m_quit;
350
351	/* Create a new mockfs and mount it to a tempdir */
352	MockFS(int max_readahead, bool allow_other,
353		bool default_permissions, bool push_symlinks_in, bool ro,
354		enum poll_method pm, uint32_t flags,
355		uint32_t kernel_minor_version, uint32_t max_write, bool async,
356		bool no_clusterr, unsigned time_gran, bool nointr);
357
358	virtual ~MockFS();
359
360	/* Kill the filesystem daemon without unmounting the filesystem */
361	void kill_daemon();
362
363	/* Process FUSE requests endlessly */
364	void loop();
365
366	/*
367	 * Send an asynchronous notification to invalidate a directory entry.
368	 * Similar to libfuse's fuse_lowlevel_notify_inval_entry
369	 *
370	 * This method will block until the client has responded, so it should
371	 * generally be run in a separate thread from request processing.
372	 *
373	 * @param	parent	Parent directory's inode number
374	 * @param	name	name of dirent to invalidate
375	 * @param	namelen	size of name, including the NUL
376	 */
377	int notify_inval_entry(ino_t parent, const char *name, size_t namelen);
378
379	/*
380	 * Send an asynchronous notification to invalidate an inode's cached
381	 * data and/or attributes.  Similar to libfuse's
382	 * fuse_lowlevel_notify_inval_inode.
383	 *
384	 * This method will block until the client has responded, so it should
385	 * generally be run in a separate thread from request processing.
386	 *
387	 * @param	ino	File's inode number
388	 * @param	off	offset at which to begin invalidation.  A
389	 * 			negative offset means to invalidate attributes
390	 * 			only.
391	 * @param	len	Size of region of data to invalidate.  0 means
392	 * 			to invalidate all cached data.
393	 */
394	int notify_inval_inode(ino_t ino, off_t off, ssize_t len);
395
396	/*
397	 * Send an asynchronous notification to store data directly into an
398	 * inode's cache.  Similar to libfuse's fuse_lowlevel_notify_store.
399	 *
400	 * This method will block until the client has responded, so it should
401	 * generally be run in a separate thread from request processing.
402	 *
403	 * @param	ino	File's inode number
404	 * @param	off	Offset at which to store data
405	 * @param	data	Pointer to the data to cache
406	 * @param	len	Size of data
407	 */
408	int notify_store(ino_t ino, off_t off, const void* data, ssize_t size);
409
410	/*
411	 * Request handler
412	 *
413	 * This method is expected to provide the responses to each FUSE
414	 * operation.  For an immediate response, push one buffer into out.
415	 * For a delayed response, push nothing.  For an immediate response
416	 * plus a delayed response to an earlier operation, push two bufs.
417	 * Test cases must define each response using Googlemock expectations
418	 */
419	MOCK_METHOD2(process, void(const mockfs_buf_in&,
420				std::vector<std::unique_ptr<mockfs_buf_out>>&));
421
422	/* Gracefully unmount */
423	void unmount();
424};
425