[deliverable/linux.git] / include / linux / kernfs.h

/*
 * kernfs.h - pseudo filesystem decoupled from vfs locking
 *
 * This file is released under the GPLv2.
 */

#ifndef __LINUX_KERNFS_H
#define __LINUX_KERNFS_H

#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/idr.h>
#include <linux/lockdep.h>
#include <linux/rbtree.h>
#include <linux/atomic.h>
#include <linux/wait.h>

struct file;
struct dentry;
struct iattr;
struct seq_file;
struct vm_area_struct;
struct super_block;
struct file_system_type;

struct kernfs_open_node;
struct kernfs_iattrs;

enum kernfs_node_type {
	KERNFS_DIR		= 0x0001,
	KERNFS_FILE		= 0x0002,
	KERNFS_LINK		= 0x0004,
};

#define KERNFS_TYPE_MASK	0x000f
#define KERNFS_FLAG_MASK	~KERNFS_TYPE_MASK

enum kernfs_node_flag {
	KERNFS_ACTIVATED	= 0x0010,
	KERNFS_NS		= 0x0020,
	KERNFS_HAS_SEQ_SHOW	= 0x0040,
	KERNFS_HAS_MMAP		= 0x0080,
	KERNFS_LOCKDEP		= 0x0100,
	KERNFS_STATIC_NAME	= 0x0200,
	KERNFS_SUICIDAL		= 0x0400,
	KERNFS_SUICIDED		= 0x0800,
};

/* @flags for kernfs_create_root() */
enum kernfs_root_flag {
	/*
	 * kernfs_nodes are created in the deactivated state and invisible.
	 * They require explicit kernfs_activate() to become visible.  This
	 * can be used to make related nodes become visible atomically
	 * after all nodes are created successfully.
	 */
	KERNFS_ROOT_CREATE_DEACTIVATED		= 0x0001,

	/*
	 * For regular flies, if the opener has CAP_DAC_OVERRIDE, open(2)
	 * succeeds regardless of the RW permissions.  sysfs had an extra
	 * layer of enforcement where open(2) fails with -EACCES regardless
	 * of CAP_DAC_OVERRIDE if the permission doesn't have the
	 * respective read or write access at all (none of S_IRUGO or
	 * S_IWUGO) or the respective operation isn't implemented.  The
	 * following flag enables that behavior.
	 */
	KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK	= 0x0002,
};

/* type-specific structures for kernfs_node union members */
struct kernfs_elem_dir {
	unsigned long		subdirs;
	/* children rbtree starts here and goes through kn->rb */
	struct rb_root		children;

	/*
	 * The kernfs hierarchy this directory belongs to.  This fits
	 * better directly in kernfs_node but is here to save space.
	 */
	struct kernfs_root	*root;
};

struct kernfs_elem_symlink {
	struct kernfs_node	*target_kn;
};

struct kernfs_elem_attr {
	const struct kernfs_ops	*ops;
	struct kernfs_open_node	*open;
	loff_t			size;
	struct kernfs_node	*notify_next;	/* for kernfs_notify() */
};

/*
 * kernfs_node - the building block of kernfs hierarchy.  Each and every
 * kernfs node is represented by single kernfs_node.  Most fields are
 * private to kernfs and shouldn't be accessed directly by kernfs users.
 *
 * As long as s_count reference is held, the kernfs_node itself is
 * accessible.  Dereferencing elem or any other outer entity requires
 * active reference.
 */
struct kernfs_node {
	atomic_t		count;
	atomic_t		active;
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	struct lockdep_map	dep_map;
#endif
	/*
	 * Use kernfs_get_parent() and kernfs_name/path() instead of
	 * accessing the following two fields directly.  If the node is
	 * never moved to a different parent, it is safe to access the
	 * parent directly.
	 */
	struct kernfs_node	*parent;
	const char		*name;

	struct rb_node		rb;

	const void		*ns;	/* namespace tag */
	unsigned int		hash;	/* ns + name hash */
	union {
		struct kernfs_elem_dir		dir;
		struct kernfs_elem_symlink	symlink;
		struct kernfs_elem_attr		attr;
	};

	void			*priv;

	unsigned short		flags;
	umode_t			mode;
	unsigned int		ino;
	struct kernfs_iattrs	*iattr;
};

/*
 * kernfs_syscall_ops may be specified on kernfs_create_root() to support
 * syscalls.  These optional callbacks are invoked on the matching syscalls
 * and can perform any kernfs operations which don't necessarily have to be
 * the exact operation requested.  An active reference is held for each
 * kernfs_node parameter.
 */
struct kernfs_syscall_ops {
	int (*remount_fs)(struct kernfs_root *root, int *flags, char *data);
	int (*show_options)(struct seq_file *sf, struct kernfs_root *root);

