dcache.h 19 KB

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