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

Free Electrons

Embedded Linux Experts

Linux/include/linux/dcache.h
