blob: a3ed5e059d479eb2ff7ee712f6adff5170c2a4be [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#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
13struct nameidata;
14struct 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 */
34struct qstr {
35 unsigned int hash;
36 unsigned int len;
37 const unsigned char *name;
38};
39
40struct 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};
47extern 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 */
54static inline unsigned long
55partial_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 */
64static 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. */
70static inline unsigned int
71full_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
79struct dcookie_struct;
80
81#define DNAME_INLINE_LEN_MIN 36
82
83struct 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
Eric Dumazet3f4bb1f2005-09-06 15:18:16 -070091 * so they all fit in a cache line.
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 */
Eric Dumazet3f4bb1f2005-09-06 15:18:16 -070093 struct hlist_node d_hash; /* lookup hash list */
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 struct dentry *d_parent; /* parent directory */
95 struct qstr d_name;
96
97 struct list_head d_lru; /* LRU list */
Eric Dumazet5160ee62006-01-08 01:03:32 -080098 /*
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 struct dcookie_struct *d_cookie; /* cookie, if any */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 int d_mounted;
113 unsigned char d_iname[DNAME_INLINE_LEN_MIN]; /* small names */
114};
115
116struct 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/*
133locking rules:
134 big lock dcache_lock d_lock may block
135d_revalidate: no no no yes
136d_hash no no no yes
137d_compare: no yes yes no
138d_delete: no yes no no
139d_release: no no no yes
140d_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
164extern 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
182static 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
190static 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
199static 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 */
207extern void d_instantiate(struct dentry *, struct inode *);
208extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
209extern void d_delete(struct dentry *);
210
211/* allocate/de-allocate */
212extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
213extern struct dentry * d_alloc_anon(struct inode *);
214extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
215extern void shrink_dcache_sb(struct super_block *);
216extern void shrink_dcache_parent(struct dentry *);
217extern void shrink_dcache_anon(struct hlist_head *);
218extern int d_invalidate(struct dentry *);
219
220/* only used at mount-time */
221extern struct dentry * d_alloc_root(struct inode *);
222
223/* <clickety>-<click> the ramfs-type tree */
224extern void d_genocide(struct dentry *);
225
226extern struct dentry *d_find_alias(struct inode *);
227extern void d_prune_aliases(struct inode *);
228
229/* test whether we have any submounts in a subdir tree */
230extern int have_submounts(struct dentry *);
231
232/*
233 * This adds the entry to the hash queues.
234 */
235extern 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
246static 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 */
260static 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 */
270extern void d_move(struct dentry *, struct dentry *);
271
272/* appendix may either be NULL or be used for transname suffixes */
273extern struct dentry * d_lookup(struct dentry *, struct qstr *);
274extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
275
276/* validate "insecure" dentry pointer */
277extern int d_validate(struct dentry *, struct dentry *);
278
279extern 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
296static 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
305extern 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
314static inline int d_unhashed(struct dentry *dentry)
315{
316 return (dentry->d_flags & DCACHE_UNHASHED);
317}
318
319static 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
329extern void dput(struct dentry *);
330
331static inline int d_mountpoint(struct dentry *dentry)
332{
333 return dentry->d_mounted;
334}
335
336extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *);
Ram Paia05964f2005-11-07 17:20:17 -0500337extern struct vfsmount *__lookup_mnt(struct vfsmount *, struct dentry *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
339
340extern int sysctl_vfs_cache_pressure;
341
342#endif /* __KERNEL__ */
343
344#endif /* __LINUX_DCACHE_H */