[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 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_JUST_DEACTIVATED	= 0x0010, /* used to aid lockdep annotation */
	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,
};

/* 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;
};

/*
 * 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;
	int			deact_depth;
	unsigned int		hash;	/* ns + name hash */
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	struct lockdep_map	dep_map;
#endif
	/* the following two fields are published */
	struct kernfs_node	*parent;
	const char		*name;

	struct rb_node		rb;

	const void		*ns;	/* namespace tag */
	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_dir_ops may be specified on kernfs_create_root() to support
 * directory manipulation 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.
 */
struct kernfs_dir_ops {
	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;

	/* private fields, do not use outside kernfs proper */
	struct ida		ino_ida;
	struct kernfs_dir_ops	*dir_ops;
	wait_queue_head_t	deactivate_waitq;
};

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

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

	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 and a write larger than
	 * PAGE_SIZE results in partial operation of PAGE_SIZE.
	 */
	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_SYSFS

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;
}

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_root *kernfs_create_root(struct kernfs_dir_ops *kdops,
				       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_deactivate(struct kernfs_node *kn);
void kernfs_reactivate(struct kernfs_node *kn);
void kernfs_deactivate_self(struct kernfs_node *kn);
void kernfs_reactivate_self(struct kernfs_node *kn);
void kernfs_remove(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, const void *ns);
void kernfs_kill_sb(struct super_block *sb);

void kernfs_init(void);

#else	/* CONFIG_SYSFS */

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 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_root *
kernfs_create_root(struct kernfs_dir_ops *kdops, 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_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, 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_SYSFS */

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 struct dentry *
kernfs_mount(struct file_system_type *fs_type, int flags,
	     struct kernfs_root *root)
{
	return kernfs_mount_ns(fs_type, flags, root, 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>
ea1c472d	18	#include <linux/wait.h>
879f40d1	19
5d60418e TH	20	struct file;
5d60418e TH	21	struct iattr;
dd8a5b03 TH	22	struct seq_file;
dd8a5b03 TH	23	struct vm_area_struct;
4b93dc9b TH	24	struct super_block;
4b93dc9b TH	25	struct file_system_type;
5d60418e	26
c525aadd TH	27	struct kernfs_open_node;
c525aadd TH	28	struct kernfs_iattrs;
cf9e5a73 TH	29
cf9e5a73 TH	30	enum kernfs_node_type {
df23fc39 TH	31	KERNFS_DIR = 0x0001,
	32	KERNFS_FILE = 0x0002,
	33	KERNFS_LINK = 0x0004,
cf9e5a73 TH	34	};
cf9e5a73 TH	35
df23fc39	36	#define KERNFS_TYPE_MASK 0x000f
df23fc39	37	#define KERNFS_FLAG_MASK ~KERNFS_TYPE_MASK
cf9e5a73 TH	38
cf9e5a73 TH	39	enum kernfs_node_flag {
45a140e5	40	KERNFS_JUST_DEACTIVATED = 0x0010, /* used to aid lockdep annotation */
df23fc39 TH	41	KERNFS_NS = 0x0020,
	42	KERNFS_HAS_SEQ_SHOW = 0x0040,
	43	KERNFS_HAS_MMAP = 0x0080,
	44	KERNFS_LOCKDEP = 0x0100,
2063d608	45	KERNFS_STATIC_NAME = 0x0200,
1ae06819 TH	46	KERNFS_SUICIDAL = 0x0400,
1ae06819 TH	47	KERNFS_SUICIDED = 0x0800,
cf9e5a73 TH	48	};
cf9e5a73 TH	49
324a56e1 TH	50	/* type-specific structures for kernfs_node union members */
324a56e1 TH	51	struct kernfs_elem_dir {
cf9e5a73	52	unsigned long subdirs;
adc5e8b5	53	/* children rbtree starts here and goes through kn->rb */
cf9e5a73 TH	54	struct rb_root children;
	55
	56	/*
	57	* The kernfs hierarchy this directory belongs to. This fits
324a56e1	58	* better directly in kernfs_node but is here to save space.
cf9e5a73 TH	59	*/
	60	struct kernfs_root *root;
	61	};
	62
324a56e1 TH	63	struct kernfs_elem_symlink {
324a56e1 TH	64	struct kernfs_node *target_kn;
cf9e5a73 TH	65	};
cf9e5a73 TH	66
324a56e1	67	struct kernfs_elem_attr {
cf9e5a73	68	const struct kernfs_ops *ops;
c525aadd	69	struct kernfs_open_node *open;
cf9e5a73 TH	70	loff_t size;
	71	};
	72
	73	/*
324a56e1 TH	74	* kernfs_node - the building block of kernfs hierarchy. Each and every
324a56e1 TH	75	* kernfs node is represented by single kernfs_node. Most fields are
cf9e5a73 TH	76	* private to kernfs and shouldn't be accessed directly by kernfs users.
cf9e5a73 TH	77	*
324a56e1 TH	78	* As long as s_count reference is held, the kernfs_node itself is
	79	* accessible. Dereferencing elem or any other outer entity requires
	80	* active reference.
cf9e5a73	81	*/
324a56e1	82	struct kernfs_node {
adc5e8b5 TH	83	atomic_t count;
adc5e8b5 TH	84	atomic_t active;
9f010c2a TH	85	int deact_depth;
9f010c2a TH	86	unsigned int hash; /* ns + name hash */
cf9e5a73 TH	87	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	88	struct lockdep_map dep_map;
	89	#endif
	90	/* the following two fields are published */
adc5e8b5 TH	91	struct kernfs_node *parent;
adc5e8b5 TH	92	const char *name;
cf9e5a73	93
adc5e8b5	94	struct rb_node rb;
cf9e5a73	95
adc5e8b5	96	const void ns; / namespace tag */
cf9e5a73	97	union {
adc5e8b5 TH	98	struct kernfs_elem_dir dir;
	99	struct kernfs_elem_symlink symlink;
	100	struct kernfs_elem_attr attr;
cf9e5a73 TH	101	};
	102
	103	void *priv;
	104
adc5e8b5 TH	105	unsigned short flags;
	106	umode_t mode;
	107	unsigned int ino;
c525aadd	108	struct kernfs_iattrs *iattr;
cf9e5a73	109	};
b8441ed2	110
80b9bbef TH	111	/*
	112	* kernfs_dir_ops may be specified on kernfs_create_root() to support
	113	* directory manipulation syscalls. These optional callbacks are invoked
	114	* on the matching syscalls and can perform any kernfs operations which
	115	* don't necessarily have to be the exact operation requested.
	116	*/
	117	struct kernfs_dir_ops {
	118	int (mkdir)(struct kernfs_node parent, const char *name,
	119	umode_t mode);
	120	int (rmdir)(struct kernfs_node kn);
	121	int (rename)(struct kernfs_node kn, struct kernfs_node *new_parent,
	122	const char *new_name);
	123	};
	124
ba7443bc TH	125	struct kernfs_root {
ba7443bc TH	126	/* published fields */
324a56e1	127	struct kernfs_node *kn;
bc755553 TH	128
	129	/* private fields, do not use outside kernfs proper */
	130	struct ida ino_ida;
80b9bbef	131	struct kernfs_dir_ops *dir_ops;
ea1c472d	132	wait_queue_head_t deactivate_waitq;
ba7443bc TH	133	};
ba7443bc TH	134
c525aadd	135	struct kernfs_open_file {
dd8a5b03	136	/* published fields */
324a56e1	137	struct kernfs_node *kn;
dd8a5b03 TH	138	struct file *file;
	139
	140	/* private fields, do not use outside kernfs proper */
	141	struct mutex mutex;
	142	int event;
	143	struct list_head list;
	144
	145	bool mmapped;
	146	const struct vm_operations_struct *vm_ops;
	147	};
	148
f6acf8bb TH	149	struct kernfs_ops {
	150	/*
	151	* Read is handled by either seq_file or raw_read().
	152	*
d19b9846 TH	153	* If seq_show() is present, seq_file path is active. Other seq
	154	* operations are optional and if not implemented, the behavior is
	155	* equivalent to single_open(). @sf->private points to the
c525aadd	156	* associated kernfs_open_file.
f6acf8bb TH	157	*
	158	* read() is bounced through kernel buffer and a read larger than
	159	* PAGE_SIZE results in partial operation of PAGE_SIZE.
	160	*/
	161	int (seq_show)(struct seq_file sf, void *v);
d19b9846 TH	162
	163	void (seq_start)(struct seq_file sf, loff_t ppos);
	164	void (seq_next)(struct seq_file sf, void v, loff_t *ppos);
	165	void (seq_stop)(struct seq_file sf, void *v);
f6acf8bb	166
c525aadd	167	ssize_t (read)(struct kernfs_open_file of, char *buf, size_t bytes,
f6acf8bb TH	168	loff_t off);
	169
	170	/*
	171	* write() is bounced through kernel buffer and a write larger than
	172	* PAGE_SIZE results in partial operation of PAGE_SIZE.
	173	*/
c525aadd	174	ssize_t (write)(struct kernfs_open_file of, char *buf, size_t bytes,
f6acf8bb TH	175	loff_t off);
f6acf8bb TH	176
c525aadd	177	int (mmap)(struct kernfs_open_file of, struct vm_area_struct *vma);
517e64f5 TH	178
	179	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	180	struct lock_class_key lockdep_key;
	181	#endif
f6acf8bb TH	182	};
f6acf8bb TH	183
879f40d1 TH	184	#ifdef CONFIG_SYSFS
879f40d1 TH	185
df23fc39	186	static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
cf9e5a73	187	{
df23fc39	188	return kn->flags & KERNFS_TYPE_MASK;
cf9e5a73 TH	189	}
	190
	191	/**
	192	* kernfs_enable_ns - enable namespace under a directory
324a56e1	193	* @kn: directory of interest, should be empty
cf9e5a73	194	*
324a56e1 TH	195	* This is to be called right after @kn is created to enable namespace
324a56e1 TH	196	* under it. All children of @kn must have non-NULL namespace tags and
cf9e5a73 TH	197	* only the ones which match the super_block's tag will be visible.
cf9e5a73 TH	198	*/
324a56e1	199	static inline void kernfs_enable_ns(struct kernfs_node *kn)
cf9e5a73	200	{
df23fc39	201	WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);
adc5e8b5	202	WARN_ON_ONCE(!RB_EMPTY_ROOT(&kn->dir.children));
df23fc39	203	kn->flags \|= KERNFS_NS;
cf9e5a73 TH	204	}
cf9e5a73 TH	205
ac9bba03 TH	206	/**
ac9bba03 TH	207	* kernfs_ns_enabled - test whether namespace is enabled
324a56e1	208	* @kn: the node to test
ac9bba03 TH	209	*
	210	* Test whether namespace filtering is enabled for the children of @ns.
	211	*/
324a56e1	212	static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
ac9bba03	213	{
df23fc39	214	return kn->flags & KERNFS_NS;
ac9bba03 TH	215	}
ac9bba03 TH	216
324a56e1 TH	217	struct kernfs_node kernfs_find_and_get_ns(struct kernfs_node parent,
	218	const char name, const void ns);
	219	void kernfs_get(struct kernfs_node *kn);
	220	void kernfs_put(struct kernfs_node *kn);
ccf73cf3	221
80b9bbef TH	222	struct kernfs_root kernfs_create_root(struct kernfs_dir_ops kdops,
80b9bbef TH	223	void *priv);
ba7443bc TH	224	void kernfs_destroy_root(struct kernfs_root *root);
ba7443bc TH	225
324a56e1	226	struct kernfs_node kernfs_create_dir_ns(struct kernfs_node parent,
bb8b9d09 TH	227	const char *name, umode_t mode,
bb8b9d09 TH	228	void priv, const void ns);
2063d608 TH	229	struct kernfs_node __kernfs_create_file(struct kernfs_node parent,
	230	const char *name,
	231	umode_t mode, loff_t size,
	232	const struct kernfs_ops *ops,
	233	void priv, const void ns,
	234	bool name_is_static,
	235	struct lock_class_key *key);
324a56e1 TH	236	struct kernfs_node kernfs_create_link(struct kernfs_node parent,
	237	const char *name,
	238	struct kernfs_node *target);
9f010c2a TH	239	void kernfs_deactivate(struct kernfs_node *kn);
	240	void kernfs_reactivate(struct kernfs_node *kn);
	241	void kernfs_deactivate_self(struct kernfs_node *kn);
	242	void kernfs_reactivate_self(struct kernfs_node *kn);
324a56e1	243	void kernfs_remove(struct kernfs_node *kn);
1ae06819	244	bool kernfs_remove_self(struct kernfs_node *kn);
324a56e1	245	int kernfs_remove_by_name_ns(struct kernfs_node parent, const char name,
879f40d1	246	const void *ns);
324a56e1	247	int kernfs_rename_ns(struct kernfs_node kn, struct kernfs_node new_parent,
890ece16	248	const char new_name, const void new_ns);
324a56e1 TH	249	int kernfs_setattr(struct kernfs_node kn, const struct iattr iattr);
324a56e1 TH	250	void kernfs_notify(struct kernfs_node *kn);
879f40d1	251
4b93dc9b TH	252	const void kernfs_super_ns(struct super_block sb);
	253	struct dentry kernfs_mount_ns(struct file_system_type fs_type, int flags,
	254	struct kernfs_root root, const void ns);
	255	void kernfs_kill_sb(struct super_block *sb);
	256
	257	void kernfs_init(void);
	258
879f40d1 TH	259	#else /* CONFIG_SYSFS */
879f40d1 TH	260
df23fc39	261	static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
cf9e5a73 TH	262	{ return 0; } /* whatever */
cf9e5a73 TH	263
324a56e1	264	static inline void kernfs_enable_ns(struct kernfs_node *kn) { }
cf9e5a73	265
324a56e1	266	static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
ac9bba03 TH	267	{ return false; }
ac9bba03 TH	268
324a56e1 TH	269	static inline struct kernfs_node *
324a56e1 TH	270	kernfs_find_and_get_ns(struct kernfs_node parent, const char name,
ccf73cf3 TH	271	const void *ns)
	272	{ return NULL; }
	273
324a56e1 TH	274	static inline void kernfs_get(struct kernfs_node *kn) { }
324a56e1 TH	275	static inline void kernfs_put(struct kernfs_node *kn) { }
ccf73cf3	276
80b9bbef TH	277	static inline struct kernfs_root *
80b9bbef TH	278	kernfs_create_root(struct kernfs_dir_ops kdops, void priv)
ba7443bc TH	279	{ return ERR_PTR(-ENOSYS); }
	280
	281	static inline void kernfs_destroy_root(struct kernfs_root *root) { }
	282
324a56e1	283	static inline struct kernfs_node *
bb8b9d09 TH	284	kernfs_create_dir_ns(struct kernfs_node parent, const char name,
bb8b9d09 TH	285	umode_t mode, void priv, const void ns)
93b2b8e4 TH	286	{ return ERR_PTR(-ENOSYS); }
93b2b8e4 TH	287
324a56e1	288	static inline struct kernfs_node *
2063d608 TH	289	__kernfs_create_file(struct kernfs_node parent, const char name,
	290	umode_t mode, loff_t size, const struct kernfs_ops *ops,
	291	void priv, const void ns, bool name_is_static,
	292	struct lock_class_key *key)
496f7394 TH	293	{ return ERR_PTR(-ENOSYS); }
496f7394 TH	294
324a56e1 TH	295	static inline struct kernfs_node *
	296	kernfs_create_link(struct kernfs_node parent, const char name,
	297	struct kernfs_node *target)
5d0e26bb TH	298	{ return ERR_PTR(-ENOSYS); }
5d0e26bb TH	299
324a56e1	300	static inline void kernfs_remove(struct kernfs_node *kn) { }
879f40d1	301
1ae06819 TH	302	static inline bool kernfs_remove_self(struct kernfs_node *kn)
	303	{ return false; }
	304
324a56e1	305	static inline int kernfs_remove_by_name_ns(struct kernfs_node *kn,
879f40d1 TH	306	const char name, const void ns)
	307	{ return -ENOSYS; }
	308
324a56e1 TH	309	static inline int kernfs_rename_ns(struct kernfs_node *kn,
324a56e1 TH	310	struct kernfs_node *new_parent,
890ece16 TH	311	const char new_name, const void new_ns)
	312	{ return -ENOSYS; }
	313
324a56e1	314	static inline int kernfs_setattr(struct kernfs_node *kn,
5d60418e TH	315	const struct iattr *iattr)
	316	{ return -ENOSYS; }
	317
324a56e1	318	static inline void kernfs_notify(struct kernfs_node *kn) { }
024f6471	319
4b93dc9b TH	320	static inline const void kernfs_super_ns(struct super_block sb)
	321	{ return NULL; }
	322
	323	static inline struct dentry *
	324	kernfs_mount_ns(struct file_system_type *fs_type, int flags,
	325	struct kernfs_root root, const void ns)
	326	{ return ERR_PTR(-ENOSYS); }
	327
	328	static inline void kernfs_kill_sb(struct super_block *sb) { }
	329
	330	static inline void kernfs_init(void) { }
	331
879f40d1 TH	332	#endif /* CONFIG_SYSFS */
879f40d1 TH	333
324a56e1 TH	334	static inline struct kernfs_node *
324a56e1 TH	335	kernfs_find_and_get(struct kernfs_node kn, const char name)
ccf73cf3	336	{
324a56e1	337	return kernfs_find_and_get_ns(kn, name, NULL);
ccf73cf3 TH	338	}
ccf73cf3 TH	339
324a56e1	340	static inline struct kernfs_node *
bb8b9d09 TH	341	kernfs_create_dir(struct kernfs_node parent, const char name, umode_t mode,
bb8b9d09 TH	342	void *priv)
93b2b8e4	343	{
bb8b9d09	344	return kernfs_create_dir_ns(parent, name, mode, priv, NULL);
93b2b8e4 TH	345	}
93b2b8e4 TH	346
324a56e1 TH	347	static inline struct kernfs_node *
324a56e1 TH	348	kernfs_create_file_ns(struct kernfs_node parent, const char name,
517e64f5 TH	349	umode_t mode, loff_t size, const struct kernfs_ops *ops,
	350	void priv, const void ns)
	351	{
	352	struct lock_class_key *key = NULL;
	353
	354	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	355	key = (struct lock_class_key *)&ops->lockdep_key;
	356	#endif
2063d608 TH	357	return __kernfs_create_file(parent, name, mode, size, ops, priv, ns,
2063d608 TH	358	false, key);
517e64f5 TH	359	}
517e64f5 TH	360
324a56e1 TH	361	static inline struct kernfs_node *
324a56e1 TH	362	kernfs_create_file(struct kernfs_node parent, const char name, umode_t mode,
496f7394 TH	363	loff_t size, const struct kernfs_ops ops, void priv)
	364	{
	365	return kernfs_create_file_ns(parent, name, mode, size, ops, priv, NULL);
	366	}
	367
324a56e1	368	static inline int kernfs_remove_by_name(struct kernfs_node *parent,
879f40d1 TH	369	const char *name)
	370	{
	371	return kernfs_remove_by_name_ns(parent, name, NULL);
	372	}
	373
4b93dc9b TH	374	static inline struct dentry *
	375	kernfs_mount(struct file_system_type *fs_type, int flags,
	376	struct kernfs_root *root)
	377	{
	378	return kernfs_mount_ns(fs_type, flags, root, NULL);
	379	}
	380
b8441ed2	381	#endif /* __LINUX_KERNFS_H */