	int (*mkdir)(struct kernfs_node *parent, const char *name,
		     umode_t mode);
	int (*rmdir)(struct kernfs_node *kn);
	int (*rename)(struct kernfs_node *kn, struct kernfs_node *new_parent,
		      const char *new_name);
};

struct kernfs_root {
	/* published fields */
	struct kernfs_node	*kn;
	unsigned int		flags;	/* KERNFS_ROOT_* flags */

	/* private fields, do not use outside kernfs proper */
	struct ida		ino_ida;
	struct kernfs_syscall_ops *syscall_ops;

	/* list of kernfs_super_info of this root, protected by kernfs_mutex */
	struct list_head	supers;

	wait_queue_head_t	deactivate_waitq;
};

struct kernfs_open_file {
	/* published fields */
	struct kernfs_node	*kn;
	struct file		*file;
	void			*priv;

	/* private fields, do not use outside kernfs proper */
	struct mutex		mutex;
	int			event;
	struct list_head	list;

	size_t			atomic_write_len;
	bool			mmapped;
	const struct vm_operations_struct *vm_ops;
};

struct kernfs_ops {
	/*
	 * Read is handled by either seq_file or raw_read().
	 *
	 * If seq_show() is present, seq_file path is active.  Other seq
	 * operations are optional and if not implemented, the behavior is
	 * equivalent to single_open().  @sf->private points to the
	 * associated kernfs_open_file.
	 *
	 * read() is bounced through kernel buffer and a read larger than
	 * PAGE_SIZE results in partial operation of PAGE_SIZE.
	 */
	int (*seq_show)(struct seq_file *sf, void *v);

	void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
	void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
	void (*seq_stop)(struct seq_file *sf, void *v);

	ssize_t (*read)(struct kernfs_open_file *of, char *buf, size_t bytes,
			loff_t off);

	/*
	 * write() is bounced through kernel buffer.  If atomic_write_len
	 * is not set, a write larger than PAGE_SIZE results in partial
	 * operations of PAGE_SIZE chunks.  If atomic_write_len is set,
	 * writes upto the specified size are executed atomically but
	 * larger ones are rejected with -E2BIG.
	 */
	size_t atomic_write_len;
	ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes,
			 loff_t off);

	int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma);

#ifdef CONFIG_DEBUG_LOCK_ALLOC
	struct lock_class_key	lockdep_key;
#endif
};

#ifdef CONFIG_KERNFS

static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
{
	return kn->flags & KERNFS_TYPE_MASK;
}

/**
 * kernfs_enable_ns - enable namespace under a directory
 * @kn: directory of interest, should be empty
 *
 * This is to be called right after @kn is created to enable namespace
 * under it.  All children of @kn must have non-NULL namespace tags and
 * only the ones which match the super_block's tag will be visible.
 */
static inline void kernfs_enable_ns(struct kernfs_node *kn)
{
	WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);
	WARN_ON_ONCE(!RB_EMPTY_ROOT(&kn->dir.children));
	kn->flags |= KERNFS_NS;
}

/**
 * kernfs_ns_enabled - test whether namespace is enabled
 * @kn: the node to test
 *
 * Test whether namespace filtering is enabled for the children of @ns.
 */
static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
{
	return kn->flags & KERNFS_NS;
}

int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen);
char * __must_check kernfs_path(struct kernfs_node *kn, char *buf,
				size_t buflen);
void pr_cont_kernfs_name(struct kernfs_node *kn);
void pr_cont_kernfs_path(struct kernfs_node *kn);
struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn);
struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
					   const char *name, const void *ns);
void kernfs_get(struct kernfs_node *kn);
void kernfs_put(struct kernfs_node *kn);

struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry);
struct kernfs_root *kernfs_root_from_sb(struct super_block *sb);

struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
				       unsigned int flags, void *priv);
void kernfs_destroy_root(struct kernfs_root *root);

struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
					 const char *name, umode_t mode,
					 void *priv, const void *ns);
struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
					 const char *name,
					 umode_t mode, loff_t size,
					 const struct kernfs_ops *ops,
					 void *priv, const void *ns,
					 bool name_is_static,
					 struct lock_class_key *key);
struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
				       const char *name,
				       struct kernfs_node *target);
void kernfs_activate(struct kernfs_node *kn);
void kernfs_remove(struct kernfs_node *kn);
void kernfs_break_active_protection(struct kernfs_node *kn);
void kernfs_unbreak_active_protection(struct kernfs_node *kn);
bool kernfs_remove_self(struct kernfs_node *kn);
int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
			     const void *ns);
int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
		     const char *new_name, const void *new_ns);
int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr);
void kernfs_notify(struct kernfs_node *kn);

const void *kernfs_super_ns(struct super_block *sb);
struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
			       struct kernfs_root *root, unsigned long magic,
			       bool *new_sb_created, const void *ns);
