// SPDX-License-Identifier: GPL-2.0
/*
 * Simple filesystem to test FUSE symlink cache
 *
 * This is a simple FUSE filesystem that contains two objects: a file named
 * 'file' and a symlink to that file named 'link'.  If symlink caching is
 * disabled (i.e. FUSE_CAP_CACHE_SYMLINKS is reset during FUSE_INIT), whenever
 * the ->readlink() is executed to resolve 'link' a counter will be incremented.
 *
 * If symlink caching is enabled (i.e. FUSE_CAP_CACHE_SYMLINKS is set during
 * FUSE_INIT), resolving a symlink will only call into user-space the first
 * time.
 */

#define FUSE_USE_VERSION 31

#include <stdio.h>
#include <fuse_lowlevel.h>

#include "kselftest_harness.h"

#include "fuse_common.h"

#define FILENAME "file"
#define FILE_INO 42

#define LINKNAME "link"
#define LINK_INO 43

#define TIMEOUT	86400.0f

struct test_state {
	pthread_mutex_t lock;
	int readlink_counter;
	bool cache;
} test_state = {
	.lock = PTHREAD_MUTEX_INITIALIZER,
};

static void fs_init(void *userdata, struct fuse_conn_info *conn)
{
	pthread_mutex_lock(&test_state.lock);
	if (test_state.cache)
		fuse_set_feature_flag(conn, FUSE_CAP_CACHE_SYMLINKS);
	else
		fuse_unset_feature_flag(conn, FUSE_CAP_CACHE_SYMLINKS);
	pthread_mutex_unlock(&test_state.lock);
}

static void fs_lookup(fuse_req_t req, fuse_ino_t parent, const char *name)
{
	struct fuse_entry_param e = {};

	if (parent != FUSE_ROOT_ID ||
	    (strcmp(name, FILENAME) != 0 && strcmp(name, LINKNAME) != 0)) {
		fuse_reply_err(req, ENOENT);
		return;
	}

	if (!strcmp(name, FILENAME)) {
		e.ino = FILE_INO;
		e.attr.st_mode = S_IFREG | 0444;
		e.attr.st_nlink = 2;
	} else if (!strcmp(name, LINKNAME)) {
		e.ino = LINK_INO;
		e.attr.st_mode = S_IFLNK | 0444;
		e.attr.st_nlink = 1;
		e.attr.st_size = strlen(FILENAME);
	}
	e.attr_timeout = TIMEOUT;
	e.entry_timeout = TIMEOUT;

	fuse_reply_entry(req, &e);
}

static void fs_readlink(fuse_req_t req, fuse_ino_t ino)
{
	char buf[PATH_MAX];
	size_t sz = strlen(FILENAME);

	if (ino != LINK_INO) {
		fuse_reply_err(req, ENOENT);
		return;
	}

	memcpy(buf, FILENAME, sz);
	buf[sz] = '\0';
	pthread_mutex_lock(&test_state.lock);
	test_state.readlink_counter++;
	pthread_mutex_unlock(&test_state.lock);

	fuse_reply_readlink(req, buf);
}

static const struct fuse_lowlevel_ops fs_ops = {
	.init           = fs_init,
	.lookup		= fs_lookup,
	.readlink	= fs_readlink,
};

FIXTURE(symlink_cache)
{
	struct fuse_common_ctx ctx;
};
FIXTURE_VARIANT(symlink_cache)
{
	const bool cache;
};
FIXTURE_VARIANT_ADD(symlink_cache, symlinks_nocache)
{
	/* Variant with symlink cache disabled */
	.cache = false,
};
FIXTURE_VARIANT_ADD(symlink_cache, symlinks_cache)
{
	/* Variant with symlink cache enabled */
	.cache = true,
};

FIXTURE_SETUP(symlink_cache)
{
	char err[MAX_ERR_MSG];

	pthread_mutex_lock(&test_state.lock);
	test_state.readlink_counter = 0;
	test_state.cache = variant->cache;
	pthread_mutex_unlock(&test_state.lock);

	if (fs_setup(&fs_ops, &self->ctx, err))
		SKIP(return, err);
}

FIXTURE_TEARDOWN(symlink_cache)
{
	fs_teardown(&self->ctx);
}

TEST_F(symlink_cache, test_symlink_cache)
{
	char pathname[PATH_MAX];
	char buf[PATH_MAX];
	ssize_t sz;
	int counter;
	int i;

	sprintf(pathname, "%s/%s", self->ctx.mountpoint, LINKNAME);
	for (i = 0; i < 100; i++) {
		sz = readlink(pathname, buf, PATH_MAX);
		ASSERT_NE(sz, -1);
	}
	pthread_mutex_lock(&test_state.lock);
	counter = test_state.readlink_counter;
	pthread_mutex_unlock(&test_state.lock);

	if (variant->cache) {
		ASSERT_EQ(counter, 1);
	} else {
		ASSERT_EQ(counter, 100);
	}
}

TEST_HARNESS_MAIN