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 20 struct file; 21 struct dentry; 22 struct iattr; 23 struct seq_file; 24 struct vm_area_struct; 25 struct super_block; 26 struct file_system_type; 27 28 struct kernfs_open_node; 29 struct kernfs_iattrs; 30 31 enum 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 40 enum 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_STATIC_NAME = 0x0200, 47 KERNFS_SUICIDAL = 0x0400, 48 KERNFS_SUICIDED = 0x0800, 49 }; 50 51 /* @flags for kernfs_create_root() */ 52 enum kernfs_root_flag { 53 KERNFS_ROOT_CREATE_DEACTIVATED = 0x0001, 54 }; 55 56 /* type-specific structures for kernfs_node union members */ 57 struct kernfs_elem_dir { 58 unsigned long subdirs; 59 /* children rbtree starts here and goes through kn->rb */ 60 struct rb_root children; 61 62 /* 63 * The kernfs hierarchy this directory belongs to. This fits 64 * better directly in kernfs_node but is here to save space. 65 */ 66 struct kernfs_root *root; 67 }; 68 69 struct kernfs_elem_symlink { 70 struct kernfs_node *target_kn; 71 }; 72 73 struct kernfs_elem_attr { 74 const struct kernfs_ops *ops; 75 struct kernfs_open_node *open; 76 loff_t size; 77 }; 78 79 /* 80 * kernfs_node - the building block of kernfs hierarchy. Each and every 81 * kernfs node is represented by single kernfs_node. Most fields are 82 * private to kernfs and shouldn't be accessed directly by kernfs users. 83 * 84 * As long as s_count reference is held, the kernfs_node itself is 85 * accessible. Dereferencing elem or any other outer entity requires 86 * active reference. 87 */ 88 struct kernfs_node { 89 atomic_t count; 90 atomic_t active; 91 #ifdef CONFIG_DEBUG_LOCK_ALLOC 92 struct lockdep_map dep_map; 93 #endif 94 /* 95 * Use kernfs_get_parent() and kernfs_name/path() instead of 96 * accessing the following two fields directly. If the node is 97 * never moved to a different parent, it is safe to access the 98 * parent directly. 99 */ 100 struct kernfs_node *parent; 101 const char *name; 102 103 struct rb_node rb; 104 105 const void *ns; /* namespace tag */ 106 unsigned int hash; /* ns + name hash */ 107 union { 108 struct kernfs_elem_dir dir; 109 struct kernfs_elem_symlink symlink; 110 struct kernfs_elem_attr attr; 111 }; 112 113 void *priv; 114 115 unsigned short flags; 116 umode_t mode; 117 unsigned int ino; 118 struct kernfs_iattrs *iattr; 119 }; 120 121 /* 122 * kernfs_syscall_ops may be specified on kernfs_create_root() to support 123 * syscalls. These optional callbacks are invoked on the matching syscalls 124 * and can perform any kernfs operations which don't necessarily have to be 125 * the exact operation requested. An active reference is held for each 126 * kernfs_node parameter. 127 */ 128 struct kernfs_syscall_ops { 129 int (*remount_fs)(struct kernfs_root *root, int *flags, char *data); 130 int (*show_options)(struct seq_file *sf, struct kernfs_root *root); 131 132 int (*mkdir)(struct kernfs_node *parent, const char *name, 133 umode_t mode); 134 int (*rmdir)(struct kernfs_node *kn); 135 int (*rename)(struct kernfs_node *kn, struct kernfs_node *new_parent, 136 const char *new_name); 137 }; 138 139 struct kernfs_root { 140 /* published fields */ 141 struct kernfs_node *kn; 142 unsigned int flags; /* KERNFS_ROOT_* flags */ 143 144 /* private fields, do not use outside kernfs proper */ 145 struct ida ino_ida; 146 struct kernfs_syscall_ops *syscall_ops; 147 wait_queue_head_t deactivate_waitq; 148 }; 149 150 struct kernfs_open_file { 151 /* published fields */ 152 struct kernfs_node *kn; 153 struct file *file; 154 void *priv; 155 156 /* private fields, do not use outside kernfs proper */ 157 struct mutex mutex; 158 int event; 159 struct list_head list; 160 161 size_t atomic_write_len; 162 bool mmapped; 163 const struct vm_operations_struct *vm_ops; 164 }; 165 166 struct kernfs_ops { 167 /* 168 * Read is handled by either seq_file or raw_read(). 169 * 170 * If seq_show() is present, seq_file path is active. Other seq 171 * operations are optional and if not implemented, the behavior is 172 * equivalent to single_open(). @sf->private points to the 173 * associated kernfs_open_file. 174 * 175 * read() is bounced through kernel buffer and a read larger than 176 * PAGE_SIZE results in partial operation of PAGE_SIZE. 177 */ 178 int (*seq_show)(struct seq_file *sf, void *v); 179 180 void *(*seq_start)(struct seq_file *sf, loff_t *ppos); 181 void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos); 182 void (*seq_stop)(struct seq_file *sf, void *v); 183 184 ssize_t (*read)(struct kernfs_open_file *of, char *buf, size_t bytes, 185 loff_t off); 186 187 /* 188 * write() is bounced through kernel buffer. If atomic_write_len 189 * is not set, a write larger than PAGE_SIZE results in partial 190 * operations of PAGE_SIZE chunks. If atomic_write_len is set, 191 * writes upto the specified size are executed atomically but 192 * larger ones are rejected with -E2BIG. 193 */ 194 size_t atomic_write_len; 195 ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes, 196 loff_t off); 197 198 int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma); 199 200 #ifdef CONFIG_DEBUG_LOCK_ALLOC 201 struct lock_class_key lockdep_key; 202 #endif 203 }; 204 205 #ifdef CONFIG_KERNFS 206 207 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn) 208 { 209 return kn->flags & KERNFS_TYPE_MASK; 210 } 211 212 /** 213 * kernfs_enable_ns - enable namespace under a directory 214 * @kn: directory of interest, should be empty 215 * 216 * This is to be called right after @kn is created to enable namespace 217 * under it. All children of @kn must have non-NULL namespace tags and 218 * only the ones which match the super_block's tag will be visible. 219 */ 220 static inline void kernfs_enable_ns(struct kernfs_node *kn) 221 { 222 WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR); 223 WARN_ON_ONCE(!RB_EMPTY_ROOT(&kn->dir.children)); 224 kn->flags |= KERNFS_NS; 225 } 226 227 /** 228 * kernfs_ns_enabled - test whether namespace is enabled 229 * @kn: the node to test 230 * 231 * Test whether namespace filtering is enabled for the children of @ns. 232 */ 233 static inline bool kernfs_ns_enabled(struct kernfs_node *kn) 234 { 235 return kn->flags & KERNFS_NS; 236 } 237 238 int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen); 239 char * __must_check kernfs_path(struct kernfs_node *kn, char *buf, 240 size_t buflen); 241 void pr_cont_kernfs_name(struct kernfs_node *kn); 242 void pr_cont_kernfs_path(struct kernfs_node *kn); 243 struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn); 244 struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent, 245 const char *name, const void *ns); 246 void kernfs_get(struct kernfs_node *kn); 247 void kernfs_put(struct kernfs_node *kn); 248 249 struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry); 250 struct kernfs_root *kernfs_root_from_sb(struct super_block *sb); 251 252 struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops, 253 unsigned int flags, void *priv); 254 void kernfs_destroy_root(struct kernfs_root *root); 255 256 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent, 257 const char *name, umode_t mode, 258 void *priv, const void *ns); 259 struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent, 260 const char *name, 261 umode_t mode, loff_t size, 262 const struct kernfs_ops *ops, 263 void *priv, const void *ns, 264 bool name_is_static, 265 struct lock_class_key *key); 266 struct kernfs_node *kernfs_create_link(struct kernfs_node *parent, 267 const char *name, 268 struct kernfs_node *target); 269 void kernfs_activate(struct kernfs_node *kn); 270 void kernfs_remove(struct kernfs_node *kn); 271 void kernfs_break_active_protection(struct kernfs_node *kn); 272 void kernfs_unbreak_active_protection(struct kernfs_node *kn); 273 bool kernfs_remove_self(struct kernfs_node *kn); 274 int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name, 275 const void *ns); 276 int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent, 277 const char *new_name, const void *new_ns); 278 int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr); 279 void kernfs_notify(struct kernfs_node *kn); 280 281 const void *kernfs_super_ns(struct super_block *sb); 282 struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags, 283 struct kernfs_root *root, bool *new_sb_created, 284 const void *ns); 285 void kernfs_kill_sb(struct super_block *sb); 286 287 void kernfs_init(void); 288 289 #else /* CONFIG_KERNFS */ 290 291 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn) 292 { return 0; } /* whatever */ 293 294 static inline void kernfs_enable_ns(struct kernfs_node *kn) { } 295 296 static inline bool kernfs_ns_enabled(struct kernfs_node *kn) 297 { return false; } 298 299 static inline int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen) 300 { return -ENOSYS; } 301 302 static inline char * __must_check kernfs_path(struct kernfs_node *kn, char *buf, 303 size_t buflen) 304 { return NULL; } 305 306 static inline void pr_cont_kernfs_name(struct kernfs_node *kn) { } 307 static inline void pr_cont_kernfs_path(struct kernfs_node *kn) { } 308 309 static inline struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn) 310 { return NULL; } 311 312 static inline struct kernfs_node * 313 kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name, 314 const void *ns) 315 { return NULL; } 316 317 static inline void kernfs_get(struct kernfs_node *kn) { } 318 static inline void kernfs_put(struct kernfs_node *kn) { } 319 320 static inline struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry) 321 { return NULL; } 322 323 static inline struct kernfs_root *kernfs_root_from_sb(struct super_block *sb) 324 { return NULL; } 325 326 static inline struct kernfs_root * 327 kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags, 328 void *priv) 329 { return ERR_PTR(-ENOSYS); } 330 331 static inline void kernfs_destroy_root(struct kernfs_root *root) { } 332 333 static inline struct kernfs_node * 334 kernfs_create_dir_ns(struct kernfs_node *parent, const char *name, 335 umode_t mode, void *priv, const void *ns) 336 { return ERR_PTR(-ENOSYS); } 337 338 static inline struct kernfs_node * 339 __kernfs_create_file(struct kernfs_node *parent, const char *name, 340 umode_t mode, loff_t size, const struct kernfs_ops *ops, 341 void *priv, const void *ns, bool name_is_static, 342 struct lock_class_key *key) 343 { return ERR_PTR(-ENOSYS); } 344 345 static inline struct kernfs_node * 346 kernfs_create_link(struct kernfs_node *parent, const char *name, 347 struct kernfs_node *target) 348 { return ERR_PTR(-ENOSYS); } 349 350 static inline void kernfs_activate(struct kernfs_node *kn) { } 351 352 static inline void kernfs_remove(struct kernfs_node *kn) { } 353 354 static inline bool kernfs_remove_self(struct kernfs_node *kn) 355 { return false; } 356 357 static inline int kernfs_remove_by_name_ns(struct kernfs_node *kn, 358 const char *name, const void *ns) 359 { return -ENOSYS; } 360 361 static inline int kernfs_rename_ns(struct kernfs_node *kn, 362 struct kernfs_node *new_parent, 363 const char *new_name, const void *new_ns) 364 { return -ENOSYS; } 365 366 static inline int kernfs_setattr(struct kernfs_node *kn, 367 const struct iattr *iattr) 368 { return -ENOSYS; } 369 370 static inline void kernfs_notify(struct kernfs_node *kn) { } 371 372 static inline const void *kernfs_super_ns(struct super_block *sb) 373 { return NULL; } 374 375 static inline struct dentry * 376 kernfs_mount_ns(struct file_system_type *fs_type, int flags, 377 struct kernfs_root *root, bool *new_sb_created, const void *ns) 378 { return ERR_PTR(-ENOSYS); } 379 380 static inline void kernfs_kill_sb(struct super_block *sb) { } 381 382 static inline void kernfs_init(void) { } 383 384 #endif /* CONFIG_KERNFS */ 385 386 static inline struct kernfs_node * 387 kernfs_find_and_get(struct kernfs_node *kn, const char *name) 388 { 389 return kernfs_find_and_get_ns(kn, name, NULL); 390 } 391 392 static inline struct kernfs_node * 393 kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode, 394 void *priv) 395 { 396 return kernfs_create_dir_ns(parent, name, mode, priv, NULL); 397 } 398 399 static inline struct kernfs_node * 400 kernfs_create_file_ns(struct kernfs_node *parent, const char *name, 401 umode_t mode, loff_t size, const struct kernfs_ops *ops, 402 void *priv, const void *ns) 403 { 404 struct lock_class_key *key = NULL; 405 406 #ifdef CONFIG_DEBUG_LOCK_ALLOC 407 key = (struct lock_class_key *)&ops->lockdep_key; 408 #endif 409 return __kernfs_create_file(parent, name, mode, size, ops, priv, ns, 410 false, key); 411 } 412 413 static inline struct kernfs_node * 414 kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode, 415 loff_t size, const struct kernfs_ops *ops, void *priv) 416 { 417 return kernfs_create_file_ns(parent, name, mode, size, ops, priv, NULL); 418 } 419 420 static inline int kernfs_remove_by_name(struct kernfs_node *parent, 421 const char *name) 422 { 423 return kernfs_remove_by_name_ns(parent, name, NULL); 424 } 425 426 static inline int kernfs_rename(struct kernfs_node *kn, 427 struct kernfs_node *new_parent, 428 const char *new_name) 429 { 430 return kernfs_rename_ns(kn, new_parent, new_name, NULL); 431 } 432 433 static inline struct dentry * 434 kernfs_mount(struct file_system_type *fs_type, int flags, 435 struct kernfs_root *root, bool *new_sb_created) 436 { 437 return kernfs_mount_ns(fs_type, flags, root, new_sb_created, NULL); 438 } 439 440 #endif /* __LINUX_KERNFS_H */ 441