void kernfs_kill_sb(struct super_block *sb);
struct super_block *kernfs_pin_sb(struct kernfs_root *root, const void *ns);

void kernfs_init(void);

#else	/* CONFIG_KERNFS */

static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
{ return 0; }	/* whatever */

static inline void kernfs_enable_ns(struct kernfs_node *kn) { }

static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
{ return false; }

static inline int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
{ return -ENOSYS; }

static inline char * __must_check kernfs_path(struct kernfs_node *kn, char *buf,
					      size_t buflen)
{ return NULL; }

static inline void pr_cont_kernfs_name(struct kernfs_node *kn) { }
static inline void pr_cont_kernfs_path(struct kernfs_node *kn) { }

static inline struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
{ return NULL; }

static inline struct kernfs_node *
kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name,
		       const void *ns)
{ return NULL; }

static inline void kernfs_get(struct kernfs_node *kn) { }
static inline void kernfs_put(struct kernfs_node *kn) { }

static inline struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
{ return NULL; }

static inline struct kernfs_root *kernfs_root_from_sb(struct super_block *sb)
{ return NULL; }

static inline struct kernfs_root *
kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags,
		   void *priv)
{ return ERR_PTR(-ENOSYS); }

static inline void kernfs_destroy_root(struct kernfs_root *root) { }

static inline struct kernfs_node *
kernfs_create_dir_ns(struct kernfs_node *parent, const char *name,
		     umode_t mode, void *priv, const void *ns)
{ return ERR_PTR(-ENOSYS); }

static inline struct kernfs_node *
__kernfs_create_file(struct kernfs_node *parent, const char *name,
		     umode_t mode, loff_t size, const struct kernfs_ops *ops,
		     void *priv, const void *ns, bool name_is_static,
		     struct lock_class_key *key)
{ return ERR_PTR(-ENOSYS); }

static inline struct kernfs_node *
kernfs_create_link(struct kernfs_node *parent, const char *name,
		   struct kernfs_node *target)
{ return ERR_PTR(-ENOSYS); }

static inline void kernfs_activate(struct kernfs_node *kn) { }

static inline void kernfs_remove(struct kernfs_node *kn) { }

static inline bool kernfs_remove_self(struct kernfs_node *kn)
{ return false; }

static inline int kernfs_remove_by_name_ns(struct kernfs_node *kn,
					   const char *name, const void *ns)
{ return -ENOSYS; }

static inline int kernfs_rename_ns(struct kernfs_node *kn,
				   struct kernfs_node *new_parent,
				   const char *new_name, const void *new_ns)
{ return -ENOSYS; }

static inline int kernfs_setattr(struct kernfs_node *kn,
				 const struct iattr *iattr)
{ return -ENOSYS; }

static inline void kernfs_notify(struct kernfs_node *kn) { }

static inline const void *kernfs_super_ns(struct super_block *sb)
{ return NULL; }

static inline struct dentry *
kernfs_mount_ns(struct file_system_type *fs_type, int flags,
		struct kernfs_root *root, unsigned long magic,
		bool *new_sb_created, const void *ns)
{ return ERR_PTR(-ENOSYS); }

static inline void kernfs_kill_sb(struct super_block *sb) { }

static inline void kernfs_init(void) { }

#endif	/* CONFIG_KERNFS */

static inline struct kernfs_node *
kernfs_find_and_get(struct kernfs_node *kn, const char *name)
{
	return kernfs_find_and_get_ns(kn, name, NULL);
}

static inline struct kernfs_node *
kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode,
		  void *priv)
{
	return kernfs_create_dir_ns(parent, name, mode, priv, NULL);
}

static inline struct kernfs_node *
kernfs_create_file_ns(struct kernfs_node *parent, const char *name,
		      umode_t mode, loff_t size, const struct kernfs_ops *ops,
		      void *priv, const void *ns)
{
	struct lock_class_key *key = NULL;

#ifdef CONFIG_DEBUG_LOCK_ALLOC
	key = (struct lock_class_key *)&ops->lockdep_key;
#endif
	return __kernfs_create_file(parent, name, mode, size, ops, priv, ns,
				    false, key);
}

static inline struct kernfs_node *
kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode,
		   loff_t size, const struct kernfs_ops *ops, void *priv)
{
	return kernfs_create_file_ns(parent, name, mode, size, ops, priv, NULL);
}

static inline int kernfs_remove_by_name(struct kernfs_node *parent,
					const char *name)
{
	return kernfs_remove_by_name_ns(parent, name, NULL);
}

static inline int kernfs_rename(struct kernfs_node *kn,
				struct kernfs_node *new_parent,
				const char *new_name)
{
	return kernfs_rename_ns(kn, new_parent, new_name, NULL);
}

