linux/fs/fuse/inode.c

/*
  FUSE: Filesystem in Userspace
  Copyright (C) 2001-2008  Miklos Szeredi <[email protected]>

  This program can be distributed under the terms of the GNU GPL.
  See the file COPYING.
*/

#include "fuse_i.h"

#include <linux/pagemap.h>
#include <linux/slab.h>
#include <linux/file.h>
#include <linux/seq_file.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/fs_context.h>
#include <linux/fs_parser.h>
#include <linux/statfs.h>
#include <linux/random.h>
#include <linux/sched.h>
#include <linux/exportfs.h>
#include <linux/posix_acl.h>
#include <linux/pid_namespace.h>
#include <uapi/linux/magic.h>

MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;

static struct kmem_cache *fuse_inode_cachep;
struct list_head fuse_conn_list;
DEFINE_MUTEX(…) …;

static int set_global_limit(const char *val, const struct kernel_param *kp);

unsigned max_user_bgreq;
module_param_call(…);
__MODULE_PARM_TYPE(…) …;
MODULE_PARM_DESC(…) …;

unsigned max_user_congthresh;
module_param_call(…);
__MODULE_PARM_TYPE(…) …;
MODULE_PARM_DESC(…) …;

#define FUSE_DEFAULT_BLKSIZE …

/** Maximum number of outstanding background requests */
#define FUSE_DEFAULT_MAX_BACKGROUND …

/** Congestion starts at 75% of maximum */
#define FUSE_DEFAULT_CONGESTION_THRESHOLD …

#ifdef CONFIG_BLOCK
static struct file_system_type fuseblk_fs_type;
#endif

struct fuse_forget_link *fuse_alloc_forget(void)
{ … }

static struct fuse_submount_lookup *fuse_alloc_submount_lookup(void)
{ … }

static struct inode *fuse_alloc_inode(struct super_block *sb)
{ … }

static void fuse_free_inode(struct inode *inode)
{ … }

static void fuse_cleanup_submount_lookup(struct fuse_conn *fc,
					 struct fuse_submount_lookup *sl)
{ … }

static void fuse_evict_inode(struct inode *inode)
{ … }

static int fuse_reconfigure(struct fs_context *fsc)
{ … }

/*
 * ino_t is 32-bits on 32-bit arch. We have to squash the 64-bit value down
 * so that it will fit.
 */
static ino_t fuse_squash_ino(u64 ino64)
{ … }

void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
				   struct fuse_statx *sx,
				   u64 attr_valid, u32 cache_mask)
{ … }

u32 fuse_get_cache_mask(struct inode *inode)
{ … }

void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
			    struct fuse_statx *sx,
			    u64 attr_valid, u64 attr_version)
{ … }

static void fuse_init_submount_lookup(struct fuse_submount_lookup *sl,
				      u64 nodeid)
{ … }

static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr,
			    struct fuse_conn *fc)
{ … }

static int fuse_inode_eq(struct inode *inode, void *_nodeidp)
{ … }

static int fuse_inode_set(struct inode *inode, void *_nodeidp)
{ … }

struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
			int generation, struct fuse_attr *attr,
			u64 attr_valid, u64 attr_version)
{ … }

struct inode *fuse_ilookup(struct fuse_conn *fc, u64 nodeid,
			   struct fuse_mount **fm)
{ … }

int fuse_reverse_inval_inode(struct fuse_conn *fc, u64 nodeid,
			     loff_t offset, loff_t len)
{ … }

bool fuse_lock_inode(struct inode *inode)
{ … }

void fuse_unlock_inode(struct inode *inode, bool locked)
{ … }

static void fuse_umount_begin(struct super_block *sb)
{ … }

static void fuse_send_destroy(struct fuse_mount *fm)
{ … }

static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
{ … }

static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
{ … }

static struct fuse_sync_bucket *fuse_sync_bucket_alloc(void)
{ … }

static void fuse_sync_fs_writes(struct fuse_conn *fc)
{ … }

static int fuse_sync_fs(struct super_block *sb, int wait)
{ … }

enum { … };

static const struct fs_parameter_spec fuse_fs_parameters[] = …;

static int fuse_parse_param(struct fs_context *fsc, struct fs_parameter *param)
{ … }

static void fuse_free_fsc(struct fs_context *fsc)
{ … }

static int fuse_show_options(struct seq_file *m, struct dentry *root)
{ … }

static void fuse_iqueue_init(struct fuse_iqueue *fiq,
			     const struct fuse_iqueue_ops *ops,
			     void *priv)
{ … }

static void fuse_pqueue_init(struct fuse_pqueue *fpq)
{ … }

void fuse_conn_init(struct fuse_conn *fc, struct fuse_mount *fm,
		    struct user_namespace *user_ns,
		    const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv)
{ … }
EXPORT_SYMBOL_GPL(…);

static void delayed_release(struct rcu_head *p)
{ … }

