dcache.h 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361
  1. #ifndef __LINUX_DCACHE_H
  2. #define __LINUX_DCACHE_H
  3. #ifdef __KERNEL__
  4. #include <asm/atomic.h>
  5. #include <linux/list.h>
  6. #include <linux/spinlock.h>
  7. #include <linux/cache.h>
  8. #include <linux/rcupdate.h>
  9. struct nameidata;
  10. struct vfsmount;
  11. /*
  12. * linux/include/linux/dcache.h
  13. *
  14. * Dirent cache data structures
  15. *
  16. * (C) Copyright 1997 Thomas Schoebel-Theuer,
  17. * with heavy changes by Linus Torvalds
  18. */
  19. #define IS_ROOT(x) ((x) == (x)->d_parent)
  20. /*
  21. * "quick string" -- eases parameter passing, but more importantly
  22. * saves "metadata" about the string (ie length and the hash).
  23. *
  24. * hash comes first so it snuggles against d_parent in the
  25. * dentry.
  26. */
  27. struct qstr {
  28. unsigned int hash;
  29. unsigned int len;
  30. const unsigned char *name;
  31. };
  32. struct dentry_stat_t {
  33. int nr_dentry;
  34. int nr_unused;
  35. int age_limit; /* age in seconds */
  36. int want_pages; /* pages requested by system */
  37. int dummy[2];
  38. };
  39. extern struct dentry_stat_t dentry_stat;
  40. /* Name hashing routines. Initial hash value */
  41. /* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
  42. #define init_name_hash() 0
  43. /* partial hash update function. Assume roughly 4 bits per character */
  44. static inline unsigned long
  45. partial_name_hash(unsigned long c, unsigned long prevhash)
  46. {
  47. return (prevhash + (c << 4) + (c >> 4)) * 11;
  48. }
  49. /*
  50. * Finally: cut down the number of bits to a int value (and try to avoid
  51. * losing bits)
  52. */
  53. static inline unsigned long end_name_hash(unsigned long hash)
  54. {
  55. return (unsigned int) hash;
  56. }
  57. /* Compute the hash for a name string. */
  58. static inline unsigned int
  59. full_name_hash(const unsigned char *name, unsigned int len)
  60. {
  61. unsigned long hash = init_name_hash();
  62. while (len--)
  63. hash = partial_name_hash(*name++, hash);
  64. return end_name_hash(hash);
  65. }
  66. struct dcookie_struct;
  67. #define DNAME_INLINE_LEN_MIN 36
  68. struct dentry {
  69. atomic_t d_count;
  70. unsigned int d_flags; /* protected by d_lock */
  71. spinlock_t d_lock; /* per dentry lock */
  72. struct inode *d_inode; /* Where the name belongs to - NULL is
  73. * negative */
  74. /*
  75. * The next three fields are touched by __d_lookup. Place them here
  76. * so they all fit in a cache line.
  77. */
  78. struct hlist_node d_hash; /* lookup hash list */
  79. struct dentry *d_parent; /* parent directory */
  80. struct qstr d_name;
  81. struct list_head d_lru; /* LRU list */
  82. /*
  83. * d_child and d_rcu can share memory
  84. */
  85. union {
  86. struct list_head d_child; /* child of parent list */
  87. struct rcu_head d_rcu;
  88. } d_u;
  89. struct list_head d_subdirs; /* our children */
  90. struct list_head d_alias; /* inode alias list */
  91. unsigned long d_time; /* used by d_revalidate */
  92. struct dentry_operations *d_op;
  93. struct super_block *d_sb; /* The root of the dentry tree */
  94. void *d_fsdata; /* fs-specific data */
  95. #ifdef CONFIG_PROFILING
  96. struct dcookie_struct *d_cookie; /* cookie, if any */
  97. #endif
  98. int d_mounted;
  99. unsigned char d_iname[DNAME_INLINE_LEN_MIN]; /* small names */
  100. };
  101. /*
  102. * dentry->d_lock spinlock nesting subclasses:
  103. *
  104. * 0: normal
  105. * 1: nested
  106. */
  107. enum dentry_d_lock_class
  108. {
  109. DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */
  110. DENTRY_D_LOCK_NESTED
  111. };
  112. struct dentry_operations {
  113. int (*d_revalidate)(struct dentry *, struct nameidata *);
  114. int (*d_hash) (struct dentry *, struct qstr *);
  115. int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
  116. int (*d_delete)(struct dentry *);
  117. void (*d_release)(struct dentry *);
  118. void (*d_iput)(struct dentry *, struct inode *);
  119. };
  120. /* the dentry parameter passed to d_hash and d_compare is the parent
  121. * directory of the entries to be compared. It is used in case these
  122. * functions need any directory specific information for determining
  123. * equivalency classes. Using the dentry itself might not work, as it
  124. * might be a negative dentry which has no information associated with
  125. * it */
  126. /*
  127. locking rules:
  128. big lock dcache_lock d_lock may block
  129. d_revalidate: no no no yes
  130. d_hash no no no yes
  131. d_compare: no yes yes no
  132. d_delete: no yes no no
  133. d_release: no no no yes
  134. d_iput: no no no yes
  135. */
  136. /* d_flags entries */
  137. #define DCACHE_AUTOFS_PENDING 0x0001 /* autofs: "under construction" */
  138. #define DCACHE_NFSFS_RENAMED 0x0002 /* this dentry has been "silly
  139. * renamed" and has to be
  140. * deleted on the last dput()
  141. */
  142. #define DCACHE_DISCONNECTED 0x0004
  143. /* This dentry is possibly not currently connected to the dcache tree,
  144. * in which case its parent will either be itself, or will have this
  145. * flag as well. nfsd will not use a dentry with this bit set, but will
  146. * first endeavour to clear the bit either by discovering that it is
  147. * connected, or by performing lookup operations. Any filesystem which
  148. * supports nfsd_operations MUST have a lookup function which, if it finds
  149. * a directory inode with a DCACHE_DISCONNECTED dentry, will d_move
  150. * that dentry into place and return that dentry rather than the passed one,
  151. * typically using d_splice_alias.
  152. */
  153. #define DCACHE_REFERENCED 0x0008 /* Recently used, don't discard. */
  154. #define DCACHE_UNHASHED 0x0010
  155. #define DCACHE_INOTIFY_PARENT_WATCHED 0x0020 /* Parent inode is watched */
  156. extern spinlock_t dcache_lock;
  157. /**
  158. * d_drop - drop a dentry
  159. * @dentry: dentry to drop
  160. *
  161. * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
  162. * be found through a VFS lookup any more. Note that this is different from
  163. * deleting the dentry - d_delete will try to mark the dentry negative if
  164. * possible, giving a successful _negative_ lookup, while d_drop will
  165. * just make the cache lookup fail.
  166. *
  167. * d_drop() is used mainly for stuff that wants to invalidate a dentry for some
  168. * reason (NFS timeouts or autofs deletes).
  169. *
  170. * __d_drop requires dentry->d_lock.
  171. */
  172. static inline void __d_drop(struct dentry *dentry)
  173. {
  174. if (!(dentry->d_flags & DCACHE_UNHASHED)) {
  175. dentry->d_flags |= DCACHE_UNHASHED;
  176. hlist_del_rcu(&dentry->d_hash);
  177. }
  178. }
  179. static inline void d_drop(struct dentry *dentry)
  180. {
  181. spin_lock(&dcache_lock);
  182. spin_lock(&dentry->d_lock);
  183. __d_drop(dentry);
  184. spin_unlock(&dentry->d_lock);
  185. spin_unlock(&dcache_lock);
  186. }
  187. static inline int dname_external(struct dentry *dentry)
  188. {
  189. return dentry->d_name.name != dentry->d_iname;
  190. }
  191. /*
  192. * These are the low-level FS interfaces to the dcache..
  193. */
  194. extern void d_instantiate(struct dentry *, struct inode *);
  195. extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
  196. extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
  197. extern void d_delete(struct dentry *);
  198. /* allocate/de-allocate */
  199. extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
  200. extern struct dentry * d_alloc_anon(struct inode *);
  201. extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
  202. extern void shrink_dcache_sb(struct super_block *);
  203. extern void shrink_dcache_parent(struct dentry *);
  204. extern void shrink_dcache_for_umount(struct super_block *);
  205. extern int d_invalidate(struct dentry *);
  206. /* only used at mount-time */
  207. extern struct dentry * d_alloc_root(struct inode *);
  208. /* <clickety>-<click> the ramfs-type tree */
  209. extern void d_genocide(struct dentry *);
  210. extern struct dentry *d_find_alias(struct inode *);
  211. extern void d_prune_aliases(struct inode *);
  212. /* test whether we have any submounts in a subdir tree */
  213. extern int have_submounts(struct dentry *);
  214. /*
  215. * This adds the entry to the hash queues.
  216. */
  217. extern void d_rehash(struct dentry *);
  218. /**
  219. * d_add - add dentry to hash queues
  220. * @entry: dentry to add
  221. * @inode: The inode to attach to this dentry
  222. *
  223. * This adds the entry to the hash queues and initializes @inode.
  224. * The entry was actually filled in earlier during d_alloc().
  225. */
  226. static inline void d_add(struct dentry *entry, struct inode *inode)
  227. {
  228. d_instantiate(entry, inode);
  229. d_rehash(entry);
  230. }
  231. /**
  232. * d_add_unique - add dentry to hash queues without aliasing
  233. * @entry: dentry to add
  234. * @inode: The inode to attach to this dentry
  235. *
  236. * This adds the entry to the hash queues and initializes @inode.
  237. * The entry was actually filled in earlier during d_alloc().
  238. */
  239. static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
  240. {
  241. struct dentry *res;
  242. res = d_instantiate_unique(entry, inode);
  243. d_rehash(res != NULL ? res : entry);
  244. return res;
  245. }
  246. /* used for rename() and baskets */
  247. extern void d_move(struct dentry *, struct dentry *);
  248. /* appendix may either be NULL or be used for transname suffixes */
  249. extern struct dentry * d_lookup(struct dentry *, struct qstr *);
  250. extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
  251. extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *);
  252. /* validate "insecure" dentry pointer */
  253. extern int d_validate(struct dentry *, struct dentry *);
  254. extern char * d_path(struct dentry *, struct vfsmount *, char *, int);
  255. /* Allocation counts.. */
  256. /**
  257. * dget, dget_locked - get a reference to a dentry
  258. * @dentry: dentry to get a reference to
  259. *
  260. * Given a dentry or %NULL pointer increment the reference count
  261. * if appropriate and return the dentry. A dentry will not be
  262. * destroyed when it has references. dget() should never be
  263. * called for dentries with zero reference counter. For these cases
  264. * (preferably none, functions in dcache.c are sufficient for normal
  265. * needs and they take necessary precautions) you should hold dcache_lock
  266. * and call dget_locked() instead of dget().
  267. */
  268. static inline struct dentry *dget(struct dentry *dentry)
  269. {
  270. if (dentry) {
  271. BUG_ON(!atomic_read(&dentry->d_count));
  272. atomic_inc(&dentry->d_count);
  273. }
  274. return dentry;
  275. }
  276. extern struct dentry * dget_locked(struct dentry *);
  277. /**
  278. * d_unhashed - is dentry hashed
  279. * @dentry: entry to check
  280. *
  281. * Returns true if the dentry passed is not currently hashed.
  282. */
  283. static inline int d_unhashed(struct dentry *dentry)
  284. {
  285. return (dentry->d_flags & DCACHE_UNHASHED);
  286. }
  287. static inline struct dentry *dget_parent(struct dentry *dentry)
  288. {
  289. struct dentry *ret;
  290. spin_lock(&dentry->d_lock);
  291. ret = dget(dentry->d_parent);
  292. spin_unlock(&dentry->d_lock);
  293. return ret;
  294. }
  295. extern void dput(struct dentry *);
  296. static inline int d_mountpoint(struct dentry *dentry)
  297. {
  298. return dentry->d_mounted;
  299. }
  300. extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *);
  301. extern struct vfsmount *__lookup_mnt(struct vfsmount *, struct dentry *, int);
  302. extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
  303. extern int sysctl_vfs_cache_pressure;
  304. #endif /* __KERNEL__ */
  305. #endif /* __LINUX_DCACHE_H */