nfs.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.
 */

/* This file tests functionality needed by NFS servers */
extern "C" {
#include <sys/param.h>
#include <sys/mount.h>

#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
}

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

using namespace std;
using namespace testing;


class Nfs: public FuseTest {
public:
virtual void SetUp() {
	if (geteuid() != 0)
                GTEST_SKIP() << "This test requires a privileged user";
	FuseTest::SetUp();
}
};

class Exportable: public Nfs {
public:
virtual void SetUp() {
	m_init_flags = FUSE_EXPORT_SUPPORT;
	Nfs::SetUp();
}
};

class Fhstat: public Exportable {};
class FhstatNotExportable: public Nfs {};
class Getfh: public Exportable {};
class Readdir: public Exportable {};

/* If the server returns a different generation number, then file is stale */
TEST_F(Fhstat, estale)
{
	const char FULLPATH[] = "mountpoint/some_dir/.";
	const char RELDIRPATH[] = "some_dir";
	fhandle_t fhp;
	struct stat sb;
	const uint64_t ino = 42;
	const mode_t mode = S_IFDIR | 0755;
	Sequence seq;

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELDIRPATH)
	.InSequence(seq)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = 1;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	EXPECT_LOOKUP(ino, ".")
	.InSequence(seq)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = 2;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno);
	ASSERT_EQ(-1, fhstat(&fhp, &sb));
	EXPECT_EQ(ESTALE, errno);
}

/* If we must lookup an entry from the server, send a LOOKUP request for "." */
TEST_F(Fhstat, lookup_dot)
{
	const char FULLPATH[] = "mountpoint/some_dir/.";
	const char RELDIRPATH[] = "some_dir";
	fhandle_t fhp;
	struct stat sb;
	const uint64_t ino = 42;
	const mode_t mode = S_IFDIR | 0755;
	const uid_t uid = 12345;

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELDIRPATH)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = 1;
		out.body.entry.attr.uid = uid;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	EXPECT_LOOKUP(ino, ".")
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = 1;
		out.body.entry.attr.uid = uid;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno);
	ASSERT_EQ(0, fhstat(&fhp, &sb)) << strerror(errno);
	EXPECT_EQ(uid, sb.st_uid);
	EXPECT_EQ(mode, sb.st_mode);
}

/* Gracefully handle failures to lookup ".". */
TEST_F(Fhstat, lookup_dot_error)
{
	const char FULLPATH[] = "mountpoint/some_dir/.";
	const char RELDIRPATH[] = "some_dir";
	fhandle_t fhp;
	struct stat sb;
	const uint64_t ino = 42;
	const mode_t mode = S_IFDIR | 0755;
	const uid_t uid = 12345;

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELDIRPATH)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = 1;
		out.body.entry.attr.uid = uid;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	EXPECT_LOOKUP(ino, ".")
	.WillOnce(Invoke(ReturnErrno(EDOOFUS)));

	ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno);
	ASSERT_EQ(-1, fhstat(&fhp, &sb));
	EXPECT_EQ(EDOOFUS, errno);
}

/* Use a file handle whose entry is still cached */
TEST_F(Fhstat, cached)
{
	const char FULLPATH[] = "mountpoint/some_dir/.";
	const char RELDIRPATH[] = "some_dir";
	fhandle_t fhp;
	struct stat sb;
	const uint64_t ino = 42;
	const mode_t mode = S_IFDIR | 0755;

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELDIRPATH)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = 1;
		out.body.entry.attr.ino = ino;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = UINT64_MAX;
	})));

	ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno);
	ASSERT_EQ(0, fhstat(&fhp, &sb)) << strerror(errno);
	EXPECT_EQ(ino, sb.st_ino);
}

/* File handle entries should expire from the cache, too */
TEST_F(Fhstat, cache_expired)
{
	const char FULLPATH[] = "mountpoint/some_dir/.";
	const char RELDIRPATH[] = "some_dir";
	fhandle_t fhp;
	struct stat sb;
	const uint64_t ino = 42;
	const mode_t mode = S_IFDIR | 0755;

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELDIRPATH)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = 1;
		out.body.entry.attr.ino = ino;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid_nsec = NAP_NS / 2;
	})));

	EXPECT_LOOKUP(ino, ".")
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = 1;
		out.body.entry.attr.ino = ino;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno);
	ASSERT_EQ(0, fhstat(&fhp, &sb)) << strerror(errno);
	EXPECT_EQ(ino, sb.st_ino);

	nap();

	/* Cache should be expired; fuse should issue a FUSE_LOOKUP */
	ASSERT_EQ(0, fhstat(&fhp, &sb)) << strerror(errno);
	EXPECT_EQ(ino, sb.st_ino);
}

/*
 * If the server returns a FUSE_LOOKUP response for a nodeid that we didn't
 * lookup, it's a bug.  But we should handle it gracefully.
 */
TEST_F(Fhstat, inconsistent_nodeid)
{
	const char FULLPATH[] = "mountpoint/some_dir/.";
	const char RELDIRPATH[] = "some_dir";
	fhandle_t fhp;
	struct stat sb;
	const uint64_t ino_in = 42;
	const uint64_t ino_out = 43;
	const mode_t mode = S_IFDIR | 0755;
	const uid_t uid = 12345;

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELDIRPATH)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.nodeid = ino_in;
		out.body.entry.attr.ino = ino_in;
		out.body.entry.attr.mode = mode;
		out.body.entry.generation = 1;
		out.body.entry.attr.uid = uid;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	EXPECT_LOOKUP(ino_in, ".")
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.nodeid = ino_out;
		out.body.entry.attr.ino = ino_out;
		out.body.entry.attr.mode = mode;
		out.body.entry.generation = 1;
		out.body.entry.attr.uid = uid;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno);
	EXPECT_NE(0, fhstat(&fhp, &sb)) << strerror(errno);
	EXPECT_EQ(EIO, errno);
}

