kernfs.h 15.3 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 * kernfs.h - pseudo filesystem decoupled from vfs locking
 *
 * This file is released under the GPLv2.
 */

#ifndef __LINUX_KERNFS_H
#define __LINUX_KERNFS_H

10
#include <linux/kernel.h>
11
#include <linux/err.h>
12 13
#include <linux/list.h>
#include <linux/mutex.h>
14
#include <linux/idr.h>
15
#include <linux/lockdep.h>
16 17
#include <linux/rbtree.h>
#include <linux/atomic.h>
18
#include <linux/wait.h>
19

20
struct file;
21
struct dentry;
22
struct iattr;
23 24
struct seq_file;
struct vm_area_struct;
25 26
struct super_block;
struct file_system_type;
27

28 29
struct kernfs_open_node;
struct kernfs_iattrs;
30 31

enum kernfs_node_type {
32 33 34
	KERNFS_DIR		= 0x0001,
	KERNFS_FILE		= 0x0002,
	KERNFS_LINK		= 0x0004,
35 36
};

37 38
#define KERNFS_TYPE_MASK	0x000f
#define KERNFS_FLAG_MASK	~KERNFS_TYPE_MASK
39 40

enum kernfs_node_flag {
41
	KERNFS_ACTIVATED	= 0x0010,
42 43 44 45
	KERNFS_NS		= 0x0020,
	KERNFS_HAS_SEQ_SHOW	= 0x0040,
	KERNFS_HAS_MMAP		= 0x0080,
	KERNFS_LOCKDEP		= 0x0100,
46 47
	KERNFS_SUICIDAL		= 0x0400,
	KERNFS_SUICIDED		= 0x0800,
48
	KERNFS_EMPTY_DIR	= 0x1000,
49 50
};

51 52
/* @flags for kernfs_create_root() */
enum kernfs_root_flag {
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
	/*
	 * 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,
71 72
};

73 74
/* type-specific structures for kernfs_node union members */
struct kernfs_elem_dir {
75
	unsigned long		subdirs;
76
	/* children rbtree starts here and goes through kn->rb */
77 78 79 80
	struct rb_root		children;

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

86 87
struct kernfs_elem_symlink {
	struct kernfs_node	*target_kn;
88 89
};

90
struct kernfs_elem_attr {
91
	const struct kernfs_ops	*ops;
92
	struct kernfs_open_node	*open;
93
	loff_t			size;
94
	struct kernfs_node	*notify_next;	/* for kernfs_notify() */
95 96 97
};

/*
98 99
 * kernfs_node - the building block of kernfs hierarchy.  Each and every
 * kernfs node is represented by single kernfs_node.  Most fields are
100 101
 * private to kernfs and shouldn't be accessed directly by kernfs users.
 *
102 103 104
 * As long as s_count reference is held, the kernfs_node itself is
 * accessible.  Dereferencing elem or any other outer entity requires
 * active reference.
105
 */
106
struct kernfs_node {
107 108
	atomic_t		count;
	atomic_t		active;
109 110 111
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	struct lockdep_map	dep_map;
#endif
112 113 114 115 116 117
	/*
	 * 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.
	 */
118 119
	struct kernfs_node	*parent;
	const char		*name;
120

121
	struct rb_node		rb;
122

123
	const void		*ns;	/* namespace tag */
124
	unsigned int		hash;	/* ns + name hash */
125
	union {
126 127 128
		struct kernfs_elem_dir		dir;
		struct kernfs_elem_symlink	symlink;
		struct kernfs_elem_attr		attr;
129 130 131 132
	};

	void			*priv;

133 134 135
	unsigned short		flags;
	umode_t			mode;
	unsigned int		ino;
136
	struct kernfs_iattrs	*iattr;
137
};
138

Tejun Heo's avatar
Tejun Heo committed
139
/*
140 141 142 143 144
 * 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.
Tejun Heo's avatar
Tejun Heo committed
145
 */
146
struct kernfs_syscall_ops {
147 148 149
	int (*remount_fs)(struct kernfs_root *root, int *flags, char *data);
	int (*show_options)(struct seq_file *sf, struct kernfs_root *root);

Tejun Heo's avatar
Tejun Heo committed
150 151 152 153 154
	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);
155 156
	int (*show_path)(struct seq_file *sf, struct kernfs_node *kn,
			 struct kernfs_root *root);
Tejun Heo's avatar
Tejun Heo committed
157 158
};

159 160
struct kernfs_root {
	/* published fields */
161
	struct kernfs_node	*kn;
162
	unsigned int		flags;	/* KERNFS_ROOT_* flags */
163 164 165