static inline struct dentry *
kernfs_mount(struct file_system_type *fs_type, int flags,
		struct kernfs_root *root, unsigned long magic,
		bool *new_sb_created)
{
	return kernfs_mount_ns(fs_type, flags, root,
				magic, new_sb_created, NULL);
}

#endif	/* __LINUX_KERNFS_H */
Commit	Line	Data
b8441ed2 TH	1	/*
	2	* kernfs.h - pseudo filesystem decoupled from vfs locking
	3	*
	4	* This file is released under the GPLv2.
	5	*/
	6
	7	#ifndef __LINUX_KERNFS_H
	8	#define __LINUX_KERNFS_H
	9
879f40d1	10	#include <linux/kernel.h>
5d0e26bb	11	#include <linux/err.h>
dd8a5b03 TH	12	#include <linux/list.h>
dd8a5b03 TH	13	#include <linux/mutex.h>
bc755553	14	#include <linux/idr.h>
517e64f5	15	#include <linux/lockdep.h>
cf9e5a73 TH	16	#include <linux/rbtree.h>
cf9e5a73 TH	17	#include <linux/atomic.h>
abd54f02	18	#include <linux/wait.h>
879f40d1	19
5d60418e	20	struct file;
917f56ca	21	struct dentry;
5d60418e	22	struct iattr;
dd8a5b03 TH	23	struct seq_file;
dd8a5b03 TH	24	struct vm_area_struct;
4b93dc9b TH	25	struct super_block;
4b93dc9b TH	26	struct file_system_type;
5d60418e	27
c525aadd TH	28	struct kernfs_open_node;
c525aadd TH	29	struct kernfs_iattrs;
cf9e5a73 TH	30
cf9e5a73 TH	31	enum kernfs_node_type {
df23fc39 TH	32	KERNFS_DIR = 0x0001,
	33	KERNFS_FILE = 0x0002,
	34	KERNFS_LINK = 0x0004,
cf9e5a73 TH	35	};
cf9e5a73 TH	36
df23fc39	37	#define KERNFS_TYPE_MASK 0x000f
df23fc39	38	#define KERNFS_FLAG_MASK ~KERNFS_TYPE_MASK
cf9e5a73 TH	39
cf9e5a73 TH	40	enum kernfs_node_flag {
d35258ef	41	KERNFS_ACTIVATED = 0x0010,
df23fc39 TH	42	KERNFS_NS = 0x0020,
	43	KERNFS_HAS_SEQ_SHOW = 0x0040,
	44	KERNFS_HAS_MMAP = 0x0080,
	45	KERNFS_LOCKDEP = 0x0100,
2063d608	46	KERNFS_STATIC_NAME = 0x0200,
6b0afc2a TH	47	KERNFS_SUICIDAL = 0x0400,
6b0afc2a TH	48	KERNFS_SUICIDED = 0x0800,
cf9e5a73 TH	49	};
cf9e5a73 TH	50
d35258ef TH	51	/* @flags for kernfs_create_root() */
d35258ef TH	52	enum kernfs_root_flag {
555724a8 TH	53	/*
	54	* kernfs_nodes are created in the deactivated state and invisible.
	55	* They require explicit kernfs_activate() to become visible. This
	56	* can be used to make related nodes become visible atomically
	57	* after all nodes are created successfully.
	58	*/
	59	KERNFS_ROOT_CREATE_DEACTIVATED = 0x0001,
	60
	61	/*
	62	* For regular flies, if the opener has CAP_DAC_OVERRIDE, open(2)
	63	* succeeds regardless of the RW permissions. sysfs had an extra
	64	* layer of enforcement where open(2) fails with -EACCES regardless
	65	* of CAP_DAC_OVERRIDE if the permission doesn't have the
	66	* respective read or write access at all (none of S_IRUGO or
	67	* S_IWUGO) or the respective operation isn't implemented. The
	68	* following flag enables that behavior.
	69	*/
	70	KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK = 0x0002,
d35258ef TH	71	};
d35258ef TH	72
324a56e1 TH	73	/* type-specific structures for kernfs_node union members */
324a56e1 TH	74	struct kernfs_elem_dir {
cf9e5a73	75	unsigned long subdirs;
adc5e8b5	76	/* children rbtree starts here and goes through kn->rb */
cf9e5a73 TH	77	struct rb_root children;
	78
	79	/*
	80	* The kernfs hierarchy this directory belongs to. This fits
324a56e1	81	* better directly in kernfs_node but is here to save space.
cf9e5a73 TH	82	*/
	83	struct kernfs_root *root;
	84	};
	85