/*
 * If the server returns a FUSE_LOOKUP response where the nodeid doesn't match
 * the inode number, and the file system is exported, it's a bug.  But we
 * should handle it gracefully.
 */
TEST_F(Fhstat, inconsistent_ino)
{
	const char FULLPATH[] = "mountpoint/some_dir/.";
	const char RELDIRPATH[] = "some_dir";
	fhandle_t fhp;
	struct stat sb;
	const uint64_t nodeid = 42;
	const uint64_t ino = 711;	// Could be anything that != nodeid
	const mode_t mode = S_IFDIR | 0755;
	const uid_t uid = 12345;

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELDIRPATH)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.nodeid = nodeid;
		out.body.entry.attr.ino = nodeid;
		out.body.entry.attr.mode = mode;
		out.body.entry.generation = 1;
		out.body.entry.attr.uid = uid;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	EXPECT_LOOKUP(nodeid, ".")
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.nodeid = nodeid;
		out.body.entry.attr.ino = ino;
		out.body.entry.attr.mode = mode;
		out.body.entry.generation = 1;
		out.body.entry.attr.uid = uid;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno);
	/*
	 * The fhstat operation will actually succeed.  But future operations
	 * will likely fail.
	 */
	ASSERT_EQ(0, fhstat(&fhp, &sb)) << strerror(errno);
	EXPECT_EQ(ino, sb.st_ino);
}

/* 
 * If the server doesn't set FUSE_EXPORT_SUPPORT, then we can't do NFS-style
 * lookups
 */
TEST_F(FhstatNotExportable, lookup_dot)
{
	const char FULLPATH[] = "mountpoint/some_dir/.";
	const char RELDIRPATH[] = "some_dir";
	fhandle_t fhp;
	const uint64_t ino = 42;
	const mode_t mode = S_IFDIR | 0755;

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELDIRPATH)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = 1;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	ASSERT_EQ(-1, getfh(FULLPATH, &fhp));
	ASSERT_EQ(EOPNOTSUPP, errno);
}

/* FreeBSD's fid struct doesn't have enough space for 64-bit generations */
TEST_F(Getfh, eoverflow)
{
	const char FULLPATH[] = "mountpoint/some_dir/.";
	const char RELDIRPATH[] = "some_dir";
	fhandle_t fhp;
	uint64_t ino = 42;

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELDIRPATH)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = S_IFDIR | 0755;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = (uint64_t)UINT32_MAX + 1;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = UINT64_MAX;
	})));

	ASSERT_NE(0, getfh(FULLPATH, &fhp));
	EXPECT_EQ(EOVERFLOW, errno);
}

/* Get an NFS file handle */
TEST_F(Getfh, ok)
{
	const char FULLPATH[] = "mountpoint/some_dir/.";
	const char RELDIRPATH[] = "some_dir";
	fhandle_t fhp;
	uint64_t ino = 42;

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELDIRPATH)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = S_IFDIR | 0755;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = UINT64_MAX;
	})));

	ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno);
}

/* 
 * Call readdir via a file handle.
 *
 * This is how a userspace nfs server like nfs-ganesha or unfs3 would call
 * readdir.  The in-kernel NFS server never does any equivalent of open.  I
 * haven't discovered a way to mimic nfsd's behavior short of actually running
 * nfsd.
 */
TEST_F(Readdir, getdirentries)
{
	const char FULLPATH[] = "mountpoint/some_dir";
	const char RELPATH[] = "some_dir";
	uint64_t ino = 42;
	mode_t mode = S_IFDIR | 0755;
	fhandle_t fhp;
	int fd;
	char buf[8192];
	ssize_t r;

	EXPECT_LOOKUP(FUSE_ROOT_ID, RELPATH)
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = 1;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	EXPECT_LOOKUP(ino, ".")
	.WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		SET_OUT_HEADER_LEN(out, entry);
		out.body.entry.attr.mode = mode;
		out.body.entry.nodeid = ino;
		out.body.entry.attr.ino = ino;
		out.body.entry.generation = 1;
		out.body.entry.attr_valid = UINT64_MAX;
		out.body.entry.entry_valid = 0;
	})));

	expect_opendir(ino);

	EXPECT_CALL(*m_mock, process(
		ResultOf([=](auto in) {
			return (in.header.opcode == FUSE_READDIR &&
				in.header.nodeid == ino &&
				in.body.readdir.size == sizeof(buf));
		}, Eq(true)),
		_)
	).WillOnce(Invoke(ReturnImmediate([=](auto in __unused, auto& out) {
		out.header.error = 0;
		out.header.len = sizeof(out.header);
	})));

	ASSERT_EQ(0, getfh(FULLPATH, &fhp)) << strerror(errno);
	fd = fhopen(&fhp, O_DIRECTORY);
	ASSERT_LE(0, fd) << strerror(errno);
	r = getdirentries(fd, buf, sizeof(buf), 0);
	ASSERT_EQ(0, r) << strerror(errno);

	leak(fd);
}