Line data Source code
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 5 :
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 : * 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 1 : extern int sysctl_vfs_cache_pressure;
382 1 :
383 : #endif /* __LINUX_DCACHE_H */
|