2 * kernfs.h - pseudo filesystem decoupled from vfs locking
4 * This file is released under the GPLv2.
7 #ifndef __LINUX_KERNFS_H
8 #define __LINUX_KERNFS_H
10 #include <linux/kernel.h>
11 #include <linux/err.h>
12 #include <linux/list.h>
13 #include <linux/mutex.h>
14 #include <linux/idr.h>
15 #include <linux/lockdep.h>
16 #include <linux/rbtree.h>
17 #include <linux/atomic.h>
18 #include <linux/uidgid.h>
19 #include <linux/wait.h>
25 struct vm_area_struct;
27 struct file_system_type;
28 struct poll_table_struct;
30 struct kernfs_open_node;
33 enum kernfs_node_type {
39 #define KERNFS_TYPE_MASK 0x000f
40 #define KERNFS_FLAG_MASK ~KERNFS_TYPE_MASK
42 enum kernfs_node_flag {
43 KERNFS_ACTIVATED = 0x0010,
45 KERNFS_HAS_SEQ_SHOW = 0x0040,
46 KERNFS_HAS_MMAP = 0x0080,
47 KERNFS_LOCKDEP = 0x0100,
48 KERNFS_SUICIDAL = 0x0400,
49 KERNFS_SUICIDED = 0x0800,
50 KERNFS_EMPTY_DIR = 0x1000,
51 KERNFS_HAS_RELEASE = 0x2000,
54 /* @flags for kernfs_create_root() */
55 enum kernfs_root_flag {
57 * kernfs_nodes are created in the deactivated state and invisible.
58 * They require explicit kernfs_activate() to become visible. This
59 * can be used to make related nodes become visible atomically
60 * after all nodes are created successfully.
62 KERNFS_ROOT_CREATE_DEACTIVATED = 0x0001,
65 * For regular flies, if the opener has CAP_DAC_OVERRIDE, open(2)
66 * succeeds regardless of the RW permissions. sysfs had an extra
67 * layer of enforcement where open(2) fails with -EACCES regardless
68 * of CAP_DAC_OVERRIDE if the permission doesn't have the
69 * respective read or write access at all (none of S_IRUGO or
70 * S_IWUGO) or the respective operation isn't implemented. The
71 * following flag enables that behavior.
73 KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK = 0x0002,
76 * The filesystem supports exportfs operation, so userspace can use
77 * fhandle to access nodes of the fs.
79 KERNFS_ROOT_SUPPORT_EXPORTOP = 0x0004,
82 /* type-specific structures for kernfs_node union members */
83 struct kernfs_elem_dir {
84 unsigned long subdirs;
85 /* children rbtree starts here and goes through kn->rb */
86 struct rb_root children;
89 * The kernfs hierarchy this directory belongs to. This fits
90 * better directly in kernfs_node but is here to save space.
92 struct kernfs_root *root;
95 struct kernfs_elem_symlink {
96 struct kernfs_node *target_kn;
99 struct kernfs_elem_attr {
100 const struct kernfs_ops *ops;
101 struct kernfs_open_node *open;
103 struct kernfs_node *notify_next; /* for kernfs_notify() */
106 /* represent a kernfs node */
107 union kernfs_node_id {
110 * blktrace will export this struct as a simplified 'struct
111 * fid' (which is a big data struction), so userspace can use
112 * it to find kernfs node. The layout must match the first two
113 * fields of 'struct fid' exactly.
122 * kernfs_node - the building block of kernfs hierarchy. Each and every
123 * kernfs node is represented by single kernfs_node. Most fields are
124 * private to kernfs and shouldn't be accessed directly by kernfs users.
126 * As long as s_count reference is held, the kernfs_node itself is
127 * accessible. Dereferencing elem or any other outer entity requires
133 #ifdef CONFIG_DEBUG_LOCK_ALLOC
134 struct lockdep_map dep_map;
137 * Use kernfs_get_parent() and kernfs_name/path() instead of
138 * accessing the following two fields directly. If the node is
139 * never moved to a different parent, it is safe to access the
142 struct kernfs_node *parent;
147 const void *ns; /* namespace tag */
148 unsigned int hash; /* ns + name hash */
150 struct kernfs_elem_dir dir;
151 struct kernfs_elem_symlink symlink;
152 struct kernfs_elem_attr attr;
157 union kernfs_node_id id;
158 unsigned short flags;
160 struct kernfs_iattrs *iattr;
164 * kernfs_syscall_ops may be specified on kernfs_create_root() to support
165 * syscalls. These optional callbacks are invoked on the matching syscalls
166 * and can perform any kernfs operations which don't necessarily have to be
167 * the exact operation requested. An active reference is held for each
168 * kernfs_node parameter.
170 struct kernfs_syscall_ops {
171 int (*remount_fs)(struct kernfs_root *root, int *flags, char *data);
172 int (*show_options)(struct seq_file *sf, struct kernfs_root *root);
174 int (*mkdir)(struct kernfs_node *parent, const char *name,
176 int (*rmdir)(struct kernfs_node *kn);
177 int (*rename)(struct kernfs_node *kn, struct kernfs_node *new_parent,
178 const char *new_name);
179 int (*show_path)(struct seq_file *sf, struct kernfs_node *kn,
180 struct kernfs_root *root);
184 /* published fields */
185 struct kernfs_node *kn;
186 unsigned int flags; /* KERNFS_ROOT_* flags */
188 /* private fields, do not use outside kernfs proper */
191 struct kernfs_syscall_ops *syscall_ops;
193 /* list of kernfs_super_info of this root, protected by kernfs_mutex */
194 struct list_head supers;
196 wait_queue_head_t deactivate_waitq;
199 struct kernfs_open_file {
200 /* published fields */
201 struct kernfs_node *kn;
203 struct seq_file *seq_file;
206 /* private fields, do not use outside kernfs proper */
208 struct mutex prealloc_mutex;
210 struct list_head list;
213 size_t atomic_write_len;
216 const struct vm_operations_struct *vm_ops;
221 * Optional open/release methods. Both are called with
222 * @of->seq_file populated.
224 int (*open)(struct kernfs_open_file *of);
225 void (*release)(struct kernfs_open_file *of);
228 * Read is handled by either seq_file or raw_read().
230 * If seq_show() is present, seq_file path is active. Other seq
231 * operations are optional and if not implemented, the behavior is
232 * equivalent to single_open(). @sf->private points to the
233 * associated kernfs_open_file.
235 * read() is bounced through kernel buffer and a read larger than
236 * PAGE_SIZE results in partial operation of PAGE_SIZE.
238 int (*seq_show)(struct seq_file *sf, void *v);
240 void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
241 void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
242 void (*seq_stop)(struct seq_file *sf, void *v);
244 ssize_t (*read)(struct kernfs_open_file *of, char *buf, size_t bytes,
248 * write() is bounced through kernel buffer. If atomic_write_len
249 * is not set, a write larger than PAGE_SIZE results in partial
250 * operations of PAGE_SIZE chunks. If atomic_write_len is set,
251 * writes upto the specified size are executed atomically but
252 * larger ones are rejected with -E2BIG.
254 size_t atomic_write_len;
256 * "prealloc" causes a buffer to be allocated at open for
257 * all read/write requests. As ->seq_show uses seq_read()
258 * which does its own allocation, it is incompatible with
259 * ->prealloc. Provide ->read and ->write with ->prealloc.
262 ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes,
265 __poll_t (*poll)(struct kernfs_open_file *of,
266 struct poll_table_struct *pt);
268 int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma);
270 #ifdef CONFIG_DEBUG_LOCK_ALLOC
271 struct lock_class_key lockdep_key;
277 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
279 return kn->flags & KERNFS_TYPE_MASK;
283 * kernfs_enable_ns - enable namespace under a directory
284 * @kn: directory of interest, should be empty
286 * This is to be called right after @kn is created to enable namespace
287 * under it. All children of @kn must have non-NULL namespace tags and
288 * only the ones which match the super_block's tag will be visible.
290 static inline void kernfs_enable_ns(struct kernfs_node *kn)
292 WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);
293 WARN_ON_ONCE(!RB_EMPTY_ROOT(&kn->dir.children));
294 kn->flags |= KERNFS_NS;
298 * kernfs_ns_enabled - test whether namespace is enabled
299 * @kn: the node to test
301 * Test whether namespace filtering is enabled for the children of @ns.
303 static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
305 return kn->flags & KERNFS_NS;
308 int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen);
309 int kernfs_path_from_node(struct kernfs_node *root_kn, struct kernfs_node *kn,
310 char *buf, size_t buflen);
311 void pr_cont_kernfs_name(struct kernfs_node *kn);
312 void pr_cont_kernfs_path(struct kernfs_node *kn);
313 struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn);
314 struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
315 const char *name, const void *ns);
316 struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent,
317 const char *path, const void *ns);
318 void kernfs_get(struct kernfs_node *kn);
319 void kernfs_put(struct kernfs_node *kn);
321 struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry);
322 struct kernfs_root *kernfs_root_from_sb(struct super_block *sb);
323 struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn);
325 struct dentry *kernfs_node_dentry(struct kernfs_node *kn,
326 struct super_block *sb);
327 struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
328 unsigned int flags, void *priv);
329 void kernfs_destroy_root(struct kernfs_root *root);
331 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
332 const char *name, umode_t mode,
333 kuid_t uid, kgid_t gid,
334 void *priv, const void *ns);
335 struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent,
337 struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
338 const char *name, umode_t mode,
339 kuid_t uid, kgid_t gid,
341 const struct kernfs_ops *ops,
342 void *priv, const void *ns,
343 struct lock_class_key *key);
344 struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
346 struct kernfs_node *target);
347 void kernfs_activate(struct kernfs_node *kn);
348 void kernfs_remove(struct kernfs_node *kn);
349 void kernfs_break_active_protection(struct kernfs_node *kn);
350 void kernfs_unbreak_active_protection(struct kernfs_node *kn);
351 bool kernfs_remove_self(struct kernfs_node *kn);
352 int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
354 int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
355 const char *new_name, const void *new_ns);
356 int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr);
357 __poll_t kernfs_generic_poll(struct kernfs_open_file *of,
358 struct poll_table_struct *pt);
359 void kernfs_notify(struct kernfs_node *kn);
361 const void *kernfs_super_ns(struct super_block *sb);
362 struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
363 struct kernfs_root *root, unsigned long magic,
364 bool *new_sb_created, const void *ns);
365 void kernfs_kill_sb(struct super_block *sb);
366 struct super_block *kernfs_pin_sb(struct kernfs_root *root, const void *ns);
368 void kernfs_init(void);
370 struct kernfs_node *kernfs_get_node_by_id(struct kernfs_root *root,
371 const union kernfs_node_id *id);
372 #else /* CONFIG_KERNFS */
374 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
375 { return 0; } /* whatever */
377 static inline void kernfs_enable_ns(struct kernfs_node *kn) { }
379 static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
382 static inline int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
385 static inline int kernfs_path_from_node(struct kernfs_node *root_kn,
386 struct kernfs_node *kn,
387 char *buf, size_t buflen)
390 static inline void pr_cont_kernfs_name(struct kernfs_node *kn) { }
391 static inline void pr_cont_kernfs_path(struct kernfs_node *kn) { }
393 static inline struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
396 static inline struct kernfs_node *
397 kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name,
400 static inline struct kernfs_node *
401 kernfs_walk_and_get_ns(struct kernfs_node *parent, const char *path,
405 static inline void kernfs_get(struct kernfs_node *kn) { }
406 static inline void kernfs_put(struct kernfs_node *kn) { }
408 static inline struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
411 static inline struct kernfs_root *kernfs_root_from_sb(struct super_block *sb)
414 static inline struct inode *
415 kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn)
418 static inline struct kernfs_root *
419 kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags,
421 { return ERR_PTR(-ENOSYS); }
423 static inline void kernfs_destroy_root(struct kernfs_root *root) { }
425 static inline struct kernfs_node *
426 kernfs_create_dir_ns(struct kernfs_node *parent, const char *name,
427 umode_t mode, kuid_t uid, kgid_t gid,
428 void *priv, const void *ns)
429 { return ERR_PTR(-ENOSYS); }
431 static inline struct kernfs_node *
432 __kernfs_create_file(struct kernfs_node *parent, const char *name,
433 umode_t mode, kuid_t uid, kgid_t gid,
434 loff_t size, const struct kernfs_ops *ops,
435 void *priv, const void *ns, struct lock_class_key *key)
436 { return ERR_PTR(-ENOSYS); }
438 static inline struct kernfs_node *
439 kernfs_create_link(struct kernfs_node *parent, const char *name,
440 struct kernfs_node *target)
441 { return ERR_PTR(-ENOSYS); }
443 static inline void kernfs_activate(struct kernfs_node *kn) { }
445 static inline void kernfs_remove(struct kernfs_node *kn) { }
447 static inline bool kernfs_remove_self(struct kernfs_node *kn)
450 static inline int kernfs_remove_by_name_ns(struct kernfs_node *kn,
451 const char *name, const void *ns)
454 static inline int kernfs_rename_ns(struct kernfs_node *kn,
455 struct kernfs_node *new_parent,
456 const char *new_name, const void *new_ns)
459 static inline int kernfs_setattr(struct kernfs_node *kn,
460 const struct iattr *iattr)
463 static inline void kernfs_notify(struct kernfs_node *kn) { }
465 static inline const void *kernfs_super_ns(struct super_block *sb)
468 static inline struct dentry *
469 kernfs_mount_ns(struct file_system_type *fs_type, int flags,
470 struct kernfs_root *root, unsigned long magic,
471 bool *new_sb_created, const void *ns)
472 { return ERR_PTR(-ENOSYS); }
474 static inline void kernfs_kill_sb(struct super_block *sb) { }
476 static inline void kernfs_init(void) { }
478 #endif /* CONFIG_KERNFS */
481 * kernfs_path - build full path of a given node
482 * @kn: kernfs_node of interest
483 * @buf: buffer to copy @kn's name into
484 * @buflen: size of @buf
486 * If @kn is NULL result will be "(null)".
488 * Returns the length of the full path. If the full length is equal to or
489 * greater than @buflen, @buf contains the truncated path with the trailing
490 * '\0'. On error, -errno is returned.
492 static inline int kernfs_path(struct kernfs_node *kn, char *buf, size_t buflen)
494 return kernfs_path_from_node(kn, NULL, buf, buflen);
497 static inline struct kernfs_node *
498 kernfs_find_and_get(struct kernfs_node *kn, const char *name)
500 return kernfs_find_and_get_ns(kn, name, NULL);
503 static inline struct kernfs_node *
504 kernfs_walk_and_get(struct kernfs_node *kn, const char *path)
506 return kernfs_walk_and_get_ns(kn, path, NULL);
509 static inline struct kernfs_node *
510 kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode,
513 return kernfs_create_dir_ns(parent, name, mode,
514 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID,
518 static inline struct kernfs_node *
519 kernfs_create_file_ns(struct kernfs_node *parent, const char *name,
520 umode_t mode, kuid_t uid, kgid_t gid,
521 loff_t size, const struct kernfs_ops *ops,
522 void *priv, const void *ns)
524 struct lock_class_key *key = NULL;
526 #ifdef CONFIG_DEBUG_LOCK_ALLOC
527 key = (struct lock_class_key *)&ops->lockdep_key;
529 return __kernfs_create_file(parent, name, mode, uid, gid,
530 size, ops, priv, ns, key);
533 static inline struct kernfs_node *
534 kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode,
535 loff_t size, const struct kernfs_ops *ops, void *priv)
537 return kernfs_create_file_ns(parent, name, mode,
538 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID,
539 size, ops, priv, NULL);
542 static inline int kernfs_remove_by_name(struct kernfs_node *parent,
545 return kernfs_remove_by_name_ns(parent, name, NULL);
548 static inline int kernfs_rename(struct kernfs_node *kn,
549 struct kernfs_node *new_parent,
550 const char *new_name)
552 return kernfs_rename_ns(kn, new_parent, new_name, NULL);
555 static inline struct dentry *
556 kernfs_mount(struct file_system_type *fs_type, int flags,
557 struct kernfs_root *root, unsigned long magic,
558 bool *new_sb_created)
560 return kernfs_mount_ns(fs_type, flags, root,
561 magic, new_sb_created, NULL);
564 #endif /* __LINUX_KERNFS_H */