1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* 3 * fs/kernfs/kernfs-internal.h - kernfs internal header file 4 * 5 * Copyright (c) 2001-3 Patrick Mochel 6 * Copyright (c) 2007 SUSE Linux Products GmbH 7 * Copyright (c) 2007, 2013 Tejun Heo <teheo@suse.de> 8 */ 9 10 #ifndef __KERNFS_INTERNAL_H 11 #define __KERNFS_INTERNAL_H 12 13 #include <linux/lockdep.h> 14 #include <linux/fs.h> 15 #include <linux/mutex.h> 16 #include <linux/rwsem.h> 17 #include <linux/xattr.h> 18 19 #include <linux/kernfs.h> 20 #include <linux/fs_context.h> 21 22 struct kernfs_iattrs { 23 kuid_t ia_uid; 24 kgid_t ia_gid; 25 struct timespec64 ia_atime; 26 struct timespec64 ia_mtime; 27 struct timespec64 ia_ctime; 28 29 struct list_head xattrs; 30 struct simple_xattr_limits xattr_limits; 31 }; 32 33 struct kernfs_root { 34 /* published fields */ 35 struct kernfs_node *kn; 36 unsigned int flags; /* KERNFS_ROOT_* flags */ 37 38 /* private fields, do not use outside kernfs proper */ 39 struct idr ino_idr; 40 spinlock_t kernfs_idr_lock; /* root->ino_idr */ 41 u32 last_id_lowbits; 42 u32 id_highbits; 43 struct kernfs_syscall_ops *syscall_ops; 44 45 /* list of kernfs_super_info of this root, protected by kernfs_rwsem */ 46 struct list_head supers; 47 48 wait_queue_head_t deactivate_waitq; 49 struct rw_semaphore kernfs_rwsem; 50 struct rw_semaphore kernfs_iattr_rwsem; 51 struct rw_semaphore kernfs_supers_rwsem; 52 53 /* kn->parent and kn->name */ 54 rwlock_t kernfs_rename_lock; 55 56 struct rcu_head rcu; 57 58 struct simple_xattr_cache xa_cache; 59 }; 60 61 /* +1 to avoid triggering overflow warning when negating it */ 62 #define KN_DEACTIVATED_BIAS (INT_MIN + 1) 63 64 /* KERNFS_TYPE_MASK and types are defined in include/linux/kernfs.h */ 65 66 /** 67 * kernfs_root - find out the kernfs_root a kernfs_node belongs to 68 * @kn: kernfs_node of interest 69 * 70 * Return: the kernfs_root @kn belongs to. 71 */ 72 static inline struct kernfs_root *kernfs_root(const struct kernfs_node *kn) 73 { 74 const struct kernfs_node *knp; 75 /* if parent exists, it's always a dir; otherwise, @sd is a dir */ 76 guard(rcu)(); 77 knp = rcu_dereference(kn->__parent); 78 if (knp) 79 kn = knp; 80 return kn->dir.root; 81 } 82 83 /* 84 * mount.c 85 */ 86 struct kernfs_super_info { 87 struct super_block *sb; 88 89 /* 90 * The root associated with this super_block. Each super_block is 91 * identified by the root and ns it's associated with. 92 */ 93 struct kernfs_root *root; 94 95 /* 96 * Each sb is associated with one namespace tag, currently the 97 * network namespace of the task which mounted this kernfs 98 * instance. If multiple tags become necessary, make the following 99 * an array and compare kernfs_node tag against every entry. 100 */ 101 const struct ns_common *ns; 102 103 /* anchored at kernfs_root->supers, protected by kernfs_rwsem */ 104 struct list_head node; 105 }; 106 #define kernfs_info(SB) ((struct kernfs_super_info *)(SB->s_fs_info)) 107 108 static inline bool kernfs_root_is_locked(const struct kernfs_node *kn) 109 { 110 return lockdep_is_held(&kernfs_root(kn)->kernfs_rwsem); 111 } 112 113 static inline bool kernfs_rename_is_locked(const struct kernfs_node *kn) 114 { 115 return lockdep_is_held(&kernfs_root(kn)->kernfs_rename_lock); 116 } 117 118 static inline const char *kernfs_rcu_name(const struct kernfs_node *kn) 119 { 120 return rcu_dereference_check(kn->name, kernfs_root_is_locked(kn)); 121 } 122 123 static inline struct kernfs_node *kernfs_parent(const struct kernfs_node *kn) 124 { 125 /* 126 * The kernfs_node::__parent remains valid within a RCU section. The kn 127 * can be reparented (and renamed) which changes the entry. This can be 128 * avoided by locking kernfs_root::kernfs_rwsem or 129 * kernfs_root::kernfs_rename_lock. 130 * Both locks can be used to obtain a reference on __parent. Once the 131 * reference count reaches 0 then the node is about to be freed 132 * and can not be renamed (or become a different parent) anymore. 133 */ 134 return rcu_dereference_check(kn->__parent, 135 kernfs_root_is_locked(kn) || 136 kernfs_rename_is_locked(kn) || 137 !atomic_read(&kn->count)); 138 } 139 140 static inline struct kernfs_node *kernfs_dentry_node(struct dentry *dentry) 141 { 142 if (d_really_is_negative(dentry)) 143 return NULL; 144 return d_inode(dentry)->i_private; 145 } 146 147 static inline void kernfs_set_rev(struct kernfs_node *parent, 148 struct dentry *dentry) 149 { 150 dentry->d_time = parent->dir.rev; 151 } 152 153 static inline void kernfs_inc_rev(struct kernfs_node *parent) 154 { 155 parent->dir.rev++; 156 } 157 158 static inline bool kernfs_dir_changed(struct kernfs_node *parent, 159 struct dentry *dentry) 160 { 161 if (parent->dir.rev != dentry->d_time) 162 return true; 163 return false; 164 } 165 166 extern const struct super_operations kernfs_sops; 167 extern struct kmem_cache *kernfs_node_cache, *kernfs_iattrs_cache; 168 169 /* 170 * inode.c 171 */ 172 extern const struct xattr_handler * const kernfs_xattr_handlers[]; 173 void kernfs_evict_inode(struct inode *inode); 174 int kernfs_iop_permission(struct mnt_idmap *idmap, 175 struct inode *inode, int mask); 176 int kernfs_iop_setattr(struct mnt_idmap *idmap, struct dentry *dentry, 177 struct iattr *iattr); 178 int kernfs_iop_getattr(struct mnt_idmap *idmap, 179 const struct path *path, struct kstat *stat, 180 u32 request_mask, unsigned int query_flags); 181 ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size); 182 int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr); 183 184 /* 185 * dir.c 186 */ 187 extern const struct dentry_operations kernfs_dops; 188 extern const struct file_operations kernfs_dir_fops; 189 extern const struct inode_operations kernfs_dir_iops; 190 191 struct kernfs_node *kernfs_get_active(struct kernfs_node *kn); 192 void kernfs_put_active(struct kernfs_node *kn); 193 int kernfs_add_one(struct kernfs_node *kn); 194 struct kernfs_node *kernfs_new_node(struct kernfs_node *parent, 195 const char *name, umode_t mode, 196 kuid_t uid, kgid_t gid, 197 unsigned flags); 198 199 /* 200 * file.c 201 */ 202 extern const struct file_operations kernfs_file_fops; 203 204 bool kernfs_should_drain_open_files(struct kernfs_node *kn); 205 void kernfs_drain_open_files(struct kernfs_node *kn); 206 207 /* 208 * symlink.c 209 */ 210 extern const struct inode_operations kernfs_symlink_iops; 211 212 /* 213 * kernfs locks 214 */ 215 extern struct kernfs_global_locks *kernfs_locks; 216 217 /* Hashed mutex helpers - protect per-node data structures */ 218 static inline struct mutex *kernfs_node_lock_ptr(struct kernfs_node *kn) 219 { 220 int idx = hash_ptr(kn, NR_KERNFS_LOCK_BITS); 221 222 return &kernfs_locks->node_mutex[idx]; 223 } 224 225 static inline struct mutex *kernfs_node_lock(struct kernfs_node *kn) 226 { 227 struct mutex *lock = kernfs_node_lock_ptr(kn); 228 229 mutex_lock(lock); 230 return lock; 231 } 232 233 DEFINE_CLASS(kernfs_node_lock, struct mutex *, 234 mutex_unlock(_T), kernfs_node_lock(kn), struct kernfs_node *kn) 235 236 #endif /* __KERNFS_INTERNAL_H */ 237