1 #ifndef __LINUX_DCACHE_H 2 #define __LINUX_DCACHE_H 3 4 #include <asm/atomic.h> 5 #include <linux/list.h> 6 #include <linux/rculist.h> 7 #include <linux/spinlock.h> 8 #include <linux/cache.h> 9 #include <linux/rcupdate.h> 10 11 struct nameidata; 12 struct path; 13 struct vfsmount; 14 15 /* 16 * linux/include/linux/dcache.h 17 * 18 * Dirent cache data structures 19 * 20 * (C) Copyright 1997 Thomas Schoebel-Theuer, 21 * with heavy changes by Linus Torvalds 22 */ 23 24 #define IS_ROOT(x) ((x) == (x)->d_parent) 25 26 /* 27 * "quick string" -- eases parameter passing, but more importantly 28 * saves "metadata" about the string (ie length and the hash). 29 * 30 * hash comes first so it snuggles against d_parent in the 31 * dentry. 32 */ 33 struct qstr { 34 unsigned int hash; 35 unsigned int len; 36 const unsigned char *name; 37 }; 38 39 struct dentry_stat_t { 40 int nr_dentry; 41 int nr_unused; 42 int age_limit; /* age in seconds */ 43 int want_pages; /* pages requested by system */ 44 int dummy[2]; 45 }; 46 extern struct dentry_stat_t dentry_stat; 47 48 /* Name hashing routines. Initial hash value */ 49 /* Hash courtesy of the R5 hash in reiserfs modulo sign bits */ 50 #define init_name_hash() 0 51 52 /* partial hash update function. Assume roughly 4 bits per character */ 53 static inline unsigned long 54 partial_name_hash(unsigned long c, unsigned long prevhash) 55 { 56 return (prevhash + (c << 4) + (c >> 4)) * 11; 57 } 58 59 /* 60 * Finally: cut down the number of bits to a int value (and try to avoid 61 * losing bits) 62 */ 63 static inline unsigned long end_name_hash(unsigned long hash) 64 { 65 return (unsigned int) hash; 66 } 67 68 /* Compute the hash for a name string. */ 69 static inline unsigned int 70 full_name_hash(const unsigned char *name, unsigned int len) 71 { 72 unsigned long hash = init_name_hash(); 73 while (len--) 74 hash = partial_name_hash(*name++, hash); 75 return end_name_hash(hash); 76 } 77 78 struct dcookie_struct; 79 80 #define DNAME_INLINE_LEN_MIN 36 81 82 struct dentry { 83 atomic_t d_count; 84 unsigned int d_flags; /* protected by d_lock */ 85 spinlock_t d_lock; /* per dentry lock */ 86 struct inode *d_inode; /* Where the name belongs to - NULL is 87 * negative */ 88 /* 89 * The next three fields are touched by __d_lookup. Place them here 90 * so they all fit in a cache line. 91 */ 92 struct hlist_node d_hash; /* lookup hash list */ 93 struct dentry *d_parent; /* parent directory */ 94 struct qstr d_name; 95 96 struct list_head d_lru; /* LRU list */ 97 /* 98 * d_child and d_rcu can share memory 99 */ 100 union { 101 struct list_head d_child; /* child of parent list */ 102 struct rcu_head d_rcu; 103 } d_u; 104 struct list_head d_subdirs; /* our children */ 105 struct list_head d_alias; /* inode alias list */ 106 unsigned long d_time; /* used by d_revalidate */ 107 struct dentry_operations *d_op; 108 struct super_block *d_sb; /* The root of the dentry tree */ 109 void *d_fsdata; /* fs-specific data */ 110 #ifdef CONFIG_PROFILING 111 struct dcookie_struct *d_cookie; /* cookie, if any */ 112 #endif 113 int d_mounted; 114 unsigned char d_iname[DNAME_INLINE_LEN_MIN]; /* small names */ 115 }; 116 117 /* 118 * dentry->d_lock spinlock nesting subclasses: 119 * 120 * 0: normal 121 * 1: nested 122 */ 123 enum dentry_d_lock_class 124 { 125 DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */ 126 DENTRY_D_LOCK_NESTED 127 }; 128 129 struct dentry_operations { 130 int (*d_revalidate)(struct dentry *, struct nameidata *); 131 int (*d_hash) (struct dentry *, struct qstr *); 132 int (*d_compare) (struct dentry *, struct qstr *, struct qstr *); 133 int (*d_delete)(struct dentry *); 134 void (*d_release)(struct dentry *); 135 void (*d_iput)(struct dentry *, struct inode *); 136 char *(*d_dname)(struct dentry *, char *, int); 137 }; 138 139 /* the dentry parameter passed to d_hash and d_compare is the parent 140 * directory of the entries to be compared. It is used in case these 141 * functions need any directory specific information for determining 142 * equivalency classes. Using the dentry itself might not work, as it 143 * might be a negative dentry which has no information associated with 144 * it */ 145 146 /* 147 locking rules: 148 big lock dcache_lock d_lock may block 149 d_revalidate: no no no yes 150 d_hash no no no yes 151 d_compare: no yes yes no 152 d_delete: no yes no no 153 d_release: no no no yes 154 d_iput: no no no yes 155 */ 156 157 /* d_flags entries */ 158 #define DCACHE_AUTOFS_PENDING 0x0001 /* autofs: "under construction" */ 159 #define DCACHE_NFSFS_RENAMED 0x0002 /* this dentry has been "silly 160 * renamed" and has to be 161 * deleted on the last dput() 162 */ 163 #define DCACHE_DISCONNECTED 0x0004 164 /* This dentry is possibly not currently connected to the dcache tree, 165 * in which case its parent will either be itself, or will have this 166 * flag as well. nfsd will not use a dentry with this bit set, but will 167 * first endeavour to clear the bit either by discovering that it is 168 * connected, or by performing lookup operations. Any filesystem which 169 * supports nfsd_operations MUST have a lookup function which, if it finds 170 * a directory inode with a DCACHE_DISCONNECTED dentry, will d_move 171 * that dentry into place and return that dentry rather than the passed one, 172 * typically using d_splice_alias. 173 */ 174 175 #define DCACHE_REFERENCED 0x0008 /* Recently used, don't discard. */ 176 #define DCACHE_UNHASHED 0x0010 177 178 #define DCACHE_INOTIFY_PARENT_WATCHED 0x0020 /* Parent inode is watched */ 179 180 extern spinlock_t dcache_lock; 181 extern seqlock_t rename_lock; 182 183 /** 184 * d_drop - drop a dentry 185 * @dentry: dentry to drop 186 * 187 * d_drop() unhashes the entry from the parent dentry hashes, so that it won't 188 * be found through a VFS lookup any more. Note that this is different from 189 * deleting the dentry - d_delete will try to mark the dentry negative if 190 * possible, giving a successful _negative_ lookup, while d_drop will 191 * just make the cache lookup fail. 192 * 193 * d_drop() is used mainly for stuff that wants to invalidate a dentry for some 194 * reason (NFS timeouts or autofs deletes). 195 * 196 * __d_drop requires dentry->d_lock. 197 */ 198 199 static inline void __d_drop(struct dentry *dentry) 200 { 201 if (!(dentry->d_flags & DCACHE_UNHASHED)) { 202 dentry->d_flags |= DCACHE_UNHASHED; 203 hlist_del_rcu(&dentry->d_hash); 204 } 205 } 206 207 static inline void d_drop(struct dentry *dentry) 208 { 209 spin_lock(&dcache_lock); 210 spin_lock(&dentry->d_lock); 211 __d_drop(dentry); 212 spin_unlock(&dentry->d_lock); 213 spin_unlock(&dcache_lock); 214 } 215 216 static inline int dname_external(struct dentry *dentry) 217 { 218 return dentry->d_name.name != dentry->d_iname; 219 } 220 221 /* 222 * These are the low-level FS interfaces to the dcache.. 223 */ 224 extern void d_instantiate(struct dentry *, struct inode *); 225 extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *); 226 extern struct dentry * d_materialise_unique(struct dentry *, struct inode *); 227 extern void d_delete(struct dentry *); 228 229 /* allocate/de-allocate */ 230 extern struct dentry * d_alloc(struct dentry *, const struct qstr *); 231 extern struct dentry * d_splice_alias(struct inode *, struct dentry *); 232 extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *); 233 extern struct dentry * d_obtain_alias(struct inode *); 234 extern void shrink_dcache_sb(struct super_block *); 235 extern void shrink_dcache_parent(struct dentry *); 236 extern void shrink_dcache_for_umount(struct super_block *); 237 extern int d_invalidate(struct dentry *); 238 239 /* only used at mount-time */ 240 extern struct dentry * d_alloc_root(struct inode *); 241 242 /* <clickety>-<click> the ramfs-type tree */ 243 extern void d_genocide(struct dentry *); 244 245 extern struct dentry *d_find_alias(struct inode *); 246 extern void d_prune_aliases(struct inode *); 247 248 /* test whether we have any submounts in a subdir tree */ 249 extern int have_submounts(struct dentry *); 250 251 /* 252 * This adds the entry to the hash queues. 253 */ 254 extern void d_rehash(struct dentry *); 255 256 /** 257 * d_add - add dentry to hash queues 258 * @entry: dentry to add 259 * @inode: The inode to attach to this dentry 260 * 261 * This adds the entry to the hash queues and initializes @inode. 262 * The entry was actually filled in earlier during d_alloc(). 263 */ 264 265 static inline void d_add(struct dentry *entry, struct inode *inode) 266 { 267 d_instantiate(entry, inode); 268 d_rehash(entry); 269 } 270 271 /** 272 * d_add_unique - add dentry to hash queues without aliasing 273 * @entry: dentry to add 274 * @inode: The inode to attach to this dentry 275 * 276 * This adds the entry to the hash queues and initializes @inode. 277 * The entry was actually filled in earlier during d_alloc(). 278 */ 279 static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode) 280 { 281 struct dentry *res; 282 283 res = d_instantiate_unique(entry, inode); 284 d_rehash(res != NULL ? res : entry); 285 return res; 286 } 287 288 /* used for rename() and baskets */ 289 extern void d_move(struct dentry *, struct dentry *); 290 extern struct dentry *d_ancestor(struct dentry *, struct dentry *); 291 292 /* appendix may either be NULL or be used for transname suffixes */ 293 extern struct dentry * d_lookup(struct dentry *, struct qstr *); 294 extern struct dentry * __d_lookup(struct dentry *, struct qstr *); 295 extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *); 296 297 /* validate "insecure" dentry pointer */ 298 extern int d_validate(struct dentry *, struct dentry *); 299 300 /* 301 * helper function for dentry_operations.d_dname() members 302 */ 303 extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...); 304 305 extern char *__d_path(const struct path *path, struct path *root, char *, int); 306 extern char *d_path(const struct path *, char *, int); 307 extern char *dentry_path(struct dentry *, char *, int); 308 309 /* Allocation counts.. */ 310 311 /** 312 * dget, dget_locked - get a reference to a dentry 313 * @dentry: dentry to get a reference to 314 * 315 * Given a dentry or %NULL pointer increment the reference count 316 * if appropriate and return the dentry. A dentry will not be 317 * destroyed when it has references. dget() should never be 318 * called for dentries with zero reference counter. For these cases 319 * (preferably none, functions in dcache.c are sufficient for normal 320 * needs and they take necessary precautions) you should hold dcache_lock 321 * and call dget_locked() instead of dget(). 322 */ 323 324 static inline struct dentry *dget(struct dentry *dentry) 325 { 326 if (dentry) { 327 BUG_ON(!atomic_read(&dentry->d_count)); 328 atomic_inc(&dentry->d_count); 329 } 330 return dentry; 331 } 332 333 extern struct dentry * dget_locked(struct dentry *); 334 335 /** 336 * d_unhashed - is dentry hashed 337 * @dentry: entry to check 338 * 339 * Returns true if the dentry passed is not currently hashed. 340 */ 341 342 static inline int d_unhashed(struct dentry *dentry) 343 { 344 return (dentry->d_flags & DCACHE_UNHASHED); 345 } 346 347 static inline struct dentry *dget_parent(struct dentry *dentry) 348 { 349 struct dentry *ret; 350 351 spin_lock(&dentry->d_lock); 352 ret = dget(dentry->d_parent); 353 spin_unlock(&dentry->d_lock); 354 return ret; 355 } 356 357 extern void dput(struct dentry *); 358 359 static inline int d_mountpoint(struct dentry *dentry) 360 { 361 return dentry->d_mounted; 362 } 363 364 extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *); 365 extern struct dentry *lookup_create(struct nameidata *nd, int is_dir); 366 367 extern int sysctl_vfs_cache_pressure; 368 369 #endif /* __LINUX_DCACHE_H */ 370