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/wait.h>
24 struct vm_area_struct;
26 struct file_system_type;
28 struct kernfs_open_node;
31 enum kernfs_node_type {
37 #define KERNFS_TYPE_MASK 0x000f
38 #define KERNFS_FLAG_MASK ~KERNFS_TYPE_MASK
40 enum kernfs_node_flag {
41 KERNFS_ACTIVATED = 0x0010,
43 KERNFS_HAS_SEQ_SHOW = 0x0040,
44 KERNFS_HAS_MMAP = 0x0080,
45 KERNFS_LOCKDEP = 0x0100,
46 KERNFS_SUICIDAL = 0x0400,
47 KERNFS_SUICIDED = 0x0800,
48 KERNFS_EMPTY_DIR = 0x1000,
51 /* @flags for kernfs_create_root() */
52 enum kernfs_root_flag {
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.
59 KERNFS_ROOT_CREATE_DEACTIVATED = 0x0001,
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.
70 KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK = 0x0002,
73 /* type-specific structures for kernfs_node union members */
74 struct kernfs_elem_dir {
75 unsigned long subdirs;
76 /* children rbtree starts here and goes through kn->rb */
77 struct rb_root children;
80 * The kernfs hierarchy this directory belongs to. This fits
81 * better directly in kernfs_node but is here to save space.
83 struct kernfs_root *root;
86 struct kernfs_elem_symlink {
87 struct kernfs_node *target_kn;
90 struct kernfs_elem_attr {
91 const struct kernfs_ops *ops;
92 struct kernfs_open_node *open;
94 struct kernfs_node *notify_next; /* for kernfs_notify() */
98 * kernfs_node - the building block of kernfs hierarchy. Each and every
99 * kernfs node is represented by single kernfs_node. Most fields are
100 * private to kernfs and shouldn't be accessed directly by kernfs users.
102 * As long as s_count reference is held, the kernfs_node itself is
103 * accessible. Dereferencing elem or any other outer entity requires
109 #ifdef CONFIG_DEBUG_LOCK_ALLOC
110 struct lockdep_map dep_map;
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
118 struct kernfs_node *parent;
123 const void *ns; /* namespace tag */
124 unsigned int hash; /* ns + name hash */
126 struct kernfs_elem_dir dir;
127 struct kernfs_elem_symlink symlink;
128 struct kernfs_elem_attr attr;
133 unsigned short flags;
136 struct kernfs_iattrs *iattr;
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.
146 struct kernfs_syscall_ops {
147 int (*remount_fs)(struct kernfs_root *root, int *flags, char *data);
148 int (*show_options)(struct seq_file *sf, struct kernfs_root *root);
150 int (*mkdir)(struct kernfs_node *parent, const char *name,
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 int (*show_path)(struct seq_file *sf, struct kernfs_node *kn,
156 struct kernfs_root *root);
160 /* published fields */
161 struct kernfs_node *kn;
162 unsigned int flags; /* KERNFS_ROOT_* flags */
164 /* private fields, do not use outside kernfs proper */
166 struct kernfs_syscall_ops *syscall_ops;
168 /* list of kernfs_super_info of this root, protected by kernfs_mutex */
169 struct list_head supers;
171 wait_queue_head_t deactivate_waitq;
174 struct kernfs_open_file {
175 /* published fields */
176 struct kernfs_node *kn;
180 /* private fields, do not use outside kernfs proper */
183 struct list_head list;
186 size_t atomic_write_len;
188 const struct vm_operations_struct *vm_ops;
193 * Read is handled by either seq_file or raw_read().
195 * If seq_show() is present, seq_file path is active. Other seq
196 * operations are optional and if not implemented, the behavior is
197 * equivalent to single_open(). @sf->private points to the
198 * associated kernfs_open_file.
200 * read() is bounced through kernel buffer and a read larger than
201 * PAGE_SIZE results in partial operation of PAGE_SIZE.
203 int (*seq_show)(struct seq_file *sf, void *v);
205 void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
206 void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
207 void (*seq_stop)(struct seq_file *sf, void *v);
209 ssize_t (*read)(struct kernfs_open_file *of, char *buf, size_t bytes,
213 * write() is bounced through kernel buffer. If atomic_write_len
214 * is not set, a write larger than PAGE_SIZE results in partial
215 * operations of PAGE_SIZE chunks. If atomic_write_len is set,
216 * writes upto the specified size are executed atomically but
217 * larger ones are rejected with -E2BIG.
219 size_t atomic_write_len;
221 * "prealloc" causes a buffer to be allocated at open for
222 * all read/write requests. As ->seq_show uses seq_read()
223 * which does its own allocation, it is incompatible with
224 * ->prealloc. Provide ->read and ->write with ->prealloc.
227 ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes,
230 int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma);
232 #ifdef CONFIG_DEBUG_LOCK_ALLOC
233 struct lock_class_key lockdep_key;
239 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
241 return kn->flags & KERNFS_TYPE_MASK;
245 * kernfs_enable_ns - enable namespace under a directory
246 * @kn: directory of interest, should be empty
248 * This is to be called right after @kn is created to enable namespace
249 * under it. All children of @kn must have non-NULL namespace tags and
250 * only the ones which match the super_block's tag will be visible.
252 static inline void kernfs_enable_ns(struct kernfs_node *kn)
254 WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);
255 WARN_ON_ONCE(!RB_EMPTY_ROOT(&kn->dir.children));
256 kn->flags |= KERNFS_NS;
260 * kernfs_ns_enabled - test whether namespace is enabled
261 * @kn: the node to test
263 * Test whether namespace filtering is enabled for the children of @ns.
265 static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
267 return kn->flags & KERNFS_NS;
270 int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen);
271 size_t kernfs_path_len(struct kernfs_node *kn);
272 int kernfs_path_from_node(struct kernfs_node *root_kn, struct kernfs_node *kn,
273 char *buf, size_t buflen);
274 char *kernfs_path(struct kernfs_node *kn, char *buf, size_t buflen);
275 void pr_cont_kernfs_name(struct kernfs_node *kn);
276 void pr_cont_kernfs_path(struct kernfs_node *kn);
277 struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn);
278 struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
279 const char *name, const void *ns);
280 struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent,
281 const char *path, const void *ns);
282 void kernfs_get(struct kernfs_node *kn);
283 void kernfs_put(struct kernfs_node *kn);
285 struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry);
286 struct kernfs_root *kernfs_root_from_sb(struct super_block *sb);
287 struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn);
289 struct dentry *kernfs_node_dentry(struct kernfs_node *kn,
290 struct super_block *sb);
291 struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
292 unsigned int flags, void *priv);
293 void kernfs_destroy_root(struct kernfs_root *root);
295 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
296 const char *name, umode_t mode,
297 void *priv, const void *ns);
298 struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent,
300 struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
302 umode_t mode, loff_t size,
303 const struct kernfs_ops *ops,
304 void *priv, const void *ns,
305 struct lock_class_key *key);
306 struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
308 struct kernfs_node *target);
309 void kernfs_activate(struct kernfs_node *kn);
310 void kernfs_remove(struct kernfs_node *kn);
311 void kernfs_break_active_protection(struct kernfs_node *kn);
312 void kernfs_unbreak_active_protection(struct kernfs_node *kn);
313 bool kernfs_remove_self(struct kernfs_node *kn);
314 int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
316 int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
317 const char *new_name, const void *new_ns);
318 int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr);
319 void kernfs_notify(struct kernfs_node *kn);
321 const void *kernfs_super_ns(struct super_block *sb);
322 struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
323 struct kernfs_root *root, unsigned long magic,
324 bool *new_sb_created, const void *ns);
325 void kernfs_kill_sb(struct super_block *sb);
326 struct super_block *kernfs_pin_sb(struct kernfs_root *root, const void *ns);
328 void kernfs_init(void);
330 #else /* CONFIG_KERNFS */
332 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
333 { return 0; } /* whatever */
335 static inline void kernfs_enable_ns(struct kernfs_node *kn) { }
337 static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
340 static inline int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
343 static inline size_t kernfs_path_len(struct kernfs_node *kn)
346 static inline char *kernfs_path(struct kernfs_node *kn, char *buf,
350 static inline void pr_cont_kernfs_name(struct kernfs_node *kn) { }
351 static inline void pr_cont_kernfs_path(struct kernfs_node *kn) { }
353 static inline struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
356 static inline struct kernfs_node *
357 kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name,
360 static inline struct kernfs_node *
361 kernfs_walk_and_get_ns(struct kernfs_node *parent, const char *path,
365 static inline void kernfs_get(struct kernfs_node *kn) { }
366 static inline void kernfs_put(struct kernfs_node *kn) { }
368 static inline struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
371 static inline struct kernfs_root *kernfs_root_from_sb(struct super_block *sb)
374 static inline struct inode *
375 kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn)
378 static inline struct kernfs_root *
379 kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags,
381 { return ERR_PTR(-ENOSYS); }
383 static inline void kernfs_destroy_root(struct kernfs_root *root) { }
385 static inline struct kernfs_node *
386 kernfs_create_dir_ns(struct kernfs_node *parent, const char *name,
387 umode_t mode, void *priv, const void *ns)
388 { return ERR_PTR(-ENOSYS); }
390 static inline struct kernfs_node *
391 __kernfs_create_file(struct kernfs_node *parent, const char *name,
392 umode_t mode, loff_t size, const struct kernfs_ops *ops,
393 void *priv, const void *ns, struct lock_class_key *key)
394 { return ERR_PTR(-ENOSYS); }
396 static inline struct kernfs_node *
397 kernfs_create_link(struct kernfs_node *parent, const char *name,
398 struct kernfs_node *target)
399 { return ERR_PTR(-ENOSYS); }
401 static inline void kernfs_activate(struct kernfs_node *kn) { }
403 static inline void kernfs_remove(struct kernfs_node *kn) { }
405 static inline bool kernfs_remove_self(struct kernfs_node *kn)
408 static inline int kernfs_remove_by_name_ns(struct kernfs_node *kn,
409 const char *name, const void *ns)
412 static inline int kernfs_rename_ns(struct kernfs_node *kn,
413 struct kernfs_node *new_parent,
414 const char *new_name, const void *new_ns)
417 static inline int kernfs_setattr(struct kernfs_node *kn,
418 const struct iattr *iattr)
421 static inline void kernfs_notify(struct kernfs_node *kn) { }
423 static inline const void *kernfs_super_ns(struct super_block *sb)
426 static inline struct dentry *
427 kernfs_mount_ns(struct file_system_type *fs_type, int flags,
428 struct kernfs_root *root, unsigned long magic,
429 bool *new_sb_created, const void *ns)
430 { return ERR_PTR(-ENOSYS); }
432 static inline void kernfs_kill_sb(struct super_block *sb) { }
434 static inline void kernfs_init(void) { }
436 #endif /* CONFIG_KERNFS */
438 static inline struct kernfs_node *
439 kernfs_find_and_get(struct kernfs_node *kn, const char *name)
441 return kernfs_find_and_get_ns(kn, name, NULL);
444 static inline struct kernfs_node *
445 kernfs_walk_and_get(struct kernfs_node *kn, const char *path)
447 return kernfs_walk_and_get_ns(kn, path, NULL);
450 static inline struct kernfs_node *
451 kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode,
454 return kernfs_create_dir_ns(parent, name, mode, priv, NULL);
457 static inline struct kernfs_node *
458 kernfs_create_file_ns(struct kernfs_node *parent, const char *name,
459 umode_t mode, loff_t size, const struct kernfs_ops *ops,
460 void *priv, const void *ns)
462 struct lock_class_key *key = NULL;
464 #ifdef CONFIG_DEBUG_LOCK_ALLOC
465 key = (struct lock_class_key *)&ops->lockdep_key;
467 return __kernfs_create_file(parent, name, mode, size, ops, priv, ns,
471 static inline struct kernfs_node *
472 kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode,
473 loff_t size, const struct kernfs_ops *ops, void *priv)
475 return kernfs_create_file_ns(parent, name, mode, size, ops, priv, NULL);
478 static inline int kernfs_remove_by_name(struct kernfs_node *parent,
481 return kernfs_remove_by_name_ns(parent, name, NULL);
484 static inline int kernfs_rename(struct kernfs_node *kn,
485 struct kernfs_node *new_parent,
486 const char *new_name)
488 return kernfs_rename_ns(kn, new_parent, new_name, NULL);
491 static inline struct dentry *
492 kernfs_mount(struct file_system_type *fs_type, int flags,
493 struct kernfs_root *root, unsigned long magic,
494 bool *new_sb_created)
496 return kernfs_mount_ns(fs_type, flags, root,
497 magic, new_sb_created, NULL);
500 #endif /* __LINUX_KERNFS_H */