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 /* 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 */ 74 struct 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 86 struct kernfs_elem_symlink { 87 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 * 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 */ 106 struct 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 */ 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); 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 157 struct 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 172 struct 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 183 size_t atomic_write_len; 184 bool mmapped; 185 const struct vm_operations_struct *vm_ops; 186 }; 187 188 struct kernfs_ops { 189 /* 190 * Read is handled by either seq_file or raw_read(). 191 * 192 * If seq_show() is present, seq_file path is active. Other seq 193 * operations are optional and if not implemented, the behavior is 194 * equivalent to single_open(). @sf->private points to the 195 * associated kernfs_open_file. 196 * 197 * read() is bounced through kernel buffer and a read larger than 198 * PAGE_SIZE results in partial operation of PAGE_SIZE. 199 */ 200 int (*seq_show)(struct seq_file *sf, void *v); 201 202 void *(*seq_start)(struct seq_file *sf, loff_t *ppos); 203 void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos); 204 void (*seq_stop)(struct seq_file *sf, void *v); 205 206 ssize_t (*read)(struct kernfs_open_file *of, char *buf, size_t bytes, 207 loff_t off); 208 209 /* 210 * write() is bounced through kernel buffer. If atomic_write_len 211 * is not set, a write larger than PAGE_SIZE results in partial 212 * operations of PAGE_SIZE chunks. If atomic_write_len is set, 213 * writes upto the specified size are executed atomically but 214 * larger ones are rejected with -E2BIG. 215 */ 216 size_t atomic_write_len; 217 ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes, 218 loff_t off); 219 220 int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma); 221 222 #ifdef CONFIG_DEBUG_LOCK_ALLOC 223 struct lock_class_key lockdep_key; 224 #endif 225 }; 226 227 #ifdef CONFIG_KERNFS 228 229 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn) 230 { 231 return kn->flags & KERNFS_TYPE_MASK; 232 } 233 234 /** 235 * kernfs_enable_ns - enable namespace under a directory 236 * @kn: directory of interest, should be empty 237 * 238 * This is to be called right after @kn is created to enable namespace 239 * under it. All children of @kn must have non-NULL namespace tags and 240 * only the ones which match the super_block's tag will be visible. 241 */ 242 static inline void kernfs_enable_ns(struct kernfs_node *kn) 243 { 244 WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR); 245 WARN_ON_ONCE(!RB_EMPTY_ROOT(&kn->dir.children)); 246 kn->flags |= KERNFS_NS; 247 } 248 249 /** 250 * kernfs_ns_enabled - test whether namespace is enabled 251 * @kn: the node to test 252 * 253 * Test whether namespace filtering is enabled for the children of @ns. 254 */ 255 static inline bool kernfs_ns_enabled(struct kernfs_node *kn) 256 { 257 return kn->flags & KERNFS_NS; 258 } 259 260 int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen); 261 char * __must_check kernfs_path(struct kernfs_node *kn, char *buf, 262 size_t buflen); 263 void pr_cont_kernfs_name(struct kernfs_node *kn); 264 void pr_cont_kernfs_path(struct kernfs_node *kn); 265 struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn); 266 struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent, 267 const char *name, const void *ns); 268 void kernfs_get(struct kernfs_node *kn); 269 void kernfs_put(struct kernfs_node *kn); 270 271 struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry); 272 struct kernfs_root *kernfs_root_from_sb(struct super_block *sb); 273 274 struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops, 275 unsigned int flags, void *priv); 276 void kernfs_destroy_root(struct kernfs_root *root); 277 278 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent, 279 const char *name, umode_t mode, 280 void *priv, const void *ns); 281 struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent, 282 const char *name, 283 umode_t mode, loff_t size, 284 const struct kernfs_ops *ops, 285 void *priv, const void *ns, 286 bool name_is_static, 287 struct lock_class_key *key); 288 struct kernfs_node *kernfs_create_link(struct kernfs_node *parent, 289 const char *name, 290 struct kernfs_node *target); 291 void kernfs_activate(struct kernfs_node *kn); 292 void kernfs_remove(struct kernfs_node *kn); 293 void kernfs_break_active_protection(struct kernfs_node *kn); 294 void kernfs_unbreak_active_protection(struct kernfs_node *kn); 295 bool kernfs_remove_self(struct kernfs_node *kn); 296 int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name, 297 const void *ns); 298 int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent, 299 const char *new_name, const void *new_ns); 300 int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr); 301 void kernfs_notify(struct kernfs_node *kn); 302 303 const void *kernfs_super_ns(struct super_block *sb); 304 struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags, 305 struct kernfs_root *root, unsigned long magic, 306 bool *new_sb_created, const void *ns); 307 void kernfs_kill_sb(struct super_block *sb); 308 309 void kernfs_init(void); 310 311 #else /* CONFIG_KERNFS */ 312 313 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn) 314 { return 0; } /* whatever */ 315 316 static inline void kernfs_enable_ns(struct kernfs_node *kn) { } 317 318 static inline bool kernfs_ns_enabled(struct kernfs_node *kn) 319 { return false; } 320 321 static inline int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen) 322 { return -ENOSYS; } 323 324 static inline char * __must_check kernfs_path(struct kernfs_node *kn, char *buf, 325 size_t buflen) 326 { return NULL; } 327 328 static inline void pr_cont_kernfs_name(struct kernfs_node *kn) { } 329 static inline void pr_cont_kernfs_path(struct kernfs_node *kn) { } 330 331 static inline struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn) 332 { return NULL; } 333 334 static inline struct kernfs_node * 335 kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name, 336 const void *ns) 337 { return NULL; } 338 339 static inline void kernfs_get(struct kernfs_node *kn) { } 340 static inline void kernfs_put(struct kernfs_node *kn) { } 341 342 static inline struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry) 343 { return NULL; } 344 345 static inline struct kernfs_root *kernfs_root_from_sb(struct super_block *sb) 346 { return NULL; } 347 348 static inline struct kernfs_root * 349 kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags, 350 void *priv) 351 { return ERR_PTR(-ENOSYS); } 352 353 static inline void kernfs_destroy_root(struct kernfs_root *root) { } 354 355 static inline struct kernfs_node * 356 kernfs_create_dir_ns(struct kernfs_node *parent, const char *name, 357 umode_t mode, void *priv, const void *ns) 358 { return ERR_PTR(-ENOSYS); } 359 360 static inline struct kernfs_node * 361 __kernfs_create_file(struct kernfs_node *parent, const char *name, 362 umode_t mode, loff_t size, const struct kernfs_ops *ops, 363 void *priv, const void *ns, bool name_is_static, 364 struct lock_class_key *key) 365 { return ERR_PTR(-ENOSYS); } 366 367 static inline struct kernfs_node * 368 kernfs_create_link(struct kernfs_node *parent, const char *name, 369 struct kernfs_node *target) 370 { return ERR_PTR(-ENOSYS); } 371 372 static inline void kernfs_activate(struct kernfs_node *kn) { } 373 374 static inline void kernfs_remove(struct kernfs_node *kn) { } 375 376 static inline bool kernfs_remove_self(struct kernfs_node *kn) 377 { return false; } 378 379 static inline int kernfs_remove_by_name_ns(struct kernfs_node *kn, 380 const char *name, const void *ns) 381 { return -ENOSYS; } 382 383 static inline int kernfs_rename_ns(struct kernfs_node *kn, 384 struct kernfs_node *new_parent, 385 const char *new_name, const void *new_ns) 386 { return -ENOSYS; } 387 388 static inline int kernfs_setattr(struct kernfs_node *kn, 389 const struct iattr *iattr) 390 { return -ENOSYS; } 391 392 static inline void kernfs_notify(struct kernfs_node *kn) { } 393 394 static inline const void *kernfs_super_ns(struct super_block *sb) 395 { return NULL; } 396 397 static inline struct dentry * 398 kernfs_mount_ns(struct file_system_type *fs_type, int flags, 399 struct kernfs_root *root, unsigned long magic, 400 bool *new_sb_created, const void *ns) 401 { return ERR_PTR(-ENOSYS); } 402 403 static inline void kernfs_kill_sb(struct super_block *sb) { } 404 405 static inline void kernfs_init(void) { } 406 407 #endif /* CONFIG_KERNFS */ 408 409 static inline struct kernfs_node * 410 kernfs_find_and_get(struct kernfs_node *kn, const char *name) 411 { 412 return kernfs_find_and_get_ns(kn, name, NULL); 413 } 414 415 static inline struct kernfs_node * 416 kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode, 417 void *priv) 418 { 419 return kernfs_create_dir_ns(parent, name, mode, priv, NULL); 420 } 421 422 static inline struct kernfs_node * 423 kernfs_create_file_ns(struct kernfs_node *parent, const char *name, 424 umode_t mode, loff_t size, const struct kernfs_ops *ops, 425 void *priv, const void *ns) 426 { 427 struct lock_class_key *key = NULL; 428 429 #ifdef CONFIG_DEBUG_LOCK_ALLOC 430 key = (struct lock_class_key *)&ops->lockdep_key; 431 #endif 432 return __kernfs_create_file(parent, name, mode, size, ops, priv, ns, 433 false, key); 434 } 435 436 static inline struct kernfs_node * 437 kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode, 438 loff_t size, const struct kernfs_ops *ops, void *priv) 439 { 440 return kernfs_create_file_ns(parent, name, mode, size, ops, priv, NULL); 441 } 442 443 static inline int kernfs_remove_by_name(struct kernfs_node *parent, 444 const char *name) 445 { 446 return kernfs_remove_by_name_ns(parent, name, NULL); 447 } 448 449 static inline int kernfs_rename(struct kernfs_node *kn, 450 struct kernfs_node *new_parent, 451 const char *new_name) 452 { 453 return kernfs_rename_ns(kn, new_parent, new_name, NULL); 454 } 455 456 static inline struct dentry * 457 kernfs_mount(struct file_system_type *fs_type, int flags, 458 struct kernfs_root *root, unsigned long magic, 459 bool *new_sb_created) 460 { 461 return kernfs_mount_ns(fs_type, flags, root, 462 magic, new_sb_created, NULL); 463 } 464 465 #endif /* __LINUX_KERNFS_H */ 466