void fuse_conn_put(struct fuse_conn *fc)
{ … }
EXPORT_SYMBOL_GPL(…);

struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)
{ … }
EXPORT_SYMBOL_GPL(…);

static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
{ … }

struct fuse_inode_handle { … };

static struct dentry *fuse_get_dentry(struct super_block *sb,
				      struct fuse_inode_handle *handle)
{ … }

static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len,
			   struct inode *parent)
{ … }

static struct dentry *fuse_fh_to_dentry(struct super_block *sb,
		struct fid *fid, int fh_len, int fh_type)
{ … }

static struct dentry *fuse_fh_to_parent(struct super_block *sb,
		struct fid *fid, int fh_len, int fh_type)
{ … }

static struct dentry *fuse_get_parent(struct dentry *child)
{ … }

/* only for fid encoding; no support for file handle */
static const struct export_operations fuse_export_fid_operations = …;

static const struct export_operations fuse_export_operations = …;

static const struct super_operations fuse_super_operations = …;

static void sanitize_global_limit(unsigned *limit)
{ … }

static int set_global_limit(const char *val, const struct kernel_param *kp)
{ … }

static void process_init_limits(struct fuse_conn *fc, struct fuse_init_out *arg)
{ … }

struct fuse_init_args { … };

static void process_init_reply(struct fuse_mount *fm, struct fuse_args *args,
			       int error)
{ … }

void fuse_send_init(struct fuse_mount *fm)
{ … }
EXPORT_SYMBOL_GPL(…);

void fuse_free_conn(struct fuse_conn *fc)
{ … }
EXPORT_SYMBOL_GPL(…);

static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
{ … }

struct fuse_dev *fuse_dev_alloc(void)
{ … }
EXPORT_SYMBOL_GPL(…);

void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc)
{ … }
EXPORT_SYMBOL_GPL(…);

struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc)
{ … }
EXPORT_SYMBOL_GPL(…);

void fuse_dev_free(struct fuse_dev *fud)
{ … }
EXPORT_SYMBOL_GPL(…);

static void fuse_fill_attr_from_inode(struct fuse_attr *attr,
				      const struct fuse_inode *fi)
{ … }

static void fuse_sb_defaults(struct super_block *sb)
{ … }

static int fuse_fill_super_submount(struct super_block *sb,
				    struct fuse_inode *parent_fi)
{ … }

/* Filesystem context private data holds the FUSE inode of the mount point */
static int fuse_get_tree_submount(struct fs_context *fsc)
{ … }

static const struct fs_context_operations fuse_context_submount_ops = …;

int fuse_init_fs_context_submount(struct fs_context *fsc)
{ … }
EXPORT_SYMBOL_GPL(…);

int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx)
{ … }
EXPORT_SYMBOL_GPL(…);

static int fuse_fill_super(struct super_block *sb, struct fs_context *fsc)
{ … }

/*
 * This is the path where user supplied an already initialized fuse dev.  In
 * this case never create a new super if the old one is gone.
 */
static int fuse_set_no_super(struct super_block *sb, struct fs_context *fsc)
{ … }

static int fuse_test_super(struct super_block *sb, struct fs_context *fsc)
{ … }

static int fuse_get_tree(struct fs_context *fsc)
{ … }

static const struct fs_context_operations fuse_context_ops = …;

/*
 * Set up the filesystem mount context.
 */
static int fuse_init_fs_context(struct fs_context *fsc)
{ … }

bool fuse_mount_remove(struct fuse_mount *fm)
{ … }
EXPORT_SYMBOL_GPL(…);

void fuse_conn_destroy(struct fuse_mount *fm)
{ … }
EXPORT_SYMBOL_GPL(…);

static void fuse_sb_destroy(struct super_block *sb)
{ … }

void fuse_mount_destroy(struct fuse_mount *fm)
{ … }
EXPORT_SYMBOL(…);

static void fuse_kill_sb_anon(struct super_block *sb)
{ … }

static struct file_system_type fuse_fs_type = …;
MODULE_ALIAS_FS(…) …;

#ifdef CONFIG_BLOCK
static void fuse_kill_sb_blk(struct super_block *sb)
{ … }

static struct file_system_type fuseblk_fs_type = …;
MODULE_ALIAS_FS(…) …;

static inline int register_fuseblk(void)
{ … }

static inline void unregister_fuseblk(void)
{ … }
#else
static inline int register_fuseblk(void)
{
	return 0;
}

static inline void unregister_fuseblk(void)
{
}
#endif

static void fuse_inode_init_once(void *foo)
{ … }

static int __init fuse_fs_init(void)
{ … }

static void fuse_fs_cleanup(void)
{ … }

static struct kobject *fuse_kobj;

static int fuse_sysfs_init(void)
{ … }

static void fuse_sysfs_cleanup(void)
{ … }

static int __init fuse_init(void)
{ … }

static void __exit fuse_exit(void)
{ … }

module_init(…) …;
module_exit(fuse_exit);