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 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> 19 20struct file; 21struct dentry; 22struct iattr; 23struct seq_file; 24struct vm_area_struct; 25struct super_block; 26struct file_system_type; 27 28struct kernfs_open_node; 29struct kernfs_iattrs; 30 31enum kernfs_node_type { 32 KERNFS_DIR = 0x0001, 33 KERNFS_FILE = 0x0002, 34 KERNFS_LINK = 0x0004, 35}; 36 37#define KERNFS_TYPE_MASK 0x000f 38#define KERNFS_FLAG_MASK ~KERNFS_TYPE_MASK 39 40enum kernfs_node_flag { 41 KERNFS_ACTIVATED = 0x0010, 42 KERNFS_NS = 0x0020, 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, 49}; 50 51/* @flags for kernfs_create_root() */ 52enum kernfs_root_flag { 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, 71}; 72 73/* type-specific structures for kernfs_node union members */ 74struct kernfs_elem_dir { 75 unsigned long subdirs; 76 /* children rbtree starts here and goes through kn->rb */ 77 struct rb_root children; 78 79 /* 80 * The kernfs hierarchy this directory belongs to. This fits 81 * better directly in kernfs_node but is here to save space. 82 */ 83 struct kernfs_root *root; 84}; 85 86struct kernfs_elem_symlink { 87 struct kernfs_node *target_kn; 88}; 89 90struct 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 * 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. 101 * 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. 105 */ 106struct kernfs_node { 107 atomic_t count; 108 atomic_t active; 109#ifdef CONFIG_DEBUG_LOCK_ALLOC 110 struct lockdep_map dep_map; 111#endif 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 */ 118 struct kernfs_node *parent; 119 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 struct kernfs_elem_dir dir; 127 struct kernfs_elem_symlink symlink; 128 struct kernfs_elem_attr attr; 129 }; 130 131 void *priv; 132 133 unsigned short flags; 134 umode_t mode; 135 unsigned int ino; 136 struct kernfs_iattrs *iattr; 137}; 138 139/* 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. 145 */ 146struct 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); 149 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 157struct kernfs_root { 158 /* published fields */ 159 struct kernfs_node *kn; 160 unsigned int flags; /* KERNFS_ROOT_* flags */ 161 162 /* private fields, do not use outside kernfs proper */ 163 struct ida ino_ida; 164 struct kernfs_syscall_ops *syscall_ops; 165 166 /* list of kernfs_super_info of this root, protected by kernfs_mutex */ 167 struct list_head supers; 168 169 wait_queue_head_t deactivate_waitq; 170}; 171 172struct kernfs_open_file { 173 /* published fields */ 174 struct kernfs_node *kn; 175 struct file *file; 176 void *priv; 177 178 /* private fields, do not use outside kernfs proper */ 179 struct mutex mutex; 180 int event; 181 struct list_head list; 182 char *prealloc_buf; 183 184 size_t atomic_write_len; 185 bool mmapped; 186 const struct vm_operations_struct *vm_ops; 187}; 188 189struct kernfs_ops { 190 /* 191 * Read is handled by either seq_file or raw_read(). 192 * 193 * If seq_show() is present, seq_file path is active. Other seq 194 * operations are optional and if not implemented, the behavior is 195 * equivalent to single_open(). @sf->private points to the 196 * associated kernfs_open_file. 197 * 198 * read() is bounced through kernel buffer and a read larger than 199 * PAGE_SIZE results in partial operation of PAGE_SIZE. 200 */ 201 int (*seq_show)(struct seq_file *sf, void *v); 202 203 void *(*seq_start)(struct seq_file *sf, loff_t *ppos); 204 void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos); 205 void (*seq_stop)(struct seq_file *sf, void *v); 206 207 ssize_t (*read)(struct kernfs_open_file *of, char *buf, size_t bytes, 208 loff_t off); 209 210 /* 211 * write() is bounced through kernel buffer. If atomic_write_len 212 * is not set, a write larger than PAGE_SIZE results in partial 213 * operations of PAGE_SIZE chunks. If atomic_write_len is set, 214 * writes upto the specified size are executed atomically but 215 * larger ones are rejected with -E2BIG. 216 */ 217 size_t atomic_write_len; 218 /* 219 * "prealloc" causes a buffer to be allocated at open for 220 * all read/write requests. As ->seq_show uses seq_read() 221 * which does its own allocation, it is incompatible with 222 * ->prealloc. Provide ->read and ->write with ->prealloc. 223 */ 224 bool prealloc; 225 ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes, 226 loff_t off); 227 228 int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma); 229 230#ifdef CONFIG_DEBUG_LOCK_ALLOC 231 struct lock_class_key lockdep_key; 232#endif 233}; 234 235#ifdef CONFIG_KERNFS 236 237static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn) 238{ 239 return kn->flags & KERNFS_TYPE_MASK; 240} 241 242/** 243 * kernfs_enable_ns - enable namespace under a directory 244 * @kn: directory of interest, should be empty 245 * 246 * This is to be called right after @kn is created to enable namespace 247 * under it. All children of @kn must have non-NULL namespace tags and 248 * only the ones which match the super_block's tag will be visible. 249 */ 250static inline void kernfs_enable_ns(struct kernfs_node *kn) 251{ 252 WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR); 253 WARN_ON_ONCE(!RB_EMPTY_ROOT(&kn->dir.children)); 254 kn->flags |= KERNFS_NS; 255} 256 257/** 258 * kernfs_ns_enabled - test whether namespace is enabled 259 * @kn: the node to test 260 * 261 * Test whether namespace filtering is enabled for the children of @ns. 262 */ 263static inline bool kernfs_ns_enabled(struct kernfs_node *kn) 264{ 265 return kn->flags & KERNFS_NS; 266} 267 268int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen); 269char * __must_check kernfs_path(struct kernfs_node *kn, char *buf, 270 size_t buflen); 271void pr_cont_kernfs_name(struct kernfs_node *kn); 272void pr_cont_kernfs_path(struct kernfs_node *kn); 273struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn); 274struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent, 275 const char *name, const void *ns); 276void kernfs_get(struct kernfs_node *kn); 277void kernfs_put(struct kernfs_node *kn); 278 279struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry); 280struct kernfs_root *kernfs_root_from_sb(struct super_block *sb); 281 282struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops, 283 unsigned int flags, void *priv); 284void kernfs_destroy_root(struct kernfs_root *root); 285 286struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent, 287 const char *name, umode_t mode, 288 void *priv, const void *ns); 289struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent, 290 const char *name); 291struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent, 292 const char *name, 293 umode_t mode, loff_t size, 294 const struct kernfs_ops *ops, 295 void *priv, const void *ns, 296 struct lock_class_key *key); 297struct kernfs_node *kernfs_create_link(struct kernfs_node *parent, 298 const char *name, 299 struct kernfs_node *target); 300void kernfs_activate(struct kernfs_node *kn); 301void kernfs_remove(struct kernfs_node *kn); 302void kernfs_break_active_protection(struct kernfs_node *kn); 303void kernfs_unbreak_active_protection(struct kernfs_node *kn); 304bool kernfs_remove_self(struct kernfs_node *kn); 305int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name, 306 const void *ns); 307int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent, 308 const char *new_name, const void *new_ns); 309int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr); 310void kernfs_notify(struct kernfs_node *kn); 311 312const void *kernfs_super_ns(struct super_block *sb); 313struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags, 314 struct kernfs_root *root, unsigned long magic, 315 bool *new_sb_created, const void *ns); 316void kernfs_kill_sb(struct super_block *sb); 317struct super_block *kernfs_pin_sb(struct kernfs_root *root, const void *ns); 318 319void kernfs_init(void); 320 321#else /* CONFIG_KERNFS */ 322 323static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn) 324{ return 0; } /* whatever */ 325 326static inline void kernfs_enable_ns(struct kernfs_node *kn) { } 327 328static inline bool kernfs_ns_enabled(struct kernfs_node *kn) 329{ return false; } 330 331static inline int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen) 332{ return -ENOSYS; } 333 334static inline char * __must_check kernfs_path(struct kernfs_node *kn, char *buf, 335 size_t buflen) 336{ return NULL; } 337 338static inline void pr_cont_kernfs_name(struct kernfs_node *kn) { } 339static inline void pr_cont_kernfs_path(struct kernfs_node *kn) { } 340 341static inline struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn) 342{ return NULL; } 343 344static inline struct kernfs_node * 345kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name, 346 const void *ns) 347{ return NULL; } 348 349static inline void kernfs_get(struct kernfs_node *kn) { } 350static inline void kernfs_put(struct kernfs_node *kn) { } 351 352static inline struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry) 353{ return NULL; } 354 355static inline struct kernfs_root *kernfs_root_from_sb(struct super_block *sb) 356{ return NULL; } 357 358static inline struct kernfs_root * 359kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags, 360 void *priv) 361{ return ERR_PTR(-ENOSYS); } 362 363static inline void kernfs_destroy_root(struct kernfs_root *root) { } 364 365static inline struct kernfs_node * 366kernfs_create_dir_ns(struct kernfs_node *parent, const char *name, 367 umode_t mode, void *priv, const void *ns) 368{ return ERR_PTR(-ENOSYS); } 369 370static inline struct kernfs_node * 371__kernfs_create_file(struct kernfs_node *parent, const char *name, 372 umode_t mode, loff_t size, const struct kernfs_ops *ops, 373 void *priv, const void *ns, struct lock_class_key *key) 374{ return ERR_PTR(-ENOSYS); } 375 376static inline struct kernfs_node * 377kernfs_create_link(struct kernfs_node *parent, const char *name, 378 struct kernfs_node *target) 379{ return ERR_PTR(-ENOSYS); } 380 381static inline void kernfs_activate(struct kernfs_node *kn) { } 382 383static inline void kernfs_remove(struct kernfs_node *kn) { } 384 385static inline bool kernfs_remove_self(struct kernfs_node *kn) 386{ return false; } 387 388static inline int kernfs_remove_by_name_ns(struct kernfs_node *kn, 389 const char *name, const void *ns) 390{ return -ENOSYS; } 391 392static inline int kernfs_rename_ns(struct kernfs_node *kn, 393 struct kernfs_node *new_parent, 394 const char *new_name, const void *new_ns) 395{ return -ENOSYS; } 396 397static inline int kernfs_setattr(struct kernfs_node *kn, 398 const struct iattr *iattr) 399{ return -ENOSYS; } 400 401static inline void kernfs_notify(struct kernfs_node *kn) { } 402 403static inline const void *kernfs_super_ns(struct super_block *sb) 404{ return NULL; } 405 406static inline struct dentry * 407kernfs_mount_ns(struct file_system_type *fs_type, int flags, 408 struct kernfs_root *root, unsigned long magic, 409 bool *new_sb_created, const void *ns) 410{ return ERR_PTR(-ENOSYS); } 411 412static inline void kernfs_kill_sb(struct super_block *sb) { } 413 414static inline void kernfs_init(void) { } 415 416#endif /* CONFIG_KERNFS */ 417 418static inline struct kernfs_node * 419kernfs_find_and_get(struct kernfs_node *kn, const char *name) 420{ 421 return kernfs_find_and_get_ns(kn, name, NULL); 422} 423 424static inline struct kernfs_node * 425kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode, 426 void *priv) 427{ 428 return kernfs_create_dir_ns(parent, name, mode, priv, NULL); 429} 430 431static inline struct kernfs_node * 432kernfs_create_file_ns(struct kernfs_node *parent, const char *name, 433 umode_t mode, loff_t size, const struct kernfs_ops *ops, 434 void *priv, const void *ns) 435{ 436 struct lock_class_key *key = NULL; 437 438#ifdef CONFIG_DEBUG_LOCK_ALLOC 439 key = (struct lock_class_key *)&ops->lockdep_key; 440#endif 441 return __kernfs_create_file(parent, name, mode, size, ops, priv, ns, 442 key); 443} 444 445static inline struct kernfs_node * 446kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode, 447 loff_t size, const struct kernfs_ops *ops, void *priv) 448{ 449 return kernfs_create_file_ns(parent, name, mode, size, ops, priv, NULL); 450} 451 452static inline int kernfs_remove_by_name(struct kernfs_node *parent, 453 const char *name) 454{ 455 return kernfs_remove_by_name_ns(parent, name, NULL); 456} 457 458static inline int kernfs_rename(struct kernfs_node *kn, 459 struct kernfs_node *new_parent, 460 const char *new_name) 461{ 462 return kernfs_rename_ns(kn, new_parent, new_name, NULL); 463} 464 465static inline struct dentry * 466kernfs_mount(struct file_system_type *fs_type, int flags, 467 struct kernfs_root *root, unsigned long magic, 468 bool *new_sb_created) 469{ 470 return kernfs_mount_ns(fs_type, flags, root, 471 magic, new_sb_created, NULL); 472} 473 474#endif /* __LINUX_KERNFS_H */ 475