324a56e1 TH	86	struct kernfs_elem_symlink {
324a56e1 TH	87	struct kernfs_node *target_kn;
cf9e5a73 TH	88	};
cf9e5a73 TH	89
324a56e1	90	struct kernfs_elem_attr {
cf9e5a73	91	const struct kernfs_ops *ops;
c525aadd	92	struct kernfs_open_node *open;
cf9e5a73	93	loff_t size;
ecca47ce	94	struct kernfs_node notify_next; / for kernfs_notify() */
cf9e5a73 TH	95	};
	96
	97	/*
324a56e1 TH	98	* kernfs_node - the building block of kernfs hierarchy. Each and every
324a56e1 TH	99	* kernfs node is represented by single kernfs_node. Most fields are
cf9e5a73 TH	100	* private to kernfs and shouldn't be accessed directly by kernfs users.
cf9e5a73 TH	101	*
324a56e1 TH	102	* As long as s_count reference is held, the kernfs_node itself is
	103	* accessible. Dereferencing elem or any other outer entity requires
	104	* active reference.
cf9e5a73	105	*/
324a56e1	106	struct kernfs_node {
adc5e8b5 TH	107	atomic_t count;
adc5e8b5 TH	108	atomic_t active;
cf9e5a73 TH	109	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	110	struct lockdep_map dep_map;
	111	#endif
3eef34ad TH	112	/*
	113	* Use kernfs_get_parent() and kernfs_name/path() instead of
	114	* accessing the following two fields directly. If the node is
	115	* never moved to a different parent, it is safe to access the
	116	* parent directly.
	117	*/
adc5e8b5 TH	118	struct kernfs_node *parent;
adc5e8b5 TH	119	const char *name;
cf9e5a73	120
adc5e8b5	121	struct rb_node rb;
cf9e5a73	122
adc5e8b5	123	const void ns; / namespace tag */
9b0925a6	124	unsigned int hash; /* ns + name hash */
cf9e5a73	125	union {
adc5e8b5 TH	126	struct kernfs_elem_dir dir;
	127	struct kernfs_elem_symlink symlink;
	128	struct kernfs_elem_attr attr;
cf9e5a73 TH	129	};
	130
	131	void *priv;
	132
adc5e8b5 TH	133	unsigned short flags;
	134	umode_t mode;
	135	unsigned int ino;
c525aadd	136	struct kernfs_iattrs *iattr;
cf9e5a73	137	};
b8441ed2	138
80b9bbef	139	/*
90c07c89 TH	140	* kernfs_syscall_ops may be specified on kernfs_create_root() to support
	141	* syscalls. These optional callbacks are invoked on the matching syscalls
	142	* and can perform any kernfs operations which don't necessarily have to be
	143	* the exact operation requested. An active reference is held for each
	144	* kernfs_node parameter.
80b9bbef	145	*/
90c07c89	146	struct kernfs_syscall_ops {
6a7fed4e TH	147	int (remount_fs)(struct kernfs_root root, int flags, char data);
	148	int (show_options)(struct seq_file sf, struct kernfs_root *root);
	149
80b9bbef TH	150	int (mkdir)(struct kernfs_node parent, const char *name,
	151	umode_t mode);
	152	int (rmdir)(struct kernfs_node kn);
	153	int (rename)(struct kernfs_node kn, struct kernfs_node *new_parent,
	154	const char *new_name);
	155	};
	156
ba7443bc TH	157	struct kernfs_root {
ba7443bc TH	158	/* published fields */
324a56e1	159	struct kernfs_node *kn;
d35258ef	160	unsigned int flags; /* KERNFS_ROOT_* flags */
bc755553 TH	161
	162	/* private fields, do not use outside kernfs proper */
	163	struct ida ino_ida;
90c07c89	164	struct kernfs_syscall_ops *syscall_ops;
7d568a83 TH	165
	166	/* list of kernfs_super_info of this root, protected by kernfs_mutex */
	167	struct list_head supers;
	168
abd54f02	169	wait_queue_head_t deactivate_waitq;
ba7443bc TH	170	};
ba7443bc TH	171
c525aadd	172	struct kernfs_open_file {
dd8a5b03	173	/* published fields */
324a56e1	174	struct kernfs_node *kn;
dd8a5b03	175	struct file *file;
2536390d	176	void *priv;
dd8a5b03 TH	177
	178	/* private fields, do not use outside kernfs proper */
	179	struct mutex mutex;
	180	int event;
	181	struct list_head list;
	182
b7ce40cf	183	size_t atomic_write_len;
dd8a5b03 TH	184	bool mmapped;
	185	const struct vm_operations_struct *vm_ops;
	186	};
	187
