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 /* 79 * Try to keep struct dentry aligned on 64 byte cachelines (this will 80 * give reasonable cacheline footprint with larger lines without the 81 * large memory footprint increase). 82 */ 83 #ifdef CONFIG_64BIT 84 #define DNAME_INLINE_LEN_MIN 32 /* 192 bytes */ 85 #else 86 #define DNAME_INLINE_LEN_MIN 40 /* 128 bytes */ 87 #endif 88 89 struct dentry { 90 atomic_t d_count; 91 unsigned int d_flags; /* protected by d_lock */ 92 spinlock_t d_lock; /* per dentry lock */ 93 int d_mounted; 94 struct inode *d_inode; /* Where the name belongs to - NULL is 95 * negative */ 96 /* 97 * The next three fields are touched by __d_lookup. Place them here 98 * so they all fit in a cache line. 99 */ 100 struct hlist_node d_hash; /* lookup hash list */ 101 struct dentry *d_parent; /* parent directory */ 102 struct qstr d_name; 103 104 struct list_head d_lru; /* LRU list */ 105 /* 106 * d_child and d_rcu can share memory 107 */ 108 union { 109 struct list_head d_child; /* child of parent list */ 110 struct rcu_head d_rcu; 111 } d_u; 112 struct list_head d_subdirs; /* our children */ 113 struct list_head d_alias; /* inode alias list */ 114 unsigned long d_time; /* used by d_revalidate */ 115 const struct dentry_operations *d_op; 116 struct super_block *d_sb; /* The root of the dentry tree */ 117 void *d_fsdata; /* fs-specific data */ 118 119 unsigned char d_iname[DNAME_INLINE_LEN_MIN]; /* small names */ 120 }; 121 122 /* 123 * dentry->d_lock spinlock nesting subclasses: 124 * 125 * 0: normal 126 * 1: nested 127 */ 128 enum dentry_d_lock_class 129 { 130 DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */ 131 DENTRY_D_LOCK_NESTED 132 }; 133 134 struct dentry_operations { 135 int (*d_revalidate)(struct dentry *, struct nameidata *); 136 int (*d_hash) (struct dentry *, struct qstr *); 137 int (*d_compare) (struct dentry *, struct qstr *, struct qstr *); 138 int (*d_delete)(struct dentry *); 139 void (*d_release)(struct dentry *); 140 void (*d_iput)(struct dentry *, struct inode *); 141 char *(*d_dname)(struct dentry *, char *, int); 142 }; 143 144 /* the dentry parameter passed to d_hash and d_compare is the parent 145 * directory of the entries to be compared. It is used in case these 146 * functions need any directory specific information for determining 147 * equivalency classes. Using the dentry itself might not work, as it 148 * might be a negative dentry which has no information associated with 149 * it */ 150 151 /* 152 locking rules: 153 big lock dcache_lock d_lock may block 154 d_revalidate: no no no yes 155 d_hash no no no yes 156 d_compare: no yes yes no 157 d_delete: no yes no no 158 d_release: no no no yes 159 d_iput: no no no yes 160 */ 161 162 /* d_flags entries */ 163 #define DCACHE_AUTOFS_PENDING 0x0001 /* autofs: "under construction" */ 164 #define DCACHE_NFSFS_RENAMED 0x0002 /* this dentry has been "silly 165 * renamed" and has to be 166 * deleted on the last dput() 167 */ 168 #define DCACHE_DISCONNECTED 0x0004 169 /* This dentry is possibly not currently connected to the dcache tree, 170 * in which case its parent will either be itself, or will have this 171 * flag as well. nfsd will not use a dentry with this bit set, but will 172 * first endeavour to clear the bit either by discovering that it is 173 * connected, or by performing lookup operations. Any filesystem which 174 * supports nfsd_operations MUST have a lookup function which, if it finds 175 * a directory inode with a DCACHE_DISCONNECTED dentry, will d_move 176 * that dentry into place and return that dentry rather than the passed one, 177 * typically using d_splice_alias. 178 */ 179 180 #define DCACHE_REFERENCED 0x0008 /* Recently used, don't discard. */ 181 #define DCACHE_UNHASHED 0x0010 182 183 #define DCACHE_INOTIFY_PARENT_WATCHED 0x0020 /* Parent inode is watched by inotify */ 184 185 #define DCACHE_COOKIE 0x0040 /* For use by dcookie subsystem */ 186 187 #define DCACHE_FSNOTIFY_PARENT_WATCHED 0x0080 /* Parent inode is watched by some fsnotify listener */ 188 189 extern spinlock_t dcache_lock; 190 extern seqlock_t rename_lock; 191 192 /** 193 * d_drop - drop a dentry 194 * @dentry: dentry to drop 195 * 196 * d_drop() unhashes the entry from the parent dentry hashes, so that it won't 197 * be found through a VFS lookup any more. Note that this is different from 198 * deleting the dentry - d_delete will try to mark the dentry negative if 199 * possible, giving a successful _negative_ lookup, while d_drop will 200 * just make the cache lookup fail. 201 * 202 * d_drop() is used mainly for stuff that wants to invalidate a dentry for some 203 * reason (NFS timeouts or autofs deletes). 204 * 205 * __d_drop requires dentry->d_lock. 206 */ 207 208 static inline void __d_drop(struct dentry *dentry) 209 { 210 if (!(dentry->d_flags & DCACHE_UNHASHED)) { 211 dentry->d_flags |= DCACHE_UNHASHED; 212 hlist_del_rcu(&dentry->d_hash); 213 } 214 } 215 216 static inline void d_drop(struct dentry *dentry) 217 { 218 spin_lock(&dcache_lock); 219 spin_lock(&dentry->d_lock); 220 __d_drop(dentry); 221 spin_unlock(&dentry->d_lock); 222 spin_unlock(&dcache_lock); 223 } 224 225 static inline int dname_external(struct dentry *dentry) 226 { 227 return dentry->d_name.name != dentry->d_iname; 228 } 229 230 /* 231 * These are the low-level FS interfaces to the dcache.. 232 */ 233 extern void d_instantiate(struct dentry *, struct inode *); 234 extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *); 235 extern struct dentry * d_materialise_unique(struct dentry *, struct inode *); 236 extern void d_delete(struct dentry *); 237 238 /* allocate/de-allocate */ 239 extern struct dentry * d_alloc(struct dentry *, const struct qstr *); 240 extern struct dentry * d_splice_alias(struct inode *, struct dentry *); 241 extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *); 242 extern struct dentry * d_obtain_alias(struct inode *); 243 extern void shrink_dcache_sb(struct super_block *); 244 extern void shrink_dcache_parent(struct dentry *); 245 extern void shrink_dcache_for_umount(struct super_block *); 246 extern int d_invalidate(struct dentry *); 247 248 /* only used at mount-time */ 249 extern struct dentry * d_alloc_root(struct inode *); 250 251 /* <clickety>-<click> the ramfs-type tree */ 252 extern void d_genocide(struct dentry *); 253 254 extern struct dentry *d_find_alias(struct inode *); 255 extern void d_prune_aliases(struct inode *); 256 257 /* test whether we have any submounts in a subdir tree */ 258 extern int have_submounts(struct dentry *); 259 260 /* 261 * This adds the entry to the hash queues. 262 */ 263 extern void d_rehash(struct dentry *); 264 265 /** 266 * d_add - add dentry to hash queues 267 * @entry: dentry to add 268 * @inode: The inode to attach to this dentry 269 * 270 * This adds the entry to the hash queues and initializes @inode. 271 * The entry was actually filled in earlier during d_alloc(). 272 */ 273 274 static inline void d_add(struct dentry *entry, struct inode *inode) 275 { 276 d_instantiate(entry, inode); 277 d_rehash(entry); 278 } 279 280 /** 281 * d_add_unique - add dentry to hash queues without aliasing 282 * @entry: dentry to add 283 * @inode: The inode to attach to this dentry 284 * 285 * This adds the entry to the hash queues and initializes @inode. 286 * The entry was actually filled in earlier during d_alloc(). 287 */ 288 static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode) 289 { 290 struct dentry *res; 291 292 res = d_instantiate_unique(entry, inode); 293 d_rehash(res != NULL ? res : entry); 294 return res; 295 } 296 297 /* used for rename() and baskets */ 298 extern void d_move(struct dentry *, struct dentry *); 299 extern struct dentry *d_ancestor(struct dentry *, struct dentry *); 300 301 /* appendix may either be NULL or be used for transname suffixes */ 302 extern struct dentry * d_lookup(struct dentry *, struct qstr *); 303 extern struct dentry * __d_lookup(struct dentry *, struct qstr *); 304 extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *); 305 306 /* validate "insecure" dentry pointer */ 307 extern int d_validate(struct dentry *, struct dentry *); 308 309 /* 310 * helper function for dentry_operations.d_dname() members 311 */ 312 extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...); 313 314 extern char *__d_path(const struct path *path, struct path *root, char *, int); 315 extern char *d_path(const struct path *, char *, int); 316 extern char *dentry_path(struct dentry *, char *, int); 317 318 /* Allocation counts.. */ 319 320 /** 321 * dget, dget_locked - get a reference to a dentry 322 * @dentry: dentry to get a reference to 323 * 324 * Given a dentry or %NULL pointer increment the reference count 325 * if appropriate and return the dentry. A dentry will not be 326 * destroyed when it has references. dget() should never be 327 * called for dentries with zero reference counter. For these cases 328 * (preferably none, functions in dcache.c are sufficient for normal 329 * needs and they take necessary precautions) you should hold dcache_lock 330 * and call dget_locked() instead of dget(). 331 */ 332 333 static inline struct dentry *dget(struct dentry *dentry) 334 { 335 if (dentry) { 336 BUG_ON(!atomic_read(&dentry->d_count)); 337 atomic_inc(&dentry->d_count); 338 } 339 return dentry; 340 } 341 342 extern struct dentry * dget_locked(struct dentry *); 343 344 /** 345 * d_unhashed - is dentry hashed 346 * @dentry: entry to check 347 * 348 * Returns true if the dentry passed is not currently hashed. 349 */ 350 351 static inline int d_unhashed(struct dentry *dentry) 352 { 353 return (dentry->d_flags & DCACHE_UNHASHED); 354 } 355 356 static inline int d_unlinked(struct dentry *dentry) 357 { 358 return d_unhashed(dentry) && !IS_ROOT(dentry); 359 } 360 361 static inline struct dentry *dget_parent(struct dentry *dentry) 362 { 363 struct dentry *ret; 364 365 spin_lock(&dentry->d_lock); 366 ret = dget(dentry->d_parent); 367 spin_unlock(&dentry->d_lock); 368 return ret; 369 } 370 371 extern void dput(struct dentry *); 372 373 static inline int d_mountpoint(struct dentry *dentry) 374 { 375 return dentry->d_mounted; 376 } 377 378 extern struct vfsmount *lookup_mnt(struct path *); 379 extern struct dentry *lookup_create(struct nameidata *nd, int is_dir); 380 381 extern int sysctl_vfs_cache_pressure; 382 383 #endif /* __LINUX_DCACHE_H */ 384