destroy.cc

/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2019 The FreeBSD Foundation
 *
 * This software was developed by BFF Storage Systems, LLC under sponsorship
 * from the FreeBSD Foundation.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

extern "C" {
#include <sys/param.h>
#include <sys/mount.h>

#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
}

#include "mockfs.hh"
#include "utils.hh"

using namespace testing;

/* Tests for orderly unmounts */
class Destroy: public FuseTest {};

/* Tests for unexpected deaths of the server */
class Death: public FuseTest{};

/* Tests for the auto_unmount mount option*/
class AutoUnmount: public FuseTest {
virtual void SetUp() {
	m_auto_unmount = true;
	FuseTest::SetUp();
}

protected:
/* Unmounting fusefs might be asynchronous with close, so use a retry loop */
void assert_unmounted() {
	struct statfs statbuf;

	for (int retry = 100; retry > 0; retry--) {
		ASSERT_EQ(0, statfs("mountpoint", &statbuf)) << strerror(errno);
		if (strcmp("fusefs", statbuf.f_fstypename) != 0 &&
		    strcmp("/dev/fuse", statbuf.f_mntfromname) != 0)
			return;
		nap();
	}
	FAIL() << "fusefs is still mounted";
}

};

static void* open_th(void* arg) {
	int fd;
	const char *path = (const char*)arg;

	fd = open(path, O_RDONLY);
	EXPECT_EQ(-1, fd);
	EXPECT_EQ(ENOTCONN, errno);
	return 0;
}

/*
 * With the auto_unmount mount option, the kernel will automatically unmount
 * the file system when the server dies.
 */
TEST_F(AutoUnmount, auto_unmount)
{
	/* Kill the daemon */
	m_mock->kill_daemon();

	/* Use statfs to check that the file system is no longer mounted */
	assert_unmounted();
}

/*
 * When -o auto_unmount is used, the kernel should _not_ unmount the file
 * system when any /dev/fuse file descriptor is closed, but only for the last
 * one.
 */
TEST_F(AutoUnmount, dup)
{
	struct statfs statbuf;
	int fuse2;

	EXPECT_CALL(*m_mock, process(
		ResultOf([](auto in) {
			return (in.header.opcode == FUSE_STATFS);
		}, Eq(true)),
		_)
	).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, statfs);
	})));

	fuse2 = dup_dev_fuse();

	/*
	 * Close one of the /dev/fuse file descriptors.  Close the duplicate
	 * first so the daemon thread doesn't freak out when it gets a bunch of
	 * EBADF errors.
	 */
	close(fuse2);

	/* Use statfs to check that the file system is still mounted */
	ASSERT_EQ(0, statfs("mountpoint", &statbuf)) << strerror(errno);
	EXPECT_EQ(0, strcmp("fusefs", statbuf.f_fstypename));
	EXPECT_EQ(0, strcmp("/dev/fuse", statbuf.f_mntfromname));

	/*
	 * Close the original file descriptor too. Now the file system should be
	 * unmounted at last.
	 */
	m_mock->kill_daemon();
	assert_unmounted();
}

/*
 * The server dies with unsent operations still on the message queue.
 * Check for any memory leaks like this:
 * 1) kldunload fusefs, if necessary
 * 2) kldload fusefs
 * 3) ./destroy --gtest_filter=Death.unsent_operations
 * 4) kldunload fusefs
 * 5) check /var/log/messages for anything like this:
Freed UMA keg (fuse_ticket) was not empty (31 items).  Lost 2 pages of memory.
Warning: memory type fuse_msgbuf leaked memory on destroy (68 allocations, 428800 bytes leaked).
 */
TEST_F(Death, unsent_operations)
{
	const char FULLPATH0[] = "mountpoint/some_file.txt";
	const char FULLPATH1[] = "mountpoint/other_file.txt";
	const char RELPATH0[] = "some_file.txt";
	const char RELPATH1[] = "other_file.txt";
	pthread_t th0, th1;
	ino_t ino0 = 42, ino1 = 43;
	sem_t sem;
	mode_t mode = S_IFREG | 0644;

	sem_init(&sem, 0, 0);

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH0)
	.WillRepeatedly(Invoke(
		ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino0;
		out.body.entry.attr.nlink = 1;
	})));
	EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH1)
	.WillRepeatedly(Invoke(
		ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino1;
		out.body.entry.attr.nlink = 1;
	})));

	EXPECT_CALL(*m_mock, process(
		ResultOf([&](auto in) {
			return (in.header.opcode == FUSE_OPEN);
		}, Eq(true)),
		_)
	).WillOnce(Invoke([&](auto in __unused, auto &out __unused) {
		sem_post(&sem);
		pause();
	}));

	/*
	 * One thread's operation will be sent to the daemon and block, and the
	 * other's will be stuck in the message queue.
	 */
	ASSERT_EQ(0, pthread_create(&th0, NULL, open_th,
		__DECONST(void*, FULLPATH0))) << strerror(errno);
	ASSERT_EQ(0, pthread_create(&th1, NULL, open_th,
		__DECONST(void*, FULLPATH1))) << strerror(errno);

	/* Wait for the first thread to block */
	sem_wait(&sem);
	/* Give the second thread time to block */
	nap();

	m_mock->kill_daemon();

	pthread_join(th0, NULL);
	pthread_join(th1, NULL);

	sem_destroy(&sem);
}

/*
 * On unmount the kernel should send a FUSE_DESTROY operation.  It should also
 * send FUSE_FORGET operations for all inodes with lookup_count > 0.
 */
TEST_F(Destroy, ok)
{
	const char FULLPATH[] = "mountpoint/some_file.txt";
	const char RELPATH[] = "some_file.txt";
	uint64_t ino = 42;

	expect_lookup(RELPATH, ino, S_IFREG | 0644, 0, 2);
	expect_forget(ino, 2);
	expect_destroy(0);

	/*
	 * access(2) the file to force a lookup.  Access it twice to double its
	 * lookup count.
	 */
	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);
	ASSERT_EQ(0, access(FULLPATH, F_OK)) << strerror(errno);

	/*
	 * Unmount, triggering a FUSE_DESTROY and also causing a VOP_RECLAIM
	 * for every vnode on this mp, triggering FUSE_FORGET for each of them.
	 */
	m_mock->unmount();
}