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