Loading...
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef __LINUX_DCACHE_H
3#define __LINUX_DCACHE_H
4
5#include <linux/atomic.h>
6#include <linux/list.h>
7#include <linux/rculist.h>
8#include <linux/rculist_bl.h>
9#include <linux/spinlock.h>
10#include <linux/seqlock.h>
11#include <linux/cache.h>
12#include <linux/rcupdate.h>
13#include <linux/lockref.h>
14#include <linux/stringhash.h>
15#include <linux/wait.h>
16
17struct path;
18struct vfsmount;
19
20/*
21 * linux/include/linux/dcache.h
22 *
23 * Dirent cache data structures
24 *
25 * (C) Copyright 1997 Thomas Schoebel-Theuer,
26 * with heavy changes by Linus Torvalds
27 */
28
29#define IS_ROOT(x) ((x) == (x)->d_parent)
30
31/* The hash is always the low bits of hash_len */
32#ifdef __LITTLE_ENDIAN
33 #define HASH_LEN_DECLARE u32 hash; u32 len
34 #define bytemask_from_count(cnt) (~(~0ul << (cnt)*8))
35#else
36 #define HASH_LEN_DECLARE u32 len; u32 hash
37 #define bytemask_from_count(cnt) (~(~0ul >> (cnt)*8))
38#endif
39
40/*
41 * "quick string" -- eases parameter passing, but more importantly
42 * saves "metadata" about the string (ie length and the hash).
43 *
44 * hash comes first so it snuggles against d_parent in the
45 * dentry.
46 */
47struct qstr {
48 union {
49 struct {
50 HASH_LEN_DECLARE;
51 };
52 u64 hash_len;
53 };
54 const unsigned char *name;
55};
56
57#define QSTR_INIT(n,l) { { { .len = l } }, .name = n }
58
59extern const struct qstr empty_name;
60extern const struct qstr slash_name;
61
62struct dentry_stat_t {
63 long nr_dentry;
64 long nr_unused;
65 long age_limit; /* age in seconds */
66 long want_pages; /* pages requested by system */
67 long nr_negative; /* # of unused negative dentries */
68 long dummy; /* Reserved for future use */
69};
70extern struct dentry_stat_t dentry_stat;
71
72/*
73 * Try to keep struct dentry aligned on 64 byte cachelines (this will
74 * give reasonable cacheline footprint with larger lines without the
75 * large memory footprint increase).
76 */
77#ifdef CONFIG_64BIT
78# define DNAME_INLINE_LEN 32 /* 192 bytes */
79#else
80# ifdef CONFIG_SMP
81# define DNAME_INLINE_LEN 36 /* 128 bytes */
82# else
83# define DNAME_INLINE_LEN 40 /* 128 bytes */
84# endif
85#endif
86
87#define d_lock d_lockref.lock
88
89struct dentry {
90 /* RCU lookup touched fields */
91 unsigned int d_flags; /* protected by d_lock */
92 seqcount_spinlock_t d_seq; /* per dentry seqlock */
93 struct hlist_bl_node d_hash; /* lookup hash list */
94 struct dentry *d_parent; /* parent directory */
95 struct qstr d_name;
96 struct inode *d_inode; /* Where the name belongs to - NULL is
97 * negative */
98 unsigned char d_iname[DNAME_INLINE_LEN]; /* small names */
99
100 /* Ref lookup also touches following */
101 struct lockref d_lockref; /* per-dentry lock and refcount */
102 const struct dentry_operations *d_op;
103 struct super_block *d_sb; /* The root of the dentry tree */
104 unsigned long d_time; /* used by d_revalidate */
105 void *d_fsdata; /* fs-specific data */
106
107 union {
108 struct list_head d_lru; /* LRU list */
109 wait_queue_head_t *d_wait; /* in-lookup ones only */
110 };
111 struct list_head d_child; /* child of parent list */
112 struct list_head d_subdirs; /* our children */
113 /*
114 * d_alias and d_rcu can share memory
115 */
116 union {
117 struct hlist_node d_alias; /* inode alias list */
118 struct hlist_bl_node d_in_lookup_hash; /* only for in-lookup ones */
119 struct rcu_head d_rcu;
120 } d_u;
121} __randomize_layout;
122
123/*
124 * dentry->d_lock spinlock nesting subclasses:
125 *
126 * 0: normal
127 * 1: nested
128 */
129enum dentry_d_lock_class
130{
131 DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */
132 DENTRY_D_LOCK_NESTED
133};
134
135struct dentry_operations {
136 int (*d_revalidate)(struct dentry *, unsigned int);
137 int (*d_weak_revalidate)(struct dentry *, unsigned int);
138 int (*d_hash)(const struct dentry *, struct qstr *);
139 int (*d_compare)(const struct dentry *,
140 unsigned int, const char *, const struct qstr *);
141 int (*d_delete)(const struct dentry *);
142 int (*d_init)(struct dentry *);
143 void (*d_release)(struct dentry *);
144 void (*d_prune)(struct dentry *);
145 void (*d_iput)(struct dentry *, struct inode *);
146 char *(*d_dname)(struct dentry *, char *, int);
147 struct vfsmount *(*d_automount)(struct path *);
148 int (*d_manage)(const struct path *, bool);
149 struct dentry *(*d_real)(struct dentry *, const struct inode *);
150} ____cacheline_aligned;
151
152/*
153 * Locking rules for dentry_operations callbacks are to be found in
154 * Documentation/filesystems/locking.rst. Keep it updated!
155 *
156 * FUrther descriptions are found in Documentation/filesystems/vfs.rst.
157 * Keep it updated too!
158 */
159
160/* d_flags entries */
161#define DCACHE_OP_HASH 0x00000001
162#define DCACHE_OP_COMPARE 0x00000002
163#define DCACHE_OP_REVALIDATE 0x00000004
164#define DCACHE_OP_DELETE 0x00000008
165#define DCACHE_OP_PRUNE 0x00000010
166
167#define DCACHE_DISCONNECTED 0x00000020
168 /* This dentry is possibly not currently connected to the dcache tree, in
169 * which case its parent will either be itself, or will have this flag as
170 * well. nfsd will not use a dentry with this bit set, but will first
171 * endeavour to clear the bit either by discovering that it is connected,
172 * or by performing lookup operations. Any filesystem which supports
173 * nfsd_operations MUST have a lookup function which, if it finds a
174 * directory inode with a DCACHE_DISCONNECTED dentry, will d_move that
175 * dentry into place and return that dentry rather than the passed one,
176 * typically using d_splice_alias. */
177
178#define DCACHE_REFERENCED 0x00000040 /* Recently used, don't discard. */
179
180#define DCACHE_DONTCACHE 0x00000080 /* Purge from memory on final dput() */
181
182#define DCACHE_CANT_MOUNT 0x00000100
183#define DCACHE_GENOCIDE 0x00000200
184#define DCACHE_SHRINK_LIST 0x00000400
185
186#define DCACHE_OP_WEAK_REVALIDATE 0x00000800
187
188#define DCACHE_NFSFS_RENAMED 0x00001000
189 /* this dentry has been "silly renamed" and has to be deleted on the last
190 * dput() */
191#define DCACHE_COOKIE 0x00002000 /* For use by dcookie subsystem */
192#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x00004000
193 /* Parent inode is watched by some fsnotify listener */
194
195#define DCACHE_DENTRY_KILLED 0x00008000
196
197#define DCACHE_MOUNTED 0x00010000 /* is a mountpoint */
198#define DCACHE_NEED_AUTOMOUNT 0x00020000 /* handle automount on this dir */
199#define DCACHE_MANAGE_TRANSIT 0x00040000 /* manage transit from this dirent */
200#define DCACHE_MANAGED_DENTRY \
201 (DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT)
202
203#define DCACHE_LRU_LIST 0x00080000
204
205#define DCACHE_ENTRY_TYPE 0x00700000
206#define DCACHE_MISS_TYPE 0x00000000 /* Negative dentry (maybe fallthru to nowhere) */
207#define DCACHE_WHITEOUT_TYPE 0x00100000 /* Whiteout dentry (stop pathwalk) */
208#define DCACHE_DIRECTORY_TYPE 0x00200000 /* Normal directory */
209#define DCACHE_AUTODIR_TYPE 0x00300000 /* Lookupless directory (presumed automount) */
210#define DCACHE_REGULAR_TYPE 0x00400000 /* Regular file type (or fallthru to such) */
211#define DCACHE_SPECIAL_TYPE 0x00500000 /* Other file type (or fallthru to such) */
212#define DCACHE_SYMLINK_TYPE 0x00600000 /* Symlink (or fallthru to such) */
213
214#define DCACHE_MAY_FREE 0x00800000
215#define DCACHE_FALLTHRU 0x01000000 /* Fall through to lower layer */
216#define DCACHE_ENCRYPTED_NAME 0x02000000 /* Encrypted name (dir key was unavailable) */
217#define DCACHE_OP_REAL 0x04000000
218
219#define DCACHE_PAR_LOOKUP 0x10000000 /* being looked up (with parent locked shared) */
220#define DCACHE_DENTRY_CURSOR 0x20000000
221#define DCACHE_NORCU 0x40000000 /* No RCU delay for freeing */
222
223extern seqlock_t rename_lock;
224
225/*
226 * These are the low-level FS interfaces to the dcache..
227 */
228extern void d_instantiate(struct dentry *, struct inode *);
229extern void d_instantiate_new(struct dentry *, struct inode *);
230extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
231extern struct dentry * d_instantiate_anon(struct dentry *, struct inode *);
232extern void __d_drop(struct dentry *dentry);
233extern void d_drop(struct dentry *dentry);
234extern void d_delete(struct dentry *);
235extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
236
237/* allocate/de-allocate */
238extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
239extern struct dentry * d_alloc_anon(struct super_block *);
240extern struct dentry * d_alloc_parallel(struct dentry *, const struct qstr *,
241 wait_queue_head_t *);
242extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
243extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
244extern struct dentry * d_exact_alias(struct dentry *, struct inode *);
245extern struct dentry *d_find_any_alias(struct inode *inode);
246extern struct dentry * d_obtain_alias(struct inode *);
247extern struct dentry * d_obtain_root(struct inode *);
248extern void shrink_dcache_sb(struct super_block *);
249extern void shrink_dcache_parent(struct dentry *);
250extern void shrink_dcache_for_umount(struct super_block *);
251extern void d_invalidate(struct dentry *);
252
253/* only used at mount-time */
254extern struct dentry * d_make_root(struct inode *);
255
256/* <clickety>-<click> the ramfs-type tree */
257extern void d_genocide(struct dentry *);
258
259extern void d_tmpfile(struct dentry *, struct inode *);
260
261extern struct dentry *d_find_alias(struct inode *);
262extern void d_prune_aliases(struct inode *);
263
264/* test whether we have any submounts in a subdir tree */
265extern int path_has_submounts(const struct path *);
266
267/*
268 * This adds the entry to the hash queues.
269 */
270extern void d_rehash(struct dentry *);
271
272extern void d_add(struct dentry *, struct inode *);
273
274/* used for rename() and baskets */
275extern void d_move(struct dentry *, struct dentry *);
276extern void d_exchange(struct dentry *, struct dentry *);
277extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
278
279/* appendix may either be NULL or be used for transname suffixes */
280extern struct dentry *d_lookup(const struct dentry *, const struct qstr *);
281extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
282extern struct dentry *__d_lookup(const struct dentry *, const struct qstr *);
283extern struct dentry *__d_lookup_rcu(const struct dentry *parent,
284 const struct qstr *name, unsigned *seq);
285
286static inline unsigned d_count(const struct dentry *dentry)
287{
288 return dentry->d_lockref.count;
289}
290
291/*
292 * helper function for dentry_operations.d_dname() members
293 */
294extern __printf(4, 5)
295char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
296
297extern char *__d_path(const struct path *, const struct path *, char *, int);
298extern char *d_absolute_path(const struct path *, char *, int);
299extern char *d_path(const struct path *, char *, int);
300extern char *dentry_path_raw(struct dentry *, char *, int);
301extern char *dentry_path(struct dentry *, char *, int);
302
303/* Allocation counts.. */
304
305/**
306 * dget, dget_dlock - get a reference to a dentry
307 * @dentry: dentry to get a reference to
308 *
309 * Given a dentry or %NULL pointer increment the reference count
310 * if appropriate and return the dentry. A dentry will not be
311 * destroyed when it has references.
312 */
313static inline struct dentry *dget_dlock(struct dentry *dentry)
314{
315 if (dentry)
316 dentry->d_lockref.count++;
317 return dentry;
318}
319
320static inline struct dentry *dget(struct dentry *dentry)
321{
322 if (dentry)
323 lockref_get(&dentry->d_lockref);
324 return dentry;
325}
326
327extern struct dentry *dget_parent(struct dentry *dentry);
328
329/**
330 * d_unhashed - is dentry hashed
331 * @dentry: entry to check
332 *
333 * Returns true if the dentry passed is not currently hashed.
334 */
335
336static inline int d_unhashed(const struct dentry *dentry)
337{
338 return hlist_bl_unhashed(&dentry->d_hash);
339}
340
341static inline int d_unlinked(const struct dentry *dentry)
342{
343 return d_unhashed(dentry) && !IS_ROOT(dentry);
344}
345
346static inline int cant_mount(const struct dentry *dentry)
347{
348 return (dentry->d_flags & DCACHE_CANT_MOUNT);
349}
350
351static inline void dont_mount(struct dentry *dentry)
352{
353 spin_lock(&dentry->d_lock);
354 dentry->d_flags |= DCACHE_CANT_MOUNT;
355 spin_unlock(&dentry->d_lock);
356}
357
358extern void __d_lookup_done(struct dentry *);
359
360static inline int d_in_lookup(const struct dentry *dentry)
361{
362 return dentry->d_flags & DCACHE_PAR_LOOKUP;
363}
364
365static inline void d_lookup_done(struct dentry *dentry)
366{
367 if (unlikely(d_in_lookup(dentry))) {
368 spin_lock(&dentry->d_lock);
369 __d_lookup_done(dentry);
370 spin_unlock(&dentry->d_lock);
371 }
372}
373
374extern void dput(struct dentry *);
375
376static inline bool d_managed(const struct dentry *dentry)
377{
378 return dentry->d_flags & DCACHE_MANAGED_DENTRY;
379}
380
381static inline bool d_mountpoint(const struct dentry *dentry)
382{
383 return dentry->d_flags & DCACHE_MOUNTED;
384}
385
386/*
387 * Directory cache entry type accessor functions.
388 */
389static inline unsigned __d_entry_type(const struct dentry *dentry)
390{
391 return dentry->d_flags & DCACHE_ENTRY_TYPE;
392}
393
394static inline bool d_is_miss(const struct dentry *dentry)
395{
396 return __d_entry_type(dentry) == DCACHE_MISS_TYPE;
397}
398
399static inline bool d_is_whiteout(const struct dentry *dentry)
400{
401 return __d_entry_type(dentry) == DCACHE_WHITEOUT_TYPE;
402}
403
404static inline bool d_can_lookup(const struct dentry *dentry)
405{
406 return __d_entry_type(dentry) == DCACHE_DIRECTORY_TYPE;
407}
408
409static inline bool d_is_autodir(const struct dentry *dentry)
410{
411 return __d_entry_type(dentry) == DCACHE_AUTODIR_TYPE;
412}
413
414static inline bool d_is_dir(const struct dentry *dentry)
415{
416 return d_can_lookup(dentry) || d_is_autodir(dentry);
417}
418
419static inline bool d_is_symlink(const struct dentry *dentry)
420{
421 return __d_entry_type(dentry) == DCACHE_SYMLINK_TYPE;
422}
423
424static inline bool d_is_reg(const struct dentry *dentry)
425{
426 return __d_entry_type(dentry) == DCACHE_REGULAR_TYPE;
427}
428
429static inline bool d_is_special(const struct dentry *dentry)
430{
431 return __d_entry_type(dentry) == DCACHE_SPECIAL_TYPE;
432}
433
434static inline bool d_is_file(const struct dentry *dentry)
435{
436 return d_is_reg(dentry) || d_is_special(dentry);
437}
438
439static inline bool d_is_negative(const struct dentry *dentry)
440{
441 // TODO: check d_is_whiteout(dentry) also.
442 return d_is_miss(dentry);
443}
444
445static inline bool d_flags_negative(unsigned flags)
446{
447 return (flags & DCACHE_ENTRY_TYPE) == DCACHE_MISS_TYPE;
448}
449
450static inline bool d_is_positive(const struct dentry *dentry)
451{
452 return !d_is_negative(dentry);
453}
454
455/**
456 * d_really_is_negative - Determine if a dentry is really negative (ignoring fallthroughs)
457 * @dentry: The dentry in question
458 *
459 * Returns true if the dentry represents either an absent name or a name that
460 * doesn't map to an inode (ie. ->d_inode is NULL). The dentry could represent
461 * a true miss, a whiteout that isn't represented by a 0,0 chardev or a
462 * fallthrough marker in an opaque directory.
463 *
464 * Note! (1) This should be used *only* by a filesystem to examine its own
465 * dentries. It should not be used to look at some other filesystem's
466 * dentries. (2) It should also be used in combination with d_inode() to get
467 * the inode. (3) The dentry may have something attached to ->d_lower and the
468 * type field of the flags may be set to something other than miss or whiteout.
469 */
470static inline bool d_really_is_negative(const struct dentry *dentry)
471{
472 return dentry->d_inode == NULL;
473}
474
475/**
476 * d_really_is_positive - Determine if a dentry is really positive (ignoring fallthroughs)
477 * @dentry: The dentry in question
478 *
479 * Returns true if the dentry represents a name that maps to an inode
480 * (ie. ->d_inode is not NULL). The dentry might still represent a whiteout if
481 * that is represented on medium as a 0,0 chardev.
482 *
483 * Note! (1) This should be used *only* by a filesystem to examine its own
484 * dentries. It should not be used to look at some other filesystem's
485 * dentries. (2) It should also be used in combination with d_inode() to get
486 * the inode.
487 */
488static inline bool d_really_is_positive(const struct dentry *dentry)
489{
490 return dentry->d_inode != NULL;
491}
492
493static inline int simple_positive(const struct dentry *dentry)
494{
495 return d_really_is_positive(dentry) && !d_unhashed(dentry);
496}
497
498extern void d_set_fallthru(struct dentry *dentry);
499
500static inline bool d_is_fallthru(const struct dentry *dentry)
501{
502 return dentry->d_flags & DCACHE_FALLTHRU;
503}
504
505
506extern int sysctl_vfs_cache_pressure;
507
508static inline unsigned long vfs_pressure_ratio(unsigned long val)
509{
510 return mult_frac(val, sysctl_vfs_cache_pressure, 100);
511}
512
513/**
514 * d_inode - Get the actual inode of this dentry
515 * @dentry: The dentry to query
516 *
517 * This is the helper normal filesystems should use to get at their own inodes
518 * in their own dentries and ignore the layering superimposed upon them.
519 */
520static inline struct inode *d_inode(const struct dentry *dentry)
521{
522 return dentry->d_inode;
523}
524
525/**
526 * d_inode_rcu - Get the actual inode of this dentry with READ_ONCE()
527 * @dentry: The dentry to query
528 *
529 * This is the helper normal filesystems should use to get at their own inodes
530 * in their own dentries and ignore the layering superimposed upon them.
531 */
532static inline struct inode *d_inode_rcu(const struct dentry *dentry)
533{
534 return READ_ONCE(dentry->d_inode);
535}
536
537/**
538 * d_backing_inode - Get upper or lower inode we should be using
539 * @upper: The upper layer
540 *
541 * This is the helper that should be used to get at the inode that will be used
542 * if this dentry were to be opened as a file. The inode may be on the upper
543 * dentry or it may be on a lower dentry pinned by the upper.
544 *
545 * Normal filesystems should not use this to access their own inodes.
546 */
547static inline struct inode *d_backing_inode(const struct dentry *upper)
548{
549 struct inode *inode = upper->d_inode;
550
551 return inode;
552}
553
554/**
555 * d_backing_dentry - Get upper or lower dentry we should be using
556 * @upper: The upper layer
557 *
558 * This is the helper that should be used to get the dentry of the inode that
559 * will be used if this dentry were opened as a file. It may be the upper
560 * dentry or it may be a lower dentry pinned by the upper.
561 *
562 * Normal filesystems should not use this to access their own dentries.
563 */
564static inline struct dentry *d_backing_dentry(struct dentry *upper)
565{
566 return upper;
567}
568
569/**
570 * d_real - Return the real dentry
571 * @dentry: the dentry to query
572 * @inode: inode to select the dentry from multiple layers (can be NULL)
573 *
574 * If dentry is on a union/overlay, then return the underlying, real dentry.
575 * Otherwise return the dentry itself.
576 *
577 * See also: Documentation/filesystems/vfs.rst
578 */
579static inline struct dentry *d_real(struct dentry *dentry,
580 const struct inode *inode)
581{
582 if (unlikely(dentry->d_flags & DCACHE_OP_REAL))
583 return dentry->d_op->d_real(dentry, inode);
584 else
585 return dentry;
586}
587
588/**
589 * d_real_inode - Return the real inode
590 * @dentry: The dentry to query
591 *
592 * If dentry is on a union/overlay, then return the underlying, real inode.
593 * Otherwise return d_inode().
594 */
595static inline struct inode *d_real_inode(const struct dentry *dentry)
596{
597 /* This usage of d_real() results in const dentry */
598 return d_backing_inode(d_real((struct dentry *) dentry, NULL));
599}
600
601struct name_snapshot {
602 struct qstr name;
603 unsigned char inline_name[DNAME_INLINE_LEN];
604};
605void take_dentry_name_snapshot(struct name_snapshot *, struct dentry *);
606void release_dentry_name_snapshot(struct name_snapshot *);
607
608#endif /* __LINUX_DCACHE_H */
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
13struct nameidata;
14struct path;
15struct vfsmount;
16
17/*
18 * linux/include/linux/dcache.h
19 *
20 * Dirent cache data structures
21 *
22 * (C) Copyright 1997 Thomas Schoebel-Theuer,
23 * with heavy changes by Linus Torvalds
24 */
25
26#define IS_ROOT(x) ((x) == (x)->d_parent)
27
28/*
29 * "quick string" -- eases parameter passing, but more importantly
30 * saves "metadata" about the string (ie length and the hash).
31 *
32 * hash comes first so it snuggles against d_parent in the
33 * dentry.
34 */
35struct qstr {
36 unsigned int hash;
37 unsigned int len;
38 const unsigned char *name;
39};
40
41struct dentry_stat_t {
42 int nr_dentry;
43 int nr_unused;
44 int age_limit; /* age in seconds */
45 int want_pages; /* pages requested by system */
46 int dummy[2];
47};
48extern struct dentry_stat_t dentry_stat;
49
50/*
51 * Compare 2 name strings, return 0 if they match, otherwise non-zero.
52 * The strings are both count bytes long, and count is non-zero.
53 */
54static inline int dentry_cmp(const unsigned char *cs, size_t scount,
55 const unsigned char *ct, size_t tcount)
56{
57 int ret;
58 if (scount != tcount)
59 return 1;
60 do {
61 ret = (*cs != *ct);
62 if (ret)
63 break;
64 cs++;
65 ct++;
66 tcount--;
67 } while (tcount);
68 return ret;
69}
70
71/* Name hashing routines. Initial hash value */
72/* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
73#define init_name_hash() 0
74
75/* partial hash update function. Assume roughly 4 bits per character */
76static inline unsigned long
77partial_name_hash(unsigned long c, unsigned long prevhash)
78{
79 return (prevhash + (c << 4) + (c >> 4)) * 11;
80}
81
82/*
83 * Finally: cut down the number of bits to a int value (and try to avoid
84 * losing bits)
85 */
86static inline unsigned long end_name_hash(unsigned long hash)
87{
88 return (unsigned int) hash;
89}
90
91/* Compute the hash for a name string. */
92static inline unsigned int
93full_name_hash(const unsigned char *name, unsigned int len)
94{
95 unsigned long hash = init_name_hash();
96 while (len--)
97 hash = partial_name_hash(*name++, hash);
98 return end_name_hash(hash);
99}
100
101/*
102 * Try to keep struct dentry aligned on 64 byte cachelines (this will
103 * give reasonable cacheline footprint with larger lines without the
104 * large memory footprint increase).
105 */
106#ifdef CONFIG_64BIT
107# define DNAME_INLINE_LEN 32 /* 192 bytes */
108#else
109# ifdef CONFIG_SMP
110# define DNAME_INLINE_LEN 36 /* 128 bytes */
111# else
112# define DNAME_INLINE_LEN 40 /* 128 bytes */
113# endif
114#endif
115
116struct dentry {
117 /* RCU lookup touched fields */
118 unsigned int d_flags; /* protected by d_lock */
119 seqcount_t d_seq; /* per dentry seqlock */
120 struct hlist_bl_node d_hash; /* lookup hash list */
121 struct dentry *d_parent; /* parent directory */
122 struct qstr d_name;
123 struct inode *d_inode; /* Where the name belongs to - NULL is
124 * negative */
125 unsigned char d_iname[DNAME_INLINE_LEN]; /* small names */
126
127 /* Ref lookup also touches following */
128 unsigned int d_count; /* protected by d_lock */
129 spinlock_t d_lock; /* per dentry lock */
130 const struct dentry_operations *d_op;
131 struct super_block *d_sb; /* The root of the dentry tree */
132 unsigned long d_time; /* used by d_revalidate */
133 void *d_fsdata; /* fs-specific data */
134
135 struct list_head d_lru; /* LRU list */
136 /*
137 * d_child and d_rcu can share memory
138 */
139 union {
140 struct list_head d_child; /* child of parent list */
141 struct rcu_head d_rcu;
142 } d_u;
143 struct list_head d_subdirs; /* our children */
144 struct list_head d_alias; /* inode alias list */
145};
146
147/*
148 * dentry->d_lock spinlock nesting subclasses:
149 *
150 * 0: normal
151 * 1: nested
152 */
153enum dentry_d_lock_class
154{
155 DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */
156 DENTRY_D_LOCK_NESTED
157};
158
159struct dentry_operations {
160 int (*d_revalidate)(struct dentry *, struct nameidata *);
161 int (*d_hash)(const struct dentry *, const struct inode *,
162 struct qstr *);
163 int (*d_compare)(const struct dentry *, const struct inode *,
164 const struct dentry *, const struct inode *,
165 unsigned int, const char *, const struct qstr *);
166 int (*d_delete)(const struct dentry *);
167 void (*d_release)(struct dentry *);
168 void (*d_iput)(struct dentry *, struct inode *);
169 char *(*d_dname)(struct dentry *, char *, int);
170 struct vfsmount *(*d_automount)(struct path *);
171 int (*d_manage)(struct dentry *, bool);
172} ____cacheline_aligned;
173
174/*
175 * Locking rules for dentry_operations callbacks are to be found in
176 * Documentation/filesystems/Locking. Keep it updated!
177 *
178 * FUrther descriptions are found in Documentation/filesystems/vfs.txt.
179 * Keep it updated too!
180 */
181
182/* d_flags entries */
183#define DCACHE_OP_HASH 0x0001
184#define DCACHE_OP_COMPARE 0x0002
185#define DCACHE_OP_REVALIDATE 0x0004
186#define DCACHE_OP_DELETE 0x0008
187
188#define DCACHE_DISCONNECTED 0x0010
189 /* This dentry is possibly not currently connected to the dcache tree, in
190 * which case its parent will either be itself, or will have this flag as
191 * well. nfsd will not use a dentry with this bit set, but will first
192 * endeavour to clear the bit either by discovering that it is connected,
193 * or by performing lookup operations. Any filesystem which supports
194 * nfsd_operations MUST have a lookup function which, if it finds a
195 * directory inode with a DCACHE_DISCONNECTED dentry, will d_move that
196 * dentry into place and return that dentry rather than the passed one,
197 * typically using d_splice_alias. */
198
199#define DCACHE_REFERENCED 0x0020 /* Recently used, don't discard. */
200#define DCACHE_RCUACCESS 0x0040 /* Entry has ever been RCU-visible */
201
202#define DCACHE_CANT_MOUNT 0x0100
203#define DCACHE_GENOCIDE 0x0200
204
205#define DCACHE_NFSFS_RENAMED 0x1000
206 /* this dentry has been "silly renamed" and has to be deleted on the last
207 * dput() */
208#define DCACHE_COOKIE 0x2000 /* For use by dcookie subsystem */
209#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x4000
210 /* Parent inode is watched by some fsnotify listener */
211
212#define DCACHE_MOUNTED 0x10000 /* is a mountpoint */
213#define DCACHE_NEED_AUTOMOUNT 0x20000 /* handle automount on this dir */
214#define DCACHE_MANAGE_TRANSIT 0x40000 /* manage transit from this dirent */
215#define DCACHE_NEED_LOOKUP 0x80000 /* dentry requires i_op->lookup */
216#define DCACHE_MANAGED_DENTRY \
217 (DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT)
218
219extern seqlock_t rename_lock;
220
221static inline int dname_external(struct dentry *dentry)
222{
223 return dentry->d_name.name != dentry->d_iname;
224}
225
226/*
227 * These are the low-level FS interfaces to the dcache..
228 */
229extern void d_instantiate(struct dentry *, struct inode *);
230extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
231extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
232extern void __d_drop(struct dentry *dentry);
233extern void d_drop(struct dentry *dentry);
234extern void d_delete(struct dentry *);
235extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
236
237/* allocate/de-allocate */
238extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
239extern struct dentry * d_alloc_pseudo(struct super_block *, const struct qstr *);
240extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
241extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
242extern struct dentry * d_obtain_alias(struct inode *);
243extern void shrink_dcache_sb(struct super_block *);
244extern void shrink_dcache_parent(struct dentry *);
245extern void shrink_dcache_for_umount(struct super_block *);
246extern int d_invalidate(struct dentry *);
247
248/* only used at mount-time */
249extern struct dentry * d_alloc_root(struct inode *);
250
251/* <clickety>-<click> the ramfs-type tree */
252extern void d_genocide(struct dentry *);
253
254extern struct dentry *d_find_alias(struct inode *);
255extern void d_prune_aliases(struct inode *);
256
257/* test whether we have any submounts in a subdir tree */
258extern int have_submounts(struct dentry *);
259
260/*
261 * This adds the entry to the hash queues.
262 */
263extern 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
274static 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 */
288static 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
297extern void dentry_update_name_case(struct dentry *, struct qstr *);
298
299/* used for rename() and baskets */
300extern void d_move(struct dentry *, struct dentry *);
301extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
302
303/* appendix may either be NULL or be used for transname suffixes */
304extern struct dentry *d_lookup(struct dentry *, struct qstr *);
305extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
306extern struct dentry *__d_lookup(struct dentry *, struct qstr *);
307extern struct dentry *__d_lookup_rcu(struct dentry *parent, struct qstr *name,
308 unsigned *seq, struct inode **inode);
309
310/**
311 * __d_rcu_to_refcount - take a refcount on dentry if sequence check is ok
312 * @dentry: dentry to take a ref on
313 * @seq: seqcount to verify against
314 * Returns: 0 on failure, else 1.
315 *
316 * __d_rcu_to_refcount operates on a dentry,seq pair that was returned
317 * by __d_lookup_rcu, to get a reference on an rcu-walk dentry.
318 */
319static inline int __d_rcu_to_refcount(struct dentry *dentry, unsigned seq)
320{
321 int ret = 0;
322
323 assert_spin_locked(&dentry->d_lock);
324 if (!read_seqcount_retry(&dentry->d_seq, seq)) {
325 ret = 1;
326 dentry->d_count++;
327 }
328
329 return ret;
330}
331
332/* validate "insecure" dentry pointer */
333extern int d_validate(struct dentry *, struct dentry *);
334
335/*
336 * helper function for dentry_operations.d_dname() members
337 */
338extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
339
340extern char *__d_path(const struct path *path, struct path *root, char *, int);
341extern char *d_path(const struct path *, char *, int);
342extern char *d_path_with_unreachable(const struct path *, char *, int);
343extern char *dentry_path_raw(struct dentry *, char *, int);
344extern char *dentry_path(struct dentry *, char *, int);
345
346/* Allocation counts.. */
347
348/**
349 * dget, dget_dlock - get a reference to a dentry
350 * @dentry: dentry to get a reference to
351 *
352 * Given a dentry or %NULL pointer increment the reference count
353 * if appropriate and return the dentry. A dentry will not be
354 * destroyed when it has references.
355 */
356static inline struct dentry *dget_dlock(struct dentry *dentry)
357{
358 if (dentry)
359 dentry->d_count++;
360 return dentry;
361}
362
363static inline struct dentry *dget(struct dentry *dentry)
364{
365 if (dentry) {
366 spin_lock(&dentry->d_lock);
367 dget_dlock(dentry);
368 spin_unlock(&dentry->d_lock);
369 }
370 return dentry;
371}
372
373extern struct dentry *dget_parent(struct dentry *dentry);
374
375/**
376 * d_unhashed - is dentry hashed
377 * @dentry: entry to check
378 *
379 * Returns true if the dentry passed is not currently hashed.
380 */
381
382static inline int d_unhashed(struct dentry *dentry)
383{
384 return hlist_bl_unhashed(&dentry->d_hash);
385}
386
387static inline int d_unlinked(struct dentry *dentry)
388{
389 return d_unhashed(dentry) && !IS_ROOT(dentry);
390}
391
392static inline int cant_mount(struct dentry *dentry)
393{
394 return (dentry->d_flags & DCACHE_CANT_MOUNT);
395}
396
397static inline void dont_mount(struct dentry *dentry)
398{
399 spin_lock(&dentry->d_lock);
400 dentry->d_flags |= DCACHE_CANT_MOUNT;
401 spin_unlock(&dentry->d_lock);
402}
403
404extern void dput(struct dentry *);
405
406static inline bool d_managed(struct dentry *dentry)
407{
408 return dentry->d_flags & DCACHE_MANAGED_DENTRY;
409}
410
411static inline bool d_mountpoint(struct dentry *dentry)
412{
413 return dentry->d_flags & DCACHE_MOUNTED;
414}
415
416static inline bool d_need_lookup(struct dentry *dentry)
417{
418 return dentry->d_flags & DCACHE_NEED_LOOKUP;
419}
420
421extern void d_clear_need_lookup(struct dentry *dentry);
422
423extern int sysctl_vfs_cache_pressure;
424
425#endif /* __LINUX_DCACHE_H */