	/* private fields, do not use outside kernfs proper */
	struct ida		ino_ida;
166
	struct kernfs_syscall_ops *syscall_ops;
167 168 169 170

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

171
	wait_queue_head_t	deactivate_waitq;
172 173
};

174
struct kernfs_open_file {
175
	/* published fields */
176
	struct kernfs_node	*kn;
177
	struct file		*file;
178
	void			*priv;
179 180 181

	/* private fields, do not use outside kernfs proper */
	struct mutex		mutex;
182
	struct mutex		prealloc_mutex;
183 184
	int			event;
	struct list_head	list;
185
	char			*prealloc_buf;
186

187
	size_t			atomic_write_len;
188 189 190 191
	bool			mmapped;
	const struct vm_operations_struct *vm_ops;
};

192 193 194 195
struct kernfs_ops {
	/*
	 * Read is handled by either seq_file or raw_read().
	 *
196 197 198
	 * 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
199
	 * associated kernfs_open_file.
200 201 202 203 204
	 *
	 * 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);
205 206 207 208

	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);
209

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

	/*
214 215 216 217 218
	 * 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.
219
	 */
220
	size_t atomic_write_len;
221 222 223 224 225 226 227
	/*
	 * "prealloc" causes a buffer to be allocated at open for
	 * all read/write requests.  As ->seq_show uses seq_read()
	 * which does its own allocation, it is incompatible with
	 * ->prealloc.  Provide ->read and ->write with ->prealloc.
	 */
	bool prealloc;
228
	ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes,
229 230
			 loff_t off);

231
	int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma);
232 233 234 235

#ifdef CONFIG_DEBUG_LOCK_ALLOC
	struct lock_class_key	lockdep_key;
#endif
236 237
};

Tejun Heo's avatar
Tejun Heo committed
238
#ifdef CONFIG_KERNFS
239

240
static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
241
{
242
	return kn->flags & KERNFS_TYPE_MASK;
243 244 245 246
}

/**
 * kernfs_enable_ns - enable namespace under a directory
247
 * @kn: directory of interest, should be empty
248
 *
249 250
 * 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
251 252
 * only the ones which match the super_block's tag will be visible.
 */
253
static inline void kernfs_enable_ns(struct kernfs_node *kn)
254
{
255
	WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);
256
	WARN_ON_ONCE(!RB_EMPTY_ROOT(&kn->dir.children));
257
	kn->flags |= KERNFS_NS;
258 259
}

260 261
/**
 * kernfs_ns_enabled - test whether namespace is enabled
262
 * @kn: the node to test
263 264 265
 *
 * Test whether namespace filtering is enabled for the children of @ns.
 */
266
static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
267
{
268
	return kn->flags & KERNFS_NS;
269 270
}

271
int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen);
272
size_t kernfs_path_len(struct kernfs_node *kn);
273 274 275
int kernfs_path_from_node(struct kernfs_node *root_kn, struct kernfs_node *kn,
			  char *buf, size_t buflen);
char *kernfs_path(struct kernfs_node *kn, char *buf, size_t buflen);
276 277 278
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);
279 280
struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
					   const char *name, const void *ns);
281 282
struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent,
					   const char *path, const void *ns);
283 284
void kernfs_get(struct kernfs_node *kn);
void kernfs_put(struct kernfs_node *kn);
285

286 287
struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry);
struct kernfs_root *kernfs_root_from_sb(struct super_block *sb);
288
struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn);
289

290 291
struct dentry *kernfs_node_dentry(struct kernfs_node *kn,
				  struct super_block *sb);
292
struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
293
				       unsigned int flags, void *priv);
294 295
void kernfs_destroy_root(struct kernfs_root *root);

296
struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
297 298
					 const char *name, umode_t mode,
					 void *priv, const void *ns);
299 300
struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent,
					    const char *name);
301 302 303 304 305 306
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,
					 struct lock_class_key *key);
307 308 309
struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
				       const char *name,
				       struct kernfs_node *target);
