// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2026 Christian Brauner <brauner@kernel.org> */
#include <linux/fs.h>
#include <linux/fs/super_types.h>
#include <linux/fs_context.h>
#include <linux/fs_struct.h>
#include <linux/magic.h>
#include <linux/mount.h>

#include "internal.h"

static struct path failfs_root_path = {};

void failfs_get_root(struct path *path)
{
	*path = failfs_root_path;
	path_get(path);
}

bool failfs_mnt(const struct vfsmount *mnt)
{
	return mnt->mnt_sb == failfs_root_path.mnt->mnt_sb;
}

static int failfs_permission(struct mnt_idmap *idmap, struct inode *inode,
			     int mask)
{
	return -EOPNOTSUPP;
}

static struct dentry *failfs_lookup(struct inode *dir, struct dentry *dentry,
				    unsigned int flags)
{
	/* Unreachable: ->permission() already failed the walk. */
	return ERR_PTR(-EOPNOTSUPP);
}

static int failfs_getattr(struct mnt_idmap *idmap, const struct path *path,
			  struct kstat *stat, u32 request_mask,
			  unsigned int query_flags)
{
	return -EOPNOTSUPP;
}

static const struct inode_operations failfs_dir_inode_operations = {
	.permission	= failfs_permission,
	.lookup		= failfs_lookup,
	.getattr	= failfs_getattr,
};

static const struct file_operations failfs_dir_operations = {};

static int failfs_d_weak_revalidate(struct dentry *dentry, unsigned int flags)
{
	/*
	 * The root is only ever reached as a path-walk terminal by jumping
	 * to it: as "/" when it is the caller's root, or through a
	 * /proc/<pid>/{root,cwd} magic link. ->permission() already fails
	 * every walk of a component, but a jump lands on the root without
	 * one. Refuse here too so the root cannot be pinned by an O_PATH
	 * open or encoded into a file handle.
	 */
	return -EOPNOTSUPP;
}

static char *failfs_dname(struct dentry *dentry, char *buffer, int buflen)
{
	return dynamic_dname(buffer, buflen, "failfs:/");
}

static const struct dentry_operations failfs_dentry_operations = {
	.d_dname		= failfs_dname,
	.d_weak_revalidate	= failfs_d_weak_revalidate,
};

static int failfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	return -EOPNOTSUPP;
}

static const struct super_operations failfs_super_operations = {
	.statfs	= failfs_statfs,
};

static int failfs_fill_super(struct super_block *s, struct fs_context *fc)
{
	struct inode *inode;

	s->s_maxbytes		= MAX_LFS_FILESIZE;
	s->s_blocksize		= PAGE_SIZE;
	s->s_blocksize_bits	= PAGE_SHIFT;
	s->s_magic		= FAIL_FS_MAGIC;
	s->s_op			= &failfs_super_operations;
	s->s_export_op		= NULL;
	s->s_xattr		= NULL;
	s->s_time_gran		= 1;
	s->s_d_flags		= 0;

	inode = new_inode(s);
	if (!inode)
		return -ENOMEM;

	/* failfs supports no operations... */
	inode->i_mode	= S_IFDIR;
	set_nlink(inode, 2);
	inode->i_op	= &failfs_dir_inode_operations;
	inode->i_fop	= &failfs_dir_operations;
	simple_inode_init_ts(inode);
	inode->i_ino	= 1;
	/* ... and is immutable. */
	inode->i_flags |= S_IMMUTABLE;

	set_default_d_op(s, &failfs_dentry_operations);
	s->s_root = d_make_root(inode);
	if (!s->s_root)
		return -ENOMEM;

	return 0;
}

static int failfs_get_tree(struct fs_context *fc)
{
	return get_tree_single(fc, failfs_fill_super);
}

static const struct fs_context_operations failfs_context_ops = {
	.get_tree	= failfs_get_tree,
};

static int failfs_init_fs_context(struct fs_context *fc)
{
	fc->ops		= &failfs_context_ops;
	fc->global	= true;
	fc->sb_flags	|= SB_NOUSER;
	fc->s_iflags	|= SB_I_NOEXEC | SB_I_NODEV;
	return 0;
}

int failfs_current_chdir(void)
{
	struct path path;

	failfs_get_root(&path);
	set_fs_pwd(current->fs, &path);
	path_put(&path);
	return 0;
}

static struct file_system_type failfs_fs_type = {
	.name			= "failfs",
	.init_fs_context	= failfs_init_fs_context,
	.kill_sb		= kill_anon_super,
};

void __init failfs_init(void)
{
	struct vfsmount *mnt;

	/* A single instance that is member of no mount namespace. */
	mnt = kern_mount(&failfs_fs_type);
	if (IS_ERR(mnt))
		panic("VFS: Failed to create failfs");

	failfs_root_path.mnt	= mnt;
	failfs_root_path.dentry	= mnt->mnt_root;
}