1#ifndef __LINUX_DCACHE_H 2#define __LINUX_DCACHE_H 3 4#ifdef __KERNEL__ 5 6#include <asm/atomic.h> 7#include <linux/list.h> 8#include <linux/spinlock.h> 9#include <linux/cache.h> 10#include <linux/rcupdate.h> 11 12struct nameidata; 13struct 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 */ 33struct qstr { 34 unsigned int hash; 35 unsigned int len; 36 const unsigned char *name; 37}; 38 39struct 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}; 46extern 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 */ 53static inline unsigned long 54partial_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 */ 63static 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. */ 69static inline unsigned int 70full_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 78struct dcookie_struct; 79 80#define DNAME_INLINE_LEN_MIN 36 81 82struct 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 */ 123enum dentry_d_lock_class 124{ 125 DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */ 126 DENTRY_D_LOCK_NESTED 127}; 128 129struct 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/* 147locking rules: 148 big lock dcache_lock d_lock may block 149d_revalidate: no no no yes 150d_hash no no no yes 151d_compare: no yes yes no 152d_delete: no yes no no 153d_release: no no no yes 154d_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 180extern spinlock_t dcache_lock; 181 182/** 183 * d_drop - drop a dentry 184 * @dentry: dentry to drop 185 * 186 * d_drop() unhashes the entry from the parent dentry hashes, so that it won't 187 * be found through a VFS lookup any more. Note that this is different from 188 * deleting the dentry - d_delete will try to mark the dentry negative if 189 * possible, giving a successful _negative_ lookup, while d_drop will 190 * just make the cache lookup fail. 191 * 192 * d_drop() is used mainly for stuff that wants to invalidate a dentry for some 193 * reason (NFS timeouts or autofs deletes). 194 * 195 * __d_drop requires dentry->d_lock. 196 */ 197 198static inline void __d_drop(struct dentry *dentry) 199{ 200 if (!(dentry->d_flags & DCACHE_UNHASHED)) { 201 dentry->d_flags |= DCACHE_UNHASHED; 202 hlist_del_rcu(&dentry->d_hash); 203 } 204} 205 206static inline void d_drop(struct dentry *dentry) 207{ 208 spin_lock(&dcache_lock); 209 spin_lock(&dentry->d_lock); 210 __d_drop(dentry); 211 spin_unlock(&dentry->d_lock); 212 spin_unlock(&dcache_lock); 213} 214 215static inline int dname_external(struct dentry *dentry) 216{ 217 return dentry->d_name.name != dentry->d_iname; 218} 219 220/* 221 * These are the low-level FS interfaces to the dcache.. 222 */ 223extern void d_instantiate(struct dentry *, struct inode *); 224extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *); 225extern struct dentry * d_materialise_unique(struct dentry *, struct inode *); 226extern void d_delete(struct dentry *); 227 228/* allocate/de-allocate */ 229extern struct dentry * d_alloc(struct dentry *, const struct qstr *); 230extern struct dentry * d_alloc_anon(struct inode *); 231extern struct dentry * d_splice_alias(struct inode *, struct dentry *); 232extern void shrink_dcache_sb(struct super_block *); 233extern void shrink_dcache_parent(struct dentry *); 234extern void shrink_dcache_for_umount(struct super_block *); 235extern int d_invalidate(struct dentry *); 236 237/* only used at mount-time */ 238extern struct dentry * d_alloc_root(struct inode *); 239 240/* <clickety>-<click> the ramfs-type tree */ 241extern void d_genocide(struct dentry *); 242 243extern struct dentry *d_find_alias(struct inode *); 244extern void d_prune_aliases(struct inode *); 245 246/* test whether we have any submounts in a subdir tree */ 247extern int have_submounts(struct dentry *); 248 249/* 250 * This adds the entry to the hash queues. 251 */ 252extern void d_rehash(struct dentry *); 253 254/** 255 * d_add - add dentry to hash queues 256 * @entry: dentry to add 257 * @inode: The inode to attach to this dentry 258 * 259 * This adds the entry to the hash queues and initializes @inode. 260 * The entry was actually filled in earlier during d_alloc(). 261 */ 262 263static inline void d_add(struct dentry *entry, struct inode *inode) 264{ 265 d_instantiate(entry, inode); 266 d_rehash(entry); 267} 268 269/** 270 * d_add_unique - add dentry to hash queues without aliasing 271 * @entry: dentry to add 272 * @inode: The inode to attach to this dentry 273 * 274 * This adds the entry to the hash queues and initializes @inode. 275 * The entry was actually filled in earlier during d_alloc(). 276 */ 277static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode) 278{ 279 struct dentry *res; 280 281 res = d_instantiate_unique(entry, inode); 282 d_rehash(res != NULL ? res : entry); 283 return res; 284} 285 286/* used for rename() and baskets */ 287extern void d_move(struct dentry *, struct dentry *); 288 289/* appendix may either be NULL or be used for transname suffixes */ 290extern struct dentry * d_lookup(struct dentry *, struct qstr *); 291extern struct dentry * __d_lookup(struct dentry *, struct qstr *); 292extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *); 293 294/* validate "insecure" dentry pointer */ 295extern int d_validate(struct dentry *, struct dentry *); 296 297/* 298 * helper function for dentry_operations.d_dname() members 299 */ 300extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...); 301 302extern char * d_path(struct dentry *, struct vfsmount *, char *, int); 303 304/* Allocation counts.. */ 305 306/** 307 * dget, dget_locked - get a reference to a dentry 308 * @dentry: dentry to get a reference to 309 * 310 * Given a dentry or %NULL pointer increment the reference count 311 * if appropriate and return the dentry. A dentry will not be 312 * destroyed when it has references. dget() should never be 313 * called for dentries with zero reference counter. For these cases 314 * (preferably none, functions in dcache.c are sufficient for normal 315 * needs and they take necessary precautions) you should hold dcache_lock 316 * and call dget_locked() instead of dget(). 317 */ 318 319static inline struct dentry *dget(struct dentry *dentry) 320{ 321 if (dentry) { 322 BUG_ON(!atomic_read(&dentry->d_count)); 323 atomic_inc(&dentry->d_count); 324 } 325 return dentry; 326} 327 328extern struct dentry * dget_locked(struct dentry *); 329 330/** 331 * d_unhashed - is dentry hashed 332 * @dentry: entry to check 333 * 334 * Returns true if the dentry passed is not currently hashed. 335 */ 336 337static inline int d_unhashed(struct dentry *dentry) 338{ 339 return (dentry->d_flags & DCACHE_UNHASHED); 340} 341 342static inline struct dentry *dget_parent(struct dentry *dentry) 343{ 344 struct dentry *ret; 345 346 spin_lock(&dentry->d_lock); 347 ret = dget(dentry->d_parent); 348 spin_unlock(&dentry->d_lock); 349 return ret; 350} 351 352extern void dput(struct dentry *); 353 354static inline int d_mountpoint(struct dentry *dentry) 355{ 356 return dentry->d_mounted; 357} 358 359extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *); 360extern struct vfsmount *__lookup_mnt(struct vfsmount *, struct dentry *, int); 361extern struct dentry *lookup_create(struct nameidata *nd, int is_dir); 362 363extern int sysctl_vfs_cache_pressure; 364 365#endif /* __KERNEL__ */ 366 367#endif /* __LINUX_DCACHE_H */ 368