310
void kernfs_activate(struct kernfs_node *kn);
311
void kernfs_remove(struct kernfs_node *kn);
312 313 314
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);
315
int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
316
			     const void *ns);
317
int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
318
		     const char *new_name, const void *new_ns);
319 320
int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr);
void kernfs_notify(struct kernfs_node *kn);
321

322 323
const void *kernfs_super_ns(struct super_block *sb);
struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
324 325
			       struct kernfs_root *root, unsigned long magic,
			       bool *new_sb_created, const void *ns);
326
void kernfs_kill_sb(struct super_block *sb);
327
struct super_block *kernfs_pin_sb(struct kernfs_root *root, const void *ns);
328 329 330

void kernfs_init(void);

Tejun Heo's avatar
Tejun Heo committed
331
#else	/* CONFIG_KERNFS */
332

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

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

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

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

344 345 346
static inline size_t kernfs_path_len(struct kernfs_node *kn)
{ return 0; }

347 348
static inline char *kernfs_path(struct kernfs_node *kn, char *buf,
				size_t buflen)
349 350 351 352 353 354 355 356
{ 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; }

357 358
static inline struct kernfs_node *
kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name,
359 360
		       const void *ns)
{ return NULL; }
361 362 363 364
static inline struct kernfs_node *
kernfs_walk_and_get_ns(struct kernfs_node *parent, const char *path,
		       const void *ns)
{ return NULL; }
365

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

369 370 371 372 373 374
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; }

375 376 377 378
static inline struct inode *
kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn)
{ return NULL; }

Tejun Heo's avatar
Tejun Heo committed
379
static inline struct kernfs_root *
380 381
kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags,
		   void *priv)
382 383 384 385
{ return ERR_PTR(-ENOSYS); }

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

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

391
static inline struct kernfs_node *
392 393
__kernfs_create_file(struct kernfs_node *parent, const char *name,
		     umode_t mode, loff_t size, const struct kernfs_ops *ops,
394
		     void *priv, const void *ns, struct lock_class_key *key)
395 396
{ return ERR_PTR(-ENOSYS); }

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

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

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

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

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

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

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

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

424 425 426 427 428
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,
429 430
		struct kernfs_root *root, unsigned long magic,
		bool *new_sb_created, const void *ns)
431 432 433 434 435 436
{ return ERR_PTR(-ENOSYS); }

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

static inline void kernfs_init(void) { }

Tejun Heo's avatar
Tejun Heo committed
437
#endif	/* CONFIG_KERNFS */
438

439 440
static inline struct kernfs_node *
kernfs_find_and_get(struct kernfs_node *kn, const char *name)
441
{
442
	return kernfs_find_and_get_ns(kn, name, NULL);
443 444
}

445 446 447 448 449 450
static inline struct kernfs_node *
kernfs_walk_and_get(struct kernfs_node *kn, const char *path)
{
	return kernfs_walk_and_get_ns(kn, path, NULL);
}

451
static inline struct kernfs_node *
452 453
kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode,
		  void *priv)
454
{
455
	return kernfs_create_dir_ns(parent, name, mode, priv, NULL);
456 457
}

458 459
static inline struct kernfs_node *
kernfs_create_file_ns(struct kernfs_node *parent, const char *name,
460 461 462 463 464 465 466 467
		      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
468
	return __kernfs_create_file(parent, name, mode, size, ops, priv, ns,
469
				    key);
470 471
}

472 473
static inline struct kernfs_node *
kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode,
474 475 476 477 478
		   loff_t size, const struct kernfs_ops *ops, void *priv)
{
	return kernfs_create_file_ns(parent, name, mode, size, ops, priv, NULL);
}

479
static inline int kernfs_remove_by_name(struct kernfs_node *parent,
480 481 482 483 484
					const char *name)
{
	return kernfs_remove_by_name_ns(parent, name, NULL);
}

485 486 487 488 489 490 491
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);
}

492 493
static inline struct dentry *
kernfs_mount(struct file_system_type *fs_type, int flags,
494 495
		struct kernfs_root *root, unsigned long magic,
		bool *new_sb_created)
496
{
497 498
	return kernfs_mount_ns(fs_type, flags, root,
				magic, new_sb_created, NULL);
499 500
}

501
#endif	/* __LINUX_KERNFS_H */