Branch data Line data Source code
1 : : #ifndef __LINUX_DCACHE_H
2 : : #define __LINUX_DCACHE_H
3 : :
4 : : #include <linux/atomic.h>
5 : : #include <linux/list.h>
6 : : #include <linux/rculist.h>
7 : : #include <linux/rculist_bl.h>
8 : : #include <linux/spinlock.h>
9 : : #include <linux/seqlock.h>
10 : : #include <linux/cache.h>
11 : : #include <linux/rcupdate.h>
12 : : #include <linux/lockref.h>
13 : :
14 : : struct nameidata;
15 : : struct path;
16 : : struct vfsmount;
17 : :
18 : : /*
19 : : * linux/include/linux/dcache.h
20 : : *
21 : : * Dirent cache data structures
22 : : *
23 : : * (C) Copyright 1997 Thomas Schoebel-Theuer,
24 : : * with heavy changes by Linus Torvalds
25 : : */
26 : :
27 : : #define IS_ROOT(x) ((x) == (x)->d_parent)
28 : :
29 : : /* The hash is always the low bits of hash_len */
30 : : #ifdef __LITTLE_ENDIAN
31 : : #define HASH_LEN_DECLARE u32 hash; u32 len;
32 : : #define bytemask_from_count(cnt) (~(~0ul << (cnt)*8))
33 : : #else
34 : : #define HASH_LEN_DECLARE u32 len; u32 hash;
35 : : #define bytemask_from_count(cnt) (~(~0ul >> (cnt)*8))
36 : : #endif
37 : :
38 : : /*
39 : : * "quick string" -- eases parameter passing, but more importantly
40 : : * saves "metadata" about the string (ie length and the hash).
41 : : *
42 : : * hash comes first so it snuggles against d_parent in the
43 : : * dentry.
44 : : */
45 : : struct qstr {
46 : : union {
47 : : struct {
48 : : HASH_LEN_DECLARE;
49 : : };
50 : : u64 hash_len;
51 : : };
52 : : const unsigned char *name;
53 : : };
54 : :
55 : : #define QSTR_INIT(n,l) { { { .len = l } }, .name = n }
56 : : #define hashlen_hash(hashlen) ((u32) (hashlen))
57 : : #define hashlen_len(hashlen) ((u32)((hashlen) >> 32))
58 : :
59 : : struct dentry_stat_t {
60 : : long nr_dentry;
61 : : long nr_unused;
62 : : long age_limit; /* age in seconds */
63 : : long want_pages; /* pages requested by system */
64 : : long dummy[2];
65 : : };
66 : : extern struct dentry_stat_t dentry_stat;
67 : :
68 : : /* Name hashing routines. Initial hash value */
69 : : /* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
70 : : #define init_name_hash() 0
71 : :
72 : : /* partial hash update function. Assume roughly 4 bits per character */
73 : : static inline unsigned long
74 : : partial_name_hash(unsigned long c, unsigned long prevhash)
75 : : {
76 : 94808 : return (prevhash + (c << 4) + (c >> 4)) * 11;
77 : : }
78 : :
79 : : /*
80 : : * Finally: cut down the number of bits to a int value (and try to avoid
81 : : * losing bits)
82 : : */
83 : : static inline unsigned long end_name_hash(unsigned long hash)
84 : : {
85 : : return (unsigned int) hash;
86 : : }
87 : :
88 : : /* Compute the hash for a name string. */
89 : : extern unsigned int full_name_hash(const unsigned char *, unsigned int);
90 : :
91 : : /*
92 : : * Try to keep struct dentry aligned on 64 byte cachelines (this will
93 : : * give reasonable cacheline footprint with larger lines without the
94 : : * large memory footprint increase).
95 : : */
96 : : #ifdef CONFIG_64BIT
97 : : # define DNAME_INLINE_LEN 32 /* 192 bytes */
98 : : #else
99 : : # ifdef CONFIG_SMP
100 : : # define DNAME_INLINE_LEN 36 /* 128 bytes */
101 : : # else
102 : : # define DNAME_INLINE_LEN 40 /* 128 bytes */
103 : : # endif
104 : : #endif
105 : :
106 : : #define d_lock d_lockref.lock
107 : :
108 : : struct dentry {
109 : : /* RCU lookup touched fields */
110 : : unsigned int d_flags; /* protected by d_lock */
111 : : seqcount_t d_seq; /* per dentry seqlock */
112 : : struct hlist_bl_node d_hash; /* lookup hash list */
113 : : struct dentry *d_parent; /* parent directory */
114 : : struct qstr d_name;
115 : : struct inode *d_inode; /* Where the name belongs to - NULL is
116 : : * negative */
117 : : unsigned char d_iname[DNAME_INLINE_LEN]; /* small names */
118 : :
119 : : /* Ref lookup also touches following */
120 : : struct lockref d_lockref; /* per-dentry lock and refcount */
121 : : const struct dentry_operations *d_op;
122 : : struct super_block *d_sb; /* The root of the dentry tree */
123 : : unsigned long d_time; /* used by d_revalidate */
124 : : void *d_fsdata; /* fs-specific data */
125 : :
126 : : struct list_head d_lru; /* LRU list */
127 : : /*
128 : : * d_child and d_rcu can share memory
129 : : */
130 : : union {
131 : : struct list_head d_child; /* child of parent list */
132 : : struct rcu_head d_rcu;
133 : : } d_u;
134 : : struct list_head d_subdirs; /* our children */
135 : : struct hlist_node d_alias; /* inode alias list */
136 : : };
137 : :
138 : : /*
139 : : * dentry->d_lock spinlock nesting subclasses:
140 : : *
141 : : * 0: normal
142 : : * 1: nested
143 : : */
144 : : enum dentry_d_lock_class
145 : : {
146 : : DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */
147 : : DENTRY_D_LOCK_NESTED
148 : : };
149 : :
150 : : struct dentry_operations {
151 : : int (*d_revalidate)(struct dentry *, unsigned int);
152 : : int (*d_weak_revalidate)(struct dentry *, unsigned int);
153 : : int (*d_hash)(const struct dentry *, struct qstr *);
154 : : int (*d_compare)(const struct dentry *, const struct dentry *,
155 : : unsigned int, const char *, const struct qstr *);
156 : : int (*d_delete)(const struct dentry *);
157 : : void (*d_release)(struct dentry *);
158 : : void (*d_prune)(struct dentry *);
159 : : void (*d_iput)(struct dentry *, struct inode *);
160 : : char *(*d_dname)(struct dentry *, char *, int);
161 : : struct vfsmount *(*d_automount)(struct path *);
162 : : int (*d_manage)(struct dentry *, bool);
163 : : } ____cacheline_aligned;
164 : :
165 : : /*
166 : : * Locking rules for dentry_operations callbacks are to be found in
167 : : * Documentation/filesystems/Locking. Keep it updated!
168 : : *
169 : : * FUrther descriptions are found in Documentation/filesystems/vfs.txt.
170 : : * Keep it updated too!
171 : : */
172 : :
173 : : /* d_flags entries */
174 : : #define DCACHE_OP_HASH 0x00000001
175 : : #define DCACHE_OP_COMPARE 0x00000002
176 : : #define DCACHE_OP_REVALIDATE 0x00000004
177 : : #define DCACHE_OP_DELETE 0x00000008
178 : : #define DCACHE_OP_PRUNE 0x00000010
179 : :
180 : : #define DCACHE_DISCONNECTED 0x00000020
181 : : /* This dentry is possibly not currently connected to the dcache tree, in
182 : : * which case its parent will either be itself, or will have this flag as
183 : : * well. nfsd will not use a dentry with this bit set, but will first
184 : : * endeavour to clear the bit either by discovering that it is connected,
185 : : * or by performing lookup operations. Any filesystem which supports
186 : : * nfsd_operations MUST have a lookup function which, if it finds a
187 : : * directory inode with a DCACHE_DISCONNECTED dentry, will d_move that
188 : : * dentry into place and return that dentry rather than the passed one,
189 : : * typically using d_splice_alias. */
190 : :
191 : : #define DCACHE_REFERENCED 0x00000040 /* Recently used, don't discard. */
192 : : #define DCACHE_RCUACCESS 0x00000080 /* Entry has ever been RCU-visible */
193 : :
194 : : #define DCACHE_CANT_MOUNT 0x00000100
195 : : #define DCACHE_GENOCIDE 0x00000200
196 : : #define DCACHE_SHRINK_LIST 0x00000400
197 : :
198 : : #define DCACHE_OP_WEAK_REVALIDATE 0x00000800
199 : :
200 : : #define DCACHE_NFSFS_RENAMED 0x00001000
201 : : /* this dentry has been "silly renamed" and has to be deleted on the last
202 : : * dput() */
203 : : #define DCACHE_COOKIE 0x00002000 /* For use by dcookie subsystem */
204 : : #define DCACHE_FSNOTIFY_PARENT_WATCHED 0x00004000
205 : : /* Parent inode is watched by some fsnotify listener */
206 : :
207 : : #define DCACHE_DENTRY_KILLED 0x00008000
208 : :
209 : : #define DCACHE_MOUNTED 0x00010000 /* is a mountpoint */
210 : : #define DCACHE_NEED_AUTOMOUNT 0x00020000 /* handle automount on this dir */
211 : : #define DCACHE_MANAGE_TRANSIT 0x00040000 /* manage transit from this dirent */
212 : : #define DCACHE_MANAGED_DENTRY \
213 : : (DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT)
214 : :
215 : : #define DCACHE_LRU_LIST 0x00080000
216 : :
217 : : #define DCACHE_ENTRY_TYPE 0x00700000
218 : : #define DCACHE_MISS_TYPE 0x00000000 /* Negative dentry */
219 : : #define DCACHE_DIRECTORY_TYPE 0x00100000 /* Normal directory */
220 : : #define DCACHE_AUTODIR_TYPE 0x00200000 /* Lookupless directory (presumed automount) */
221 : : #define DCACHE_SYMLINK_TYPE 0x00300000 /* Symlink */
222 : : #define DCACHE_FILE_TYPE 0x00400000 /* Other file type */
223 : :
224 : : extern seqlock_t rename_lock;
225 : :
226 : : static inline int dname_external(const struct dentry *dentry)
227 : : {
228 : 2492498 : return dentry->d_name.name != dentry->d_iname;
229 : : }
230 : :
231 : : /*
232 : : * These are the low-level FS interfaces to the dcache..
233 : : */
234 : : extern void d_instantiate(struct dentry *, struct inode *);
235 : : extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
236 : : extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
237 : : extern int d_instantiate_no_diralias(struct dentry *, struct inode *);
238 : : extern void __d_drop(struct dentry *dentry);
239 : : extern void d_drop(struct dentry *dentry);
240 : : extern void d_delete(struct dentry *);
241 : : extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
242 : :
243 : : /* allocate/de-allocate */
244 : : extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
245 : : extern struct dentry * d_alloc_pseudo(struct super_block *, const struct qstr *);
246 : : extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
247 : : extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
248 : : extern struct dentry *d_find_any_alias(struct inode *inode);
249 : : extern struct dentry * d_obtain_alias(struct inode *);
250 : : extern void shrink_dcache_sb(struct super_block *);
251 : : extern void shrink_dcache_parent(struct dentry *);
252 : : extern void shrink_dcache_for_umount(struct super_block *);
253 : : extern int d_invalidate(struct dentry *);
254 : :
255 : : /* only used at mount-time */
256 : : extern struct dentry * d_make_root(struct inode *);
257 : :
258 : : /* <clickety>-<click> the ramfs-type tree */
259 : : extern void d_genocide(struct dentry *);
260 : :
261 : : extern void d_tmpfile(struct dentry *, struct inode *);
262 : :
263 : : extern struct dentry *d_find_alias(struct inode *);
264 : : extern void d_prune_aliases(struct inode *);
265 : :
266 : : /* test whether we have any submounts in a subdir tree */
267 : : extern int have_submounts(struct dentry *);
268 : : extern int check_submounts_and_drop(struct dentry *);
269 : :
270 : : /*
271 : : * This adds the entry to the hash queues.
272 : : */
273 : : extern void d_rehash(struct dentry *);
274 : :
275 : : /**
276 : : * d_add - add dentry to hash queues
277 : : * @entry: dentry to add
278 : : * @inode: The inode to attach to this dentry
279 : : *
280 : : * This adds the entry to the hash queues and initializes @inode.
281 : : * The entry was actually filled in earlier during d_alloc().
282 : : */
283 : :
284 : : static inline void d_add(struct dentry *entry, struct inode *inode)
285 : : {
286 : 569948 : d_instantiate(entry, inode);
287 : 569948 : d_rehash(entry);
288 : : }
289 : :
290 : : /**
291 : : * d_add_unique - add dentry to hash queues without aliasing
292 : : * @entry: dentry to add
293 : : * @inode: The inode to attach to this dentry
294 : : *
295 : : * This adds the entry to the hash queues and initializes @inode.
296 : : * The entry was actually filled in earlier during d_alloc().
297 : : */
298 : : static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
299 : : {
300 : : struct dentry *res;
301 : :
302 : 0 : res = d_instantiate_unique(entry, inode);
303 [ # # ]: 0 : d_rehash(res != NULL ? res : entry);
304 : : return res;
305 : : }
306 : :
307 : : extern void dentry_update_name_case(struct dentry *, struct qstr *);
308 : :
309 : : /* used for rename() and baskets */
310 : : extern void d_move(struct dentry *, struct dentry *);
311 : : extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
312 : :
313 : : /* appendix may either be NULL or be used for transname suffixes */
314 : : extern struct dentry *d_lookup(const struct dentry *, const struct qstr *);
315 : : extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
316 : : extern struct dentry *__d_lookup(const struct dentry *, const struct qstr *);
317 : : extern struct dentry *__d_lookup_rcu(const struct dentry *parent,
318 : : const struct qstr *name, unsigned *seq);
319 : :
320 : : static inline unsigned d_count(const struct dentry *dentry)
321 : : {
322 : : return dentry->d_lockref.count;
323 : : }
324 : :
325 : : /* validate "insecure" dentry pointer */
326 : : extern int d_validate(struct dentry *, struct dentry *);
327 : :
328 : : /*
329 : : * helper function for dentry_operations.d_dname() members
330 : : */
331 : : extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
332 : : extern char *simple_dname(struct dentry *, char *, int);
333 : :
334 : : extern char *__d_path(const struct path *, const struct path *, char *, int);
335 : : extern char *d_absolute_path(const struct path *, char *, int);
336 : : extern char *d_path(const struct path *, char *, int);
337 : : extern char *dentry_path_raw(struct dentry *, char *, int);
338 : : extern char *dentry_path(struct dentry *, char *, int);
339 : :
340 : : /* Allocation counts.. */
341 : :
342 : : /**
343 : : * dget, dget_dlock - get a reference to a dentry
344 : : * @dentry: dentry to get a reference to
345 : : *
346 : : * Given a dentry or %NULL pointer increment the reference count
347 : : * if appropriate and return the dentry. A dentry will not be
348 : : * destroyed when it has references.
349 : : */
350 : : static inline struct dentry *dget_dlock(struct dentry *dentry)
351 : : {
352 [ # # ][ # # ]: 0 : if (dentry)
[ # # ]
353 : 0 : dentry->d_lockref.count++;
354 : : return dentry;
355 : : }
356 : :
357 : : static inline struct dentry *dget(struct dentry *dentry)
358 : : {
359 [ + - ][ + - ]: 5823064 : if (dentry)
[ + + # # ]
[ + - ][ # # ]
[ # # ][ # # ]
[ + - ][ + -
+ - + - ]
[ # # # #
# # ][ + -
# # # #
+ ][ # # +
- + - ]
[ + - ][ + - ]
360 : 5823091 : lockref_get(&dentry->d_lockref);
361 : : return dentry;
362 : : }
363 : :
364 : : extern struct dentry *dget_parent(struct dentry *dentry);
365 : :
366 : : /**
367 : : * d_unhashed - is dentry hashed
368 : : * @dentry: entry to check
369 : : *
370 : : * Returns true if the dentry passed is not currently hashed.
371 : : */
372 : :
373 : : static inline int d_unhashed(const struct dentry *dentry)
374 : : {
375 : 20662104 : return hlist_bl_unhashed(&dentry->d_hash);
376 : : }
377 : :
378 : : static inline int d_unlinked(const struct dentry *dentry)
379 : : {
380 [ - + ][ # # ]: 56500 : return d_unhashed(dentry) && !IS_ROOT(dentry);
[ + + ][ + - ]
[ + - ][ + - ]
[ + + ][ + - ]
[ + + ][ + - ]
[ - + ][ # # ]
381 : : }
382 : :
383 : : static inline int cant_mount(const struct dentry *dentry)
384 : : {
385 : 86 : return (dentry->d_flags & DCACHE_CANT_MOUNT);
386 : : }
387 : :
388 : : static inline void dont_mount(struct dentry *dentry)
389 : : {
390 : : spin_lock(&dentry->d_lock);
391 : 276920 : dentry->d_flags |= DCACHE_CANT_MOUNT;
392 : : spin_unlock(&dentry->d_lock);
393 : : }
394 : :
395 : : extern void dput(struct dentry *);
396 : :
397 : : static inline bool d_managed(const struct dentry *dentry)
398 : : {
399 : : return dentry->d_flags & DCACHE_MANAGED_DENTRY;
400 : : }
401 : :
402 : : static inline bool d_mountpoint(const struct dentry *dentry)
403 : : {
404 : 9255735 : return dentry->d_flags & DCACHE_MOUNTED;
405 : : }
406 : :
407 : : /*
408 : : * Directory cache entry type accessor functions.
409 : : */
410 : : static inline void __d_set_type(struct dentry *dentry, unsigned type)
411 : : {
412 : 123009 : dentry->d_flags = (dentry->d_flags & ~DCACHE_ENTRY_TYPE) | type;
413 : : }
414 : :
415 : : static inline void __d_clear_type(struct dentry *dentry)
416 : : {
417 : : __d_set_type(dentry, DCACHE_MISS_TYPE);
418 : : }
419 : :
420 : : static inline void d_set_type(struct dentry *dentry, unsigned type)
421 : : {
422 : : spin_lock(&dentry->d_lock);
423 : : __d_set_type(dentry, type);
424 : : spin_unlock(&dentry->d_lock);
425 : : }
426 : :
427 : : static inline unsigned __d_entry_type(const struct dentry *dentry)
428 : : {
429 : 24878348 : return dentry->d_flags & DCACHE_ENTRY_TYPE;
430 : : }
431 : :
432 : 10795661 : static inline bool d_is_directory(const struct dentry *dentry)
433 : : {
434 : : return __d_entry_type(dentry) == DCACHE_DIRECTORY_TYPE;
435 : : }
436 : :
437 : : static inline bool d_is_autodir(const struct dentry *dentry)
438 : : {
439 : : return __d_entry_type(dentry) == DCACHE_AUTODIR_TYPE;
440 : : }
441 : :
442 : 7339546 : static inline bool d_is_symlink(const struct dentry *dentry)
443 : : {
444 : 9736341 : return __d_entry_type(dentry) == DCACHE_SYMLINK_TYPE;
445 : : }
446 : :
447 : : static inline bool d_is_file(const struct dentry *dentry)
448 : : {
449 : : return __d_entry_type(dentry) == DCACHE_FILE_TYPE;
450 : : }
451 : :
452 : 6743141 : static inline bool d_is_negative(const struct dentry *dentry)
453 : : {
454 : : return __d_entry_type(dentry) == DCACHE_MISS_TYPE;
455 : : }
456 : :
457 : : static inline bool d_is_positive(const struct dentry *dentry)
458 : : {
459 : : return !d_is_negative(dentry);
460 : : }
461 : :
462 : : extern int sysctl_vfs_cache_pressure;
463 : :
464 : : static inline unsigned long vfs_pressure_ratio(unsigned long val)
465 : : {
466 : 2851932 : return mult_frac(val, sysctl_vfs_cache_pressure, 100);
467 : : }
468 : : #endif /* __LINUX_DCACHE_H */
|