f6acf8bb TH	188	struct kernfs_ops {
	189	/*
	190	* Read is handled by either seq_file or raw_read().
	191	*
d19b9846 TH	192	* If seq_show() is present, seq_file path is active. Other seq
	193	* operations are optional and if not implemented, the behavior is
	194	* equivalent to single_open(). @sf->private points to the
c525aadd	195	* associated kernfs_open_file.
f6acf8bb TH	196	*
	197	* read() is bounced through kernel buffer and a read larger than
	198	* PAGE_SIZE results in partial operation of PAGE_SIZE.
	199	*/
	200	int (seq_show)(struct seq_file sf, void *v);
d19b9846 TH	201
	202	void (seq_start)(struct seq_file sf, loff_t ppos);
	203	void (seq_next)(struct seq_file sf, void v, loff_t *ppos);
	204	void (seq_stop)(struct seq_file sf, void *v);
f6acf8bb	205
c525aadd	206	ssize_t (read)(struct kernfs_open_file of, char *buf, size_t bytes,
f6acf8bb TH	207	loff_t off);
	208
	209	/*
4d3773c4 TH	210	* write() is bounced through kernel buffer. If atomic_write_len
	211	* is not set, a write larger than PAGE_SIZE results in partial
	212	* operations of PAGE_SIZE chunks. If atomic_write_len is set,
	213	* writes upto the specified size are executed atomically but
	214	* larger ones are rejected with -E2BIG.
f6acf8bb	215	*/
4d3773c4	216	size_t atomic_write_len;
c525aadd	217	ssize_t (write)(struct kernfs_open_file of, char *buf, size_t bytes,
f6acf8bb TH	218	loff_t off);
f6acf8bb TH	219
c525aadd	220	int (mmap)(struct kernfs_open_file of, struct vm_area_struct *vma);
517e64f5 TH	221
	222	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	223	struct lock_class_key lockdep_key;
	224	#endif
f6acf8bb TH	225	};
f6acf8bb TH	226
ba341d55	227	#ifdef CONFIG_KERNFS
879f40d1	228
df23fc39	229	static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
cf9e5a73	230	{
df23fc39	231	return kn->flags & KERNFS_TYPE_MASK;
cf9e5a73 TH	232	}
	233
	234	/**
	235	* kernfs_enable_ns - enable namespace under a directory
324a56e1	236	* @kn: directory of interest, should be empty
cf9e5a73	237	*
324a56e1 TH	238	* This is to be called right after @kn is created to enable namespace
324a56e1 TH	239	* under it. All children of @kn must have non-NULL namespace tags and
cf9e5a73 TH	240	* only the ones which match the super_block's tag will be visible.
cf9e5a73 TH	241	*/
324a56e1	242	static inline void kernfs_enable_ns(struct kernfs_node *kn)
cf9e5a73	243	{
df23fc39	244	WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);
adc5e8b5	245	WARN_ON_ONCE(!RB_EMPTY_ROOT(&kn->dir.children));
df23fc39	246	kn->flags \|= KERNFS_NS;
cf9e5a73 TH	247	}
cf9e5a73 TH	248
ac9bba03 TH	249	/**
ac9bba03 TH	250	* kernfs_ns_enabled - test whether namespace is enabled
324a56e1	251	* @kn: the node to test
ac9bba03 TH	252	*
	253	* Test whether namespace filtering is enabled for the children of @ns.
	254	*/
324a56e1	255	static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
ac9bba03	256	{
df23fc39	257	return kn->flags & KERNFS_NS;
ac9bba03 TH	258	}
ac9bba03 TH	259
3eef34ad TH	260	int kernfs_name(struct kernfs_node kn, char buf, size_t buflen);
	261	char * __must_check kernfs_path(struct kernfs_node kn, char buf,
	262	size_t buflen);
	263	void pr_cont_kernfs_name(struct kernfs_node *kn);
	264	void pr_cont_kernfs_path(struct kernfs_node *kn);
	265	struct kernfs_node kernfs_get_parent(struct kernfs_node kn);
324a56e1 TH	266	struct kernfs_node kernfs_find_and_get_ns(struct kernfs_node parent,
	267	const char name, const void ns);
	268	void kernfs_get(struct kernfs_node *kn);
	269	void kernfs_put(struct kernfs_node *kn);
ccf73cf3	270
0c23b225 TH	271	struct kernfs_node kernfs_node_from_dentry(struct dentry dentry);
	272	struct kernfs_root kernfs_root_from_sb(struct super_block sb);
	273
90c07c89	274	struct kernfs_root kernfs_create_root(struct kernfs_syscall_ops scops,
d35258ef	275	unsigned int flags, void *priv);
ba7443bc TH	276	void kernfs_destroy_root(struct kernfs_root *root);
ba7443bc TH	277
324a56e1	278	struct kernfs_node kernfs_create_dir_ns(struct kernfs_node parent,
bb8b9d09 TH	279	const char *name, umode_t mode,
bb8b9d09 TH	280	void priv, const void ns);
2063d608 TH	281	struct kernfs_node __kernfs_create_file(struct kernfs_node parent,
	282	const char *name,
	283	umode_t mode, loff_t size,
	284	const struct kernfs_ops *ops,
	285	void priv, const void ns,
	286	bool name_is_static,
	287	struct lock_class_key *key);
324a56e1 TH	288	struct kernfs_node kernfs_create_link(struct kernfs_node parent,
	289	const char *name,
	290	struct kernfs_node *target);
d35258ef	291	void kernfs_activate(struct kernfs_node *kn);
324a56e1	292	void kernfs_remove(struct kernfs_node *kn);
6b0afc2a TH	293	void kernfs_break_active_protection(struct kernfs_node *kn);
	294	void kernfs_unbreak_active_protection(struct kernfs_node *kn);
	295	bool kernfs_remove_self(struct kernfs_node *kn);
324a56e1	296	int kernfs_remove_by_name_ns(struct kernfs_node parent, const char name,
879f40d1	297	const void *ns);
324a56e1	298	int kernfs_rename_ns(struct kernfs_node kn, struct kernfs_node new_parent,
890ece16	299	const char new_name, const void new_ns);
324a56e1 TH	300	int kernfs_setattr(struct kernfs_node kn, const struct iattr iattr);
324a56e1 TH	301	void kernfs_notify(struct kernfs_node *kn);
879f40d1	302
4b93dc9b TH	303	const void kernfs_super_ns(struct super_block sb);
4b93dc9b TH	304	struct dentry kernfs_mount_ns(struct file_system_type fs_type, int flags,
26fc9cd2 JZ	305	struct kernfs_root *root, unsigned long magic,
26fc9cd2 JZ	306	bool new_sb_created, const void ns);
4b93dc9b	307	void kernfs_kill_sb(struct super_block *sb);
4e26445f	308	struct super_block kernfs_pin_sb(struct kernfs_root root, const void *ns);
4b93dc9b TH	309
	310	void kernfs_init(void);
	311
ba341d55	312	#else /* CONFIG_KERNFS */
879f40d1	313
df23fc39	314	static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
cf9e5a73 TH	315	{ return 0; } /* whatever */
cf9e5a73 TH	316
324a56e1	317	static inline void kernfs_enable_ns(struct kernfs_node *kn) { }
cf9e5a73	318
324a56e1	319	static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
ac9bba03 TH	320	{ return false; }
ac9bba03 TH	321
3eef34ad TH	322	static inline int kernfs_name(struct kernfs_node kn, char buf, size_t buflen)
	323	{ return -ENOSYS; }
	324
	325	static inline char * __must_check kernfs_path(struct kernfs_node kn, char buf,
	326	size_t buflen)
	327	{ return NULL; }
	328
	329	static inline void pr_cont_kernfs_name(struct kernfs_node *kn) { }
	330	static inline void pr_cont_kernfs_path(struct kernfs_node *kn) { }
	331
	332	static inline struct kernfs_node kernfs_get_parent(struct kernfs_node kn)
	333	{ return NULL; }
	334
324a56e1 TH	335	static inline struct kernfs_node *
324a56e1 TH	336	kernfs_find_and_get_ns(struct kernfs_node parent, const char name,
ccf73cf3 TH	337	const void *ns)
	338	{ return NULL; }
	339
324a56e1 TH	340	static inline void kernfs_get(struct kernfs_node *kn) { }
324a56e1 TH	341	static inline void kernfs_put(struct kernfs_node *kn) { }
ccf73cf3	342
0c23b225 TH	343	static inline struct kernfs_node kernfs_node_from_dentry(struct dentry dentry)
	344	{ return NULL; }
	345
	346	static inline struct kernfs_root kernfs_root_from_sb(struct super_block sb)
	347	{ return NULL; }
	348
80b9bbef	349	static inline struct kernfs_root *
d35258ef TH	350	kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags,
d35258ef TH	351	void *priv)
ba7443bc TH	352	{ return ERR_PTR(-ENOSYS); }
	353
	354	static inline void kernfs_destroy_root(struct kernfs_root *root) { }
	355
324a56e1	356	static inline struct kernfs_node *
bb8b9d09 TH	357	kernfs_create_dir_ns(struct kernfs_node parent, const char name,
bb8b9d09 TH	358	umode_t mode, void priv, const void ns)
93b2b8e4 TH	359	{ return ERR_PTR(-ENOSYS); }
93b2b8e4 TH	360
324a56e1	361	static inline struct kernfs_node *
2063d608 TH	362	__kernfs_create_file(struct kernfs_node parent, const char name,
	363	umode_t mode, loff_t size, const struct kernfs_ops *ops,
	364	void priv, const void ns, bool name_is_static,
	365	struct lock_class_key *key)
496f7394 TH	366	{ return ERR_PTR(-ENOSYS); }
496f7394 TH	367
324a56e1 TH	368	static inline struct kernfs_node *
	369	kernfs_create_link(struct kernfs_node parent, const char name,
	370	struct kernfs_node *target)
5d0e26bb TH	371	{ return ERR_PTR(-ENOSYS); }
5d0e26bb TH	372
d35258ef TH	373	static inline void kernfs_activate(struct kernfs_node *kn) { }
d35258ef TH	374
324a56e1	375	static inline void kernfs_remove(struct kernfs_node *kn) { }
879f40d1	376
6b0afc2a TH	377	static inline bool kernfs_remove_self(struct kernfs_node *kn)
	378	{ return false; }
	379
324a56e1	380	static inline int kernfs_remove_by_name_ns(struct kernfs_node *kn,
879f40d1 TH	381	const char name, const void ns)
	382	{ return -ENOSYS; }
	383
324a56e1 TH	384	static inline int kernfs_rename_ns(struct kernfs_node *kn,
324a56e1 TH	385	struct kernfs_node *new_parent,
890ece16 TH	386	const char new_name, const void new_ns)
	387	{ return -ENOSYS; }
	388
324a56e1	389	static inline int kernfs_setattr(struct kernfs_node *kn,
5d60418e TH	390	const struct iattr *iattr)
	391	{ return -ENOSYS; }
	392
324a56e1	393	static inline void kernfs_notify(struct kernfs_node *kn) { }
024f6471	394
4b93dc9b TH	395	static inline const void kernfs_super_ns(struct super_block sb)
	396	{ return NULL; }
	397
	398	static inline struct dentry *
	399	kernfs_mount_ns(struct file_system_type *fs_type, int flags,
26fc9cd2 JZ	400	struct kernfs_root *root, unsigned long magic,
26fc9cd2 JZ	401	bool new_sb_created, const void ns)
4b93dc9b TH	402	{ return ERR_PTR(-ENOSYS); }
	403
	404	static inline void kernfs_kill_sb(struct super_block *sb) { }
	405
	406	static inline void kernfs_init(void) { }
	407
ba341d55	408	#endif /* CONFIG_KERNFS */
879f40d1	409
324a56e1 TH	410	static inline struct kernfs_node *
324a56e1 TH	411	kernfs_find_and_get(struct kernfs_node kn, const char name)
ccf73cf3	412	{
324a56e1	413	return kernfs_find_and_get_ns(kn, name, NULL);
ccf73cf3 TH	414	}
ccf73cf3 TH	415
324a56e1	416	static inline struct kernfs_node *
bb8b9d09 TH	417	kernfs_create_dir(struct kernfs_node parent, const char name, umode_t mode,
bb8b9d09 TH	418	void *priv)
93b2b8e4	419	{
bb8b9d09	420	return kernfs_create_dir_ns(parent, name, mode, priv, NULL);
93b2b8e4 TH	421	}
93b2b8e4 TH	422
324a56e1 TH	423	static inline struct kernfs_node *
324a56e1 TH	424	kernfs_create_file_ns(struct kernfs_node parent, const char name,
517e64f5 TH	425	umode_t mode, loff_t size, const struct kernfs_ops *ops,
	426	void priv, const void ns)
	427	{
	428	struct lock_class_key *key = NULL;
	429
	430	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	431	key = (struct lock_class_key *)&ops->lockdep_key;
	432	#endif
2063d608 TH	433	return __kernfs_create_file(parent, name, mode, size, ops, priv, ns,
2063d608 TH	434	false, key);
517e64f5 TH	435	}
517e64f5 TH	436
324a56e1 TH	437	static inline struct kernfs_node *
324a56e1 TH	438	kernfs_create_file(struct kernfs_node parent, const char name, umode_t mode,
496f7394 TH	439	loff_t size, const struct kernfs_ops ops, void priv)
	440	{
	441	return kernfs_create_file_ns(parent, name, mode, size, ops, priv, NULL);
	442	}
	443
324a56e1	444	static inline int kernfs_remove_by_name(struct kernfs_node *parent,
879f40d1 TH	445	const char *name)
	446	{
	447	return kernfs_remove_by_name_ns(parent, name, NULL);
	448	}
	449
0c23b225 TH	450	static inline int kernfs_rename(struct kernfs_node *kn,
	451	struct kernfs_node *new_parent,
	452	const char *new_name)
	453	{
	454	return kernfs_rename_ns(kn, new_parent, new_name, NULL);
	455	}
	456
4b93dc9b TH	457	static inline struct dentry *
4b93dc9b TH	458	kernfs_mount(struct file_system_type *fs_type, int flags,
26fc9cd2 JZ	459	struct kernfs_root *root, unsigned long magic,
26fc9cd2 JZ	460	bool *new_sb_created)
4b93dc9b	461	{
26fc9cd2 JZ	462	return kernfs_mount_ns(fs_type, flags, root,
26fc9cd2 JZ	463	magic, new_sb_created, NULL);
4b93dc9b TH	464	}
4b93dc9b TH	465
b8441ed2	466	#endif /* __LINUX_KERNFS_H */