Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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/* Name hashing routines. Initial hash value */
51/* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
52#define init_name_hash() 0
53
54/* partial hash update function. Assume roughly 4 bits per character */
55static inline unsigned long
56partial_name_hash(unsigned long c, unsigned long prevhash)
57{
58 return (prevhash + (c << 4) + (c >> 4)) * 11;
59}
60
61/*
62 * Finally: cut down the number of bits to a int value (and try to avoid
63 * losing bits)
64 */
65static inline unsigned long end_name_hash(unsigned long hash)
66{
67 return (unsigned int) hash;
68}
69
70/* Compute the hash for a name string. */
71extern unsigned int full_name_hash(const unsigned char *, unsigned int);
72
73/*
74 * Try to keep struct dentry aligned on 64 byte cachelines (this will
75 * give reasonable cacheline footprint with larger lines without the
76 * large memory footprint increase).
77 */
78#ifdef CONFIG_64BIT
79# define DNAME_INLINE_LEN 32 /* 192 bytes */
80#else
81# ifdef CONFIG_SMP
82# define DNAME_INLINE_LEN 36 /* 128 bytes */
83# else
84# define DNAME_INLINE_LEN 40 /* 128 bytes */
85# endif
86#endif
87
88struct dentry {
89 /* RCU lookup touched fields */
90 unsigned int d_flags; /* protected by d_lock */
91 seqcount_t d_seq; /* per dentry seqlock */
92 struct hlist_bl_node d_hash; /* lookup hash list */
93 struct dentry *d_parent; /* parent directory */
94 struct qstr d_name;
95 struct inode *d_inode; /* Where the name belongs to - NULL is
96 * negative */
97 unsigned char d_iname[DNAME_INLINE_LEN]; /* small names */
98
99 /* Ref lookup also touches following */
100 unsigned int d_count; /* protected by d_lock */
101 spinlock_t d_lock; /* per dentry lock */
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 struct list_head d_lru; /* LRU list */
108 /*
109 * d_child and d_rcu can share memory
110 */
111 union {
112 struct list_head d_child; /* child of parent list */
113 struct rcu_head d_rcu;
114 } d_u;
115 struct list_head d_subdirs; /* our children */
116 struct list_head d_alias; /* inode alias list */
117};
118
119/*
120 * dentry->d_lock spinlock nesting subclasses:
121 *
122 * 0: normal
123 * 1: nested
124 */
125enum dentry_d_lock_class
126{
127 DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */
128 DENTRY_D_LOCK_NESTED
129};
130
131struct dentry_operations {
132 int (*d_revalidate)(struct dentry *, struct nameidata *);
133 int (*d_hash)(const struct dentry *, const struct inode *,
134 struct qstr *);
135 int (*d_compare)(const struct dentry *, const struct inode *,
136 const struct dentry *, const struct inode *,
137 unsigned int, const char *, const struct qstr *);
138 int (*d_delete)(const struct dentry *);
139 void (*d_release)(struct dentry *);
140 void (*d_prune)(struct dentry *);
141 void (*d_iput)(struct dentry *, struct inode *);
142 char *(*d_dname)(struct dentry *, char *, int);
143 struct vfsmount *(*d_automount)(struct path *);
144 int (*d_manage)(struct dentry *, bool);
145} ____cacheline_aligned;
146
147/*
148 * Locking rules for dentry_operations callbacks are to be found in
149 * Documentation/filesystems/Locking. Keep it updated!
150 *
151 * FUrther descriptions are found in Documentation/filesystems/vfs.txt.
152 * Keep it updated too!
153 */
154
155/* d_flags entries */
156#define DCACHE_OP_HASH 0x0001
157#define DCACHE_OP_COMPARE 0x0002
158#define DCACHE_OP_REVALIDATE 0x0004
159#define DCACHE_OP_DELETE 0x0008
160#define DCACHE_OP_PRUNE 0x0010
161
162#define DCACHE_DISCONNECTED 0x0020
163 /* This dentry is possibly not currently connected to the dcache tree, in
164 * which case its parent will either be itself, or will have this flag as
165 * well. nfsd will not use a dentry with this bit set, but will first
166 * endeavour to clear the bit either by discovering that it is connected,
167 * or by performing lookup operations. Any filesystem which supports
168 * nfsd_operations MUST have a lookup function which, if it finds a
169 * directory inode with a DCACHE_DISCONNECTED dentry, will d_move that
170 * dentry into place and return that dentry rather than the passed one,
171 * typically using d_splice_alias. */
172
173#define DCACHE_REFERENCED 0x0040 /* Recently used, don't discard. */
174#define DCACHE_RCUACCESS 0x0080 /* Entry has ever been RCU-visible */
175
176#define DCACHE_CANT_MOUNT 0x0100
177#define DCACHE_GENOCIDE 0x0200
178#define DCACHE_SHRINK_LIST 0x0400
179
180#define DCACHE_NFSFS_RENAMED 0x1000
181 /* this dentry has been "silly renamed" and has to be deleted on the last
182 * dput() */
183#define DCACHE_COOKIE 0x2000 /* For use by dcookie subsystem */
184#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x4000
185 /* Parent inode is watched by some fsnotify listener */
186
187#define DCACHE_MOUNTED 0x10000 /* is a mountpoint */
188#define DCACHE_NEED_AUTOMOUNT 0x20000 /* handle automount on this dir */
189#define DCACHE_MANAGE_TRANSIT 0x40000 /* manage transit from this dirent */
190#define DCACHE_NEED_LOOKUP 0x80000 /* dentry requires i_op->lookup */
191#define DCACHE_MANAGED_DENTRY \
192 (DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT)
193
194extern seqlock_t rename_lock;
195
196static inline int dname_external(struct dentry *dentry)
197{
198 return dentry->d_name.name != dentry->d_iname;
199}
200
201/*
202 * These are the low-level FS interfaces to the dcache..
203 */
204extern void d_instantiate(struct dentry *, struct inode *);
205extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
206extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
207extern void __d_drop(struct dentry *dentry);
208extern void d_drop(struct dentry *dentry);
209extern void d_delete(struct dentry *);
210extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
211
212/* allocate/de-allocate */
213extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
214extern struct dentry * d_alloc_pseudo(struct super_block *, const struct qstr *);
215extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
216extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
217extern struct dentry *d_find_any_alias(struct inode *inode);
218extern struct dentry * d_obtain_alias(struct inode *);
219extern void shrink_dcache_sb(struct super_block *);
220extern void shrink_dcache_parent(struct dentry *);
221extern void shrink_dcache_for_umount(struct super_block *);
222extern int d_invalidate(struct dentry *);
223
224/* only used at mount-time */
225extern struct dentry * d_alloc_root(struct inode *);
226extern struct dentry * d_make_root(struct inode *);
227
228/* <clickety>-<click> the ramfs-type tree */
229extern void d_genocide(struct dentry *);
230
231extern struct dentry *d_find_alias(struct inode *);
232extern void d_prune_aliases(struct inode *);
233
234/* test whether we have any submounts in a subdir tree */
235extern int have_submounts(struct dentry *);
236
237/*
238 * This adds the entry to the hash queues.
239 */
240extern void d_rehash(struct dentry *);
241
242/**
243 * d_add - add dentry to hash queues
244 * @entry: dentry to add
245 * @inode: The inode to attach to this dentry
246 *
247 * This adds the entry to the hash queues and initializes @inode.
248 * The entry was actually filled in earlier during d_alloc().
249 */
250
251static inline void d_add(struct dentry *entry, struct inode *inode)
252{
253 d_instantiate(entry, inode);
254 d_rehash(entry);
255}
256
257/**
258 * d_add_unique - add dentry to hash queues without aliasing
259 * @entry: dentry to add
260 * @inode: The inode to attach to this dentry
261 *
262 * This adds the entry to the hash queues and initializes @inode.
263 * The entry was actually filled in earlier during d_alloc().
264 */
265static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
266{
267 struct dentry *res;
268
269 res = d_instantiate_unique(entry, inode);
270 d_rehash(res != NULL ? res : entry);
271 return res;
272}
273
274extern void dentry_update_name_case(struct dentry *, struct qstr *);
275
276/* used for rename() and baskets */
277extern void d_move(struct dentry *, struct dentry *);
278extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
279
280/* appendix may either be NULL or be used for transname suffixes */
281extern struct dentry *d_lookup(struct dentry *, struct qstr *);
282extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
283extern struct dentry *__d_lookup(struct dentry *, struct qstr *);
284extern struct dentry *__d_lookup_rcu(const struct dentry *parent,
285 const struct qstr *name,
286 unsigned *seq, struct inode **inode);
287
288/**
289 * __d_rcu_to_refcount - take a refcount on dentry if sequence check is ok
290 * @dentry: dentry to take a ref on
291 * @seq: seqcount to verify against
292 * Returns: 0 on failure, else 1.
293 *
294 * __d_rcu_to_refcount operates on a dentry,seq pair that was returned
295 * by __d_lookup_rcu, to get a reference on an rcu-walk dentry.
296 */
297static inline int __d_rcu_to_refcount(struct dentry *dentry, unsigned seq)
298{
299 int ret = 0;
300
301 assert_spin_locked(&dentry->d_lock);
302 if (!read_seqcount_retry(&dentry->d_seq, seq)) {
303 ret = 1;
304 dentry->d_count++;
305 }
306
307 return ret;
308}
309
310/* validate "insecure" dentry pointer */
311extern int d_validate(struct dentry *, struct dentry *);
312
313/*
314 * helper function for dentry_operations.d_dname() members
315 */
316extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
317
318extern char *__d_path(const struct path *, const struct path *, char *, int);
319extern char *d_absolute_path(const struct path *, char *, int);
320extern char *d_path(const struct path *, char *, int);
321extern char *d_path_with_unreachable(const struct path *, char *, int);
322extern char *dentry_path_raw(struct dentry *, char *, int);
323extern char *dentry_path(struct dentry *, char *, int);
324
325/* Allocation counts.. */
326
327/**
328 * dget, dget_dlock - get a reference to a dentry
329 * @dentry: dentry to get a reference to
330 *
331 * Given a dentry or %NULL pointer increment the reference count
332 * if appropriate and return the dentry. A dentry will not be
333 * destroyed when it has references.
334 */
335static inline struct dentry *dget_dlock(struct dentry *dentry)
336{
337 if (dentry)
338 dentry->d_count++;
339 return dentry;
340}
341
342static inline struct dentry *dget(struct dentry *dentry)
343{
344 if (dentry) {
345 spin_lock(&dentry->d_lock);
346 dget_dlock(dentry);
347 spin_unlock(&dentry->d_lock);
348 }
349 return dentry;
350}
351
352extern struct dentry *dget_parent(struct dentry *dentry);
353
354/**
355 * d_unhashed - is dentry hashed
356 * @dentry: entry to check
357 *
358 * Returns true if the dentry passed is not currently hashed.
359 */
360
361static inline int d_unhashed(struct dentry *dentry)
362{
363 return hlist_bl_unhashed(&dentry->d_hash);
364}
365
366static inline int d_unlinked(struct dentry *dentry)
367{
368 return d_unhashed(dentry) && !IS_ROOT(dentry);
369}
370
371static inline int cant_mount(struct dentry *dentry)
372{
373 return (dentry->d_flags & DCACHE_CANT_MOUNT);
374}
375
376static inline void dont_mount(struct dentry *dentry)
377{
378 spin_lock(&dentry->d_lock);
379 dentry->d_flags |= DCACHE_CANT_MOUNT;
380 spin_unlock(&dentry->d_lock);
381}
382
383extern void dput(struct dentry *);
384
385static inline bool d_managed(struct dentry *dentry)
386{
387 return dentry->d_flags & DCACHE_MANAGED_DENTRY;
388}
389
390static inline bool d_mountpoint(struct dentry *dentry)
391{
392 return dentry->d_flags & DCACHE_MOUNTED;
393}
394
395static inline bool d_need_lookup(struct dentry *dentry)
396{
397 return dentry->d_flags & DCACHE_NEED_LOOKUP;
398}
399
400extern void d_clear_need_lookup(struct dentry *dentry);
401
402extern int sysctl_vfs_cache_pressure;
403
404#endif /* __LINUX_DCACHE_H */