Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef __LINUX_DCACHE_H |
| 2 | #define __LINUX_DCACHE_H |
| 3 | |
Arun Sharma | 60063497 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 4 | #include <linux/atomic.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | #include <linux/list.h> |
Franck Bui-Huu | 8252474 | 2008-05-12 21:21:05 +0200 | [diff] [blame] | 6 | #include <linux/rculist.h> |
Nick Piggin | ceb5bdc | 2011-01-07 17:50:05 +1100 | [diff] [blame] | 7 | #include <linux/rculist_bl.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 8 | #include <linux/spinlock.h> |
Nick Piggin | 31e6b01 | 2011-01-07 17:49:52 +1100 | [diff] [blame] | 9 | #include <linux/seqlock.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | #include <linux/cache.h> |
| 11 | #include <linux/rcupdate.h> |
Waiman Long | 9847423 | 2013-08-28 18:24:59 -0700 | [diff] [blame] | 12 | #include <linux/lockref.h> |
George Spelvin | f4bcbe7 | 2016-05-20 07:26:00 -0400 | [diff] [blame] | 13 | #include <linux/stringhash.h> |
Ingo Molnar | f9411eb | 2017-02-06 09:50:49 +0100 | [diff] [blame] | 14 | #include <linux/wait.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
Jan Blunck | cf28b48 | 2008-02-14 19:38:44 -0800 | [diff] [blame] | 16 | struct path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | struct vfsmount; |
| 18 | |
| 19 | /* |
| 20 | * linux/include/linux/dcache.h |
| 21 | * |
| 22 | * Dirent cache data structures |
| 23 | * |
| 24 | * (C) Copyright 1997 Thomas Schoebel-Theuer, |
| 25 | * with heavy changes by Linus Torvalds |
| 26 | */ |
| 27 | |
| 28 | #define IS_ROOT(x) ((x) == (x)->d_parent) |
| 29 | |
Linus Torvalds | 26fe575 | 2012-05-10 13:14:12 -0700 | [diff] [blame] | 30 | /* The hash is always the low bits of hash_len */ |
| 31 | #ifdef __LITTLE_ENDIAN |
Andrew Morton | 2bd03e4 | 2016-01-14 15:17:53 -0800 | [diff] [blame] | 32 | #define HASH_LEN_DECLARE u32 hash; u32 len |
Will Deacon | a5c21dc | 2013-12-12 17:40:21 +0000 | [diff] [blame] | 33 | #define bytemask_from_count(cnt) (~(~0ul << (cnt)*8)) |
Linus Torvalds | 26fe575 | 2012-05-10 13:14:12 -0700 | [diff] [blame] | 34 | #else |
Andrew Morton | 2bd03e4 | 2016-01-14 15:17:53 -0800 | [diff] [blame] | 35 | #define HASH_LEN_DECLARE u32 len; u32 hash |
Will Deacon | a5c21dc | 2013-12-12 17:40:21 +0000 | [diff] [blame] | 36 | #define bytemask_from_count(cnt) (~(~0ul >> (cnt)*8)) |
Linus Torvalds | 26fe575 | 2012-05-10 13:14:12 -0700 | [diff] [blame] | 37 | #endif |
| 38 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | /* |
| 40 | * "quick string" -- eases parameter passing, but more importantly |
| 41 | * saves "metadata" about the string (ie length and the hash). |
| 42 | * |
| 43 | * hash comes first so it snuggles against d_parent in the |
| 44 | * dentry. |
| 45 | */ |
| 46 | struct qstr { |
Linus Torvalds | 26fe575 | 2012-05-10 13:14:12 -0700 | [diff] [blame] | 47 | union { |
| 48 | struct { |
| 49 | HASH_LEN_DECLARE; |
| 50 | }; |
| 51 | u64 hash_len; |
| 52 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | const unsigned char *name; |
| 54 | }; |
| 55 | |
Linus Torvalds | 26fe575 | 2012-05-10 13:14:12 -0700 | [diff] [blame] | 56 | #define QSTR_INIT(n,l) { { { .len = l } }, .name = n } |
Linus Torvalds | 26fe575 | 2012-05-10 13:14:12 -0700 | [diff] [blame] | 57 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | struct dentry_stat_t { |
Glauber Costa | 3942c07 | 2013-08-28 10:17:53 +1000 | [diff] [blame] | 59 | long nr_dentry; |
| 60 | long nr_unused; |
| 61 | long age_limit; /* age in seconds */ |
| 62 | long want_pages; /* pages requested by system */ |
| 63 | long dummy[2]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | }; |
| 65 | extern struct dentry_stat_t dentry_stat; |
| 66 | |
Nick Piggin | c2452f3 | 2008-12-01 09:33:43 +0100 | [diff] [blame] | 67 | /* |
| 68 | * Try to keep struct dentry aligned on 64 byte cachelines (this will |
| 69 | * give reasonable cacheline footprint with larger lines without the |
| 70 | * large memory footprint increase). |
| 71 | */ |
| 72 | #ifdef CONFIG_64BIT |
Nick Piggin | 44a7d7a | 2011-01-07 17:49:56 +1100 | [diff] [blame] | 73 | # define DNAME_INLINE_LEN 32 /* 192 bytes */ |
Nick Piggin | c2452f3 | 2008-12-01 09:33:43 +0100 | [diff] [blame] | 74 | #else |
Nick Piggin | 44a7d7a | 2011-01-07 17:49:56 +1100 | [diff] [blame] | 75 | # ifdef CONFIG_SMP |
| 76 | # define DNAME_INLINE_LEN 36 /* 128 bytes */ |
| 77 | # else |
| 78 | # define DNAME_INLINE_LEN 40 /* 128 bytes */ |
| 79 | # endif |
Nick Piggin | c2452f3 | 2008-12-01 09:33:43 +0100 | [diff] [blame] | 80 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | |
Waiman Long | 9847423 | 2013-08-28 18:24:59 -0700 | [diff] [blame] | 82 | #define d_lock d_lockref.lock |
| 83 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 84 | struct dentry { |
Nick Piggin | 44a7d7a | 2011-01-07 17:49:56 +1100 | [diff] [blame] | 85 | /* RCU lookup touched fields */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | unsigned int d_flags; /* protected by d_lock */ |
Nick Piggin | 31e6b01 | 2011-01-07 17:49:52 +1100 | [diff] [blame] | 87 | seqcount_t d_seq; /* per dentry seqlock */ |
Nick Piggin | ceb5bdc | 2011-01-07 17:50:05 +1100 | [diff] [blame] | 88 | struct hlist_bl_node d_hash; /* lookup hash list */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | struct dentry *d_parent; /* parent directory */ |
| 90 | struct qstr d_name; |
Nick Piggin | 44a7d7a | 2011-01-07 17:49:56 +1100 | [diff] [blame] | 91 | struct inode *d_inode; /* Where the name belongs to - NULL is |
| 92 | * negative */ |
| 93 | unsigned char d_iname[DNAME_INLINE_LEN]; /* small names */ |
| 94 | |
| 95 | /* Ref lookup also touches following */ |
Waiman Long | 9847423 | 2013-08-28 18:24:59 -0700 | [diff] [blame] | 96 | struct lockref d_lockref; /* per-dentry lock and refcount */ |
Nick Piggin | 44a7d7a | 2011-01-07 17:49:56 +1100 | [diff] [blame] | 97 | const struct dentry_operations *d_op; |
| 98 | struct super_block *d_sb; /* The root of the dentry tree */ |
| 99 | unsigned long d_time; /* used by d_revalidate */ |
| 100 | void *d_fsdata; /* fs-specific data */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | |
Al Viro | d9171b9 | 2016-04-15 03:33:13 -0400 | [diff] [blame] | 102 | union { |
| 103 | struct list_head d_lru; /* LRU list */ |
| 104 | wait_queue_head_t *d_wait; /* in-lookup ones only */ |
| 105 | }; |
Al Viro | 946e51f | 2014-10-26 19:19:16 -0400 | [diff] [blame] | 106 | struct list_head d_child; /* child of parent list */ |
| 107 | struct list_head d_subdirs; /* our children */ |
Eric Dumazet | 5160ee6 | 2006-01-08 01:03:32 -0800 | [diff] [blame] | 108 | /* |
Al Viro | 946e51f | 2014-10-26 19:19:16 -0400 | [diff] [blame] | 109 | * d_alias and d_rcu can share memory |
Eric Dumazet | 5160ee6 | 2006-01-08 01:03:32 -0800 | [diff] [blame] | 110 | */ |
| 111 | union { |
Al Viro | 946e51f | 2014-10-26 19:19:16 -0400 | [diff] [blame] | 112 | struct hlist_node d_alias; /* inode alias list */ |
Al Viro | 94bdd65 | 2016-04-15 02:42:04 -0400 | [diff] [blame] | 113 | struct hlist_bl_node d_in_lookup_hash; /* only for in-lookup ones */ |
Eric Dumazet | 5160ee6 | 2006-01-08 01:03:32 -0800 | [diff] [blame] | 114 | struct rcu_head d_rcu; |
| 115 | } d_u; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | }; |
| 117 | |
Ingo Molnar | a90b9c0 | 2006-07-03 00:25:04 -0700 | [diff] [blame] | 118 | /* |
| 119 | * dentry->d_lock spinlock nesting subclasses: |
| 120 | * |
| 121 | * 0: normal |
| 122 | * 1: nested |
| 123 | */ |
| 124 | enum dentry_d_lock_class |
| 125 | { |
| 126 | DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */ |
| 127 | DENTRY_D_LOCK_NESTED |
| 128 | }; |
| 129 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | struct dentry_operations { |
Al Viro | 0b728e1 | 2012-06-10 16:03:43 -0400 | [diff] [blame] | 131 | int (*d_revalidate)(struct dentry *, unsigned int); |
Jeff Layton | ecf3d1f | 2013-02-20 11:19:05 -0500 | [diff] [blame] | 132 | int (*d_weak_revalidate)(struct dentry *, unsigned int); |
Linus Torvalds | da53be1 | 2013-05-21 15:22:44 -0700 | [diff] [blame] | 133 | int (*d_hash)(const struct dentry *, struct qstr *); |
Al Viro | 6fa67e7 | 2016-07-31 16:37:25 -0400 | [diff] [blame] | 134 | int (*d_compare)(const struct dentry *, |
Nick Piggin | 621e155 | 2011-01-07 17:49:27 +1100 | [diff] [blame] | 135 | unsigned int, const char *, const struct qstr *); |
Nick Piggin | fe15ce4 | 2011-01-07 17:49:23 +1100 | [diff] [blame] | 136 | int (*d_delete)(const struct dentry *); |
Miklos Szeredi | 285b102 | 2016-06-28 11:47:32 +0200 | [diff] [blame] | 137 | int (*d_init)(struct dentry *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | void (*d_release)(struct dentry *); |
Sage Weil | f0023bc | 2011-10-28 10:02:42 -0700 | [diff] [blame] | 139 | void (*d_prune)(struct dentry *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 140 | void (*d_iput)(struct dentry *, struct inode *); |
Eric Dumazet | c23fbb6 | 2007-05-08 00:26:18 -0700 | [diff] [blame] | 141 | char *(*d_dname)(struct dentry *, char *, int); |
David Howells | 9875cf8 | 2011-01-14 18:45:21 +0000 | [diff] [blame] | 142 | struct vfsmount *(*d_automount)(struct path *); |
Ian Kent | fb5f51c | 2016-11-24 08:03:41 +1100 | [diff] [blame] | 143 | int (*d_manage)(const struct path *, bool); |
Miklos Szeredi | e698b8a | 2016-06-30 08:53:27 +0200 | [diff] [blame] | 144 | struct dentry *(*d_real)(struct dentry *, const struct inode *, |
| 145 | unsigned int); |
Nick Piggin | 44a7d7a | 2011-01-07 17:49:56 +1100 | [diff] [blame] | 146 | } ____cacheline_aligned; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | |
Nick Piggin | 5eef7fa | 2011-01-07 17:49:22 +1100 | [diff] [blame] | 148 | /* |
| 149 | * Locking rules for dentry_operations callbacks are to be found in |
| 150 | * Documentation/filesystems/Locking. Keep it updated! |
| 151 | * |
Nick Piggin | 621e155 | 2011-01-07 17:49:27 +1100 | [diff] [blame] | 152 | * FUrther descriptions are found in Documentation/filesystems/vfs.txt. |
| 153 | * Keep it updated too! |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | */ |
| 155 | |
| 156 | /* d_flags entries */ |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 157 | #define DCACHE_OP_HASH 0x00000001 |
| 158 | #define DCACHE_OP_COMPARE 0x00000002 |
| 159 | #define DCACHE_OP_REVALIDATE 0x00000004 |
| 160 | #define DCACHE_OP_DELETE 0x00000008 |
| 161 | #define DCACHE_OP_PRUNE 0x00000010 |
Nick Piggin | 5f57cbc | 2011-01-07 17:49:54 +1100 | [diff] [blame] | 162 | |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 163 | #define DCACHE_DISCONNECTED 0x00000020 |
Nick Piggin | 5f57cbc | 2011-01-07 17:49:54 +1100 | [diff] [blame] | 164 | /* This dentry is possibly not currently connected to the dcache tree, in |
| 165 | * which case its parent will either be itself, or will have this flag as |
| 166 | * well. nfsd will not use a dentry with this bit set, but will first |
| 167 | * endeavour to clear the bit either by discovering that it is connected, |
| 168 | * or by performing lookup operations. Any filesystem which supports |
| 169 | * nfsd_operations MUST have a lookup function which, if it finds a |
| 170 | * directory inode with a DCACHE_DISCONNECTED dentry, will d_move that |
| 171 | * dentry into place and return that dentry rather than the passed one, |
| 172 | * typically using d_splice_alias. */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 174 | #define DCACHE_REFERENCED 0x00000040 /* Recently used, don't discard. */ |
| 175 | #define DCACHE_RCUACCESS 0x00000080 /* Entry has ever been RCU-visible */ |
Eric Paris | c28f7e5 | 2009-05-21 17:01:29 -0400 | [diff] [blame] | 176 | |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 177 | #define DCACHE_CANT_MOUNT 0x00000100 |
| 178 | #define DCACHE_GENOCIDE 0x00000200 |
| 179 | #define DCACHE_SHRINK_LIST 0x00000400 |
Nick Piggin | 5f57cbc | 2011-01-07 17:49:54 +1100 | [diff] [blame] | 180 | |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 181 | #define DCACHE_OP_WEAK_REVALIDATE 0x00000800 |
Jeff Layton | ecf3d1f | 2013-02-20 11:19:05 -0500 | [diff] [blame] | 182 | |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 183 | #define DCACHE_NFSFS_RENAMED 0x00001000 |
Linus Torvalds | 830c0f0 | 2011-08-06 22:41:50 -0700 | [diff] [blame] | 184 | /* this dentry has been "silly renamed" and has to be deleted on the last |
| 185 | * dput() */ |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 186 | #define DCACHE_COOKIE 0x00002000 /* For use by dcookie subsystem */ |
| 187 | #define DCACHE_FSNOTIFY_PARENT_WATCHED 0x00004000 |
Linus Torvalds | 830c0f0 | 2011-08-06 22:41:50 -0700 | [diff] [blame] | 188 | /* Parent inode is watched by some fsnotify listener */ |
Nick Piggin | fb045ad | 2011-01-07 17:49:55 +1100 | [diff] [blame] | 189 | |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 190 | #define DCACHE_DENTRY_KILLED 0x00008000 |
| 191 | |
| 192 | #define DCACHE_MOUNTED 0x00010000 /* is a mountpoint */ |
| 193 | #define DCACHE_NEED_AUTOMOUNT 0x00020000 /* handle automount on this dir */ |
| 194 | #define DCACHE_MANAGE_TRANSIT 0x00040000 /* manage transit from this dirent */ |
David Howells | 9875cf8 | 2011-01-14 18:45:21 +0000 | [diff] [blame] | 195 | #define DCACHE_MANAGED_DENTRY \ |
David Howells | cc53ce5 | 2011-01-14 18:45:26 +0000 | [diff] [blame] | 196 | (DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT) |
David Howells | 9875cf8 | 2011-01-14 18:45:21 +0000 | [diff] [blame] | 197 | |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 198 | #define DCACHE_LRU_LIST 0x00080000 |
| 199 | |
| 200 | #define DCACHE_ENTRY_TYPE 0x00700000 |
David Howells | e7f7d22 | 2015-01-29 12:02:27 +0000 | [diff] [blame] | 201 | #define DCACHE_MISS_TYPE 0x00000000 /* Negative dentry (maybe fallthru to nowhere) */ |
| 202 | #define DCACHE_WHITEOUT_TYPE 0x00100000 /* Whiteout dentry (stop pathwalk) */ |
| 203 | #define DCACHE_DIRECTORY_TYPE 0x00200000 /* Normal directory */ |
| 204 | #define DCACHE_AUTODIR_TYPE 0x00300000 /* Lookupless directory (presumed automount) */ |
David Howells | 44bdb5e | 2015-01-29 12:02:29 +0000 | [diff] [blame] | 205 | #define DCACHE_REGULAR_TYPE 0x00400000 /* Regular file type (or fallthru to such) */ |
| 206 | #define DCACHE_SPECIAL_TYPE 0x00500000 /* Other file type (or fallthru to such) */ |
| 207 | #define DCACHE_SYMLINK_TYPE 0x00600000 /* Symlink (or fallthru to such) */ |
Miklos Szeredi | b161dfa6 | 2012-09-17 22:31:38 +0200 | [diff] [blame] | 208 | |
Al Viro | 41edf27 | 2014-05-01 10:30:00 -0400 | [diff] [blame] | 209 | #define DCACHE_MAY_FREE 0x00800000 |
David Howells | df1a085 | 2015-01-29 12:02:28 +0000 | [diff] [blame] | 210 | #define DCACHE_FALLTHRU 0x01000000 /* Fall through to lower layer */ |
Miklos Szeredi | 2d90267 | 2016-06-30 08:53:27 +0200 | [diff] [blame] | 211 | #define DCACHE_ENCRYPTED_WITH_KEY 0x02000000 /* dir is encrypted with a valid key */ |
| 212 | #define DCACHE_OP_REAL 0x04000000 |
Jaegeuk Kim | 0b81d07 | 2015-05-15 16:26:10 -0700 | [diff] [blame] | 213 | |
Al Viro | 85c7f81 | 2016-04-14 19:52:13 -0400 | [diff] [blame] | 214 | #define DCACHE_PAR_LOOKUP 0x10000000 /* being looked up (with parent locked shared) */ |
Al Viro | ba65dc5 | 2016-06-10 11:32:47 -0400 | [diff] [blame] | 215 | #define DCACHE_DENTRY_CURSOR 0x20000000 |
Al Viro | 85c7f81 | 2016-04-14 19:52:13 -0400 | [diff] [blame] | 216 | |
Al Viro | 74c3cbe | 2007-07-22 08:04:18 -0400 | [diff] [blame] | 217 | extern seqlock_t rename_lock; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | /* |
| 220 | * These are the low-level FS interfaces to the dcache.. |
| 221 | */ |
| 222 | extern void d_instantiate(struct dentry *, struct inode *); |
| 223 | extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *); |
Miklos Szeredi | b70a80e | 2013-10-01 16:44:54 +0200 | [diff] [blame] | 224 | extern int d_instantiate_no_diralias(struct dentry *, struct inode *); |
Nick Piggin | 789680d | 2011-01-07 17:49:30 +1100 | [diff] [blame] | 225 | extern void __d_drop(struct dentry *dentry); |
| 226 | extern void d_drop(struct dentry *dentry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 227 | extern void d_delete(struct dentry *); |
Nick Piggin | fb045ad | 2011-01-07 17:49:55 +1100 | [diff] [blame] | 228 | extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 229 | |
| 230 | /* allocate/de-allocate */ |
| 231 | extern struct dentry * d_alloc(struct dentry *, const struct qstr *); |
Nick Piggin | 4b93688 | 2011-01-07 17:50:07 +1100 | [diff] [blame] | 232 | extern struct dentry * d_alloc_pseudo(struct super_block *, const struct qstr *); |
Al Viro | d9171b9 | 2016-04-15 03:33:13 -0400 | [diff] [blame] | 233 | extern struct dentry * d_alloc_parallel(struct dentry *, const struct qstr *, |
| 234 | wait_queue_head_t *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 235 | extern struct dentry * d_splice_alias(struct inode *, struct dentry *); |
Christoph Hellwig | e45b590 | 2008-08-07 23:49:07 +0200 | [diff] [blame] | 236 | extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *); |
Al Viro | 668d0cd | 2016-03-08 12:44:17 -0500 | [diff] [blame] | 237 | extern struct dentry * d_exact_alias(struct dentry *, struct inode *); |
Sage Weil | 46f72b3 | 2012-01-10 09:04:37 -0800 | [diff] [blame] | 238 | extern struct dentry *d_find_any_alias(struct inode *inode); |
Christoph Hellwig | 4ea3ada | 2008-08-11 15:48:57 +0200 | [diff] [blame] | 239 | extern struct dentry * d_obtain_alias(struct inode *); |
J. Bruce Fields | 1a0a397 | 2014-02-14 17:35:37 -0500 | [diff] [blame] | 240 | extern struct dentry * d_obtain_root(struct inode *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | extern void shrink_dcache_sb(struct super_block *); |
| 242 | extern void shrink_dcache_parent(struct dentry *); |
David Howells | c636ebd | 2006-10-11 01:22:19 -0700 | [diff] [blame] | 243 | extern void shrink_dcache_for_umount(struct super_block *); |
Eric W. Biederman | 5542aa2 | 2014-02-13 09:46:25 -0800 | [diff] [blame] | 244 | extern void d_invalidate(struct dentry *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | |
| 246 | /* only used at mount-time */ |
Al Viro | adc0e91 | 2012-01-08 16:49:21 -0500 | [diff] [blame] | 247 | extern struct dentry * d_make_root(struct inode *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | |
| 249 | /* <clickety>-<click> the ramfs-type tree */ |
| 250 | extern void d_genocide(struct dentry *); |
| 251 | |
Al Viro | 60545d0 | 2013-06-07 01:20:27 -0400 | [diff] [blame] | 252 | extern void d_tmpfile(struct dentry *, struct inode *); |
| 253 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | extern struct dentry *d_find_alias(struct inode *); |
| 255 | extern void d_prune_aliases(struct inode *); |
| 256 | |
| 257 | /* test whether we have any submounts in a subdir tree */ |
Ian Kent | 0161949 | 2016-11-24 08:03:41 +1100 | [diff] [blame] | 258 | extern int path_has_submounts(const struct path *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 259 | |
| 260 | /* |
| 261 | * This adds the entry to the hash queues. |
| 262 | */ |
| 263 | extern void d_rehash(struct dentry *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | |
Al Viro | 34d0d19 | 2016-03-08 21:01:03 -0500 | [diff] [blame] | 265 | extern void d_add(struct dentry *, struct inode *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 266 | |
Al Viro | 9aba36d | 2016-07-20 22:28:45 -0400 | [diff] [blame] | 267 | extern void dentry_update_name_case(struct dentry *, const struct qstr *); |
Nick Piggin | fb2d5b8 | 2011-01-07 17:49:26 +1100 | [diff] [blame] | 268 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | /* used for rename() and baskets */ |
| 270 | extern void d_move(struct dentry *, struct dentry *); |
Miklos Szeredi | da1ce06 | 2014-04-01 17:08:43 +0200 | [diff] [blame] | 271 | extern void d_exchange(struct dentry *, struct dentry *); |
OGAWA Hirofumi | e2761a1 | 2008-10-16 07:50:28 +0900 | [diff] [blame] | 272 | extern struct dentry *d_ancestor(struct dentry *, struct dentry *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 273 | |
| 274 | /* appendix may either be NULL or be used for transname suffixes */ |
Al Viro | da2d845 | 2013-01-24 18:29:34 -0500 | [diff] [blame] | 275 | extern struct dentry *d_lookup(const struct dentry *, const struct qstr *); |
Nick Piggin | 31e6b01 | 2011-01-07 17:49:52 +1100 | [diff] [blame] | 276 | extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *); |
Al Viro | a713ca2 | 2013-01-24 18:27:00 -0500 | [diff] [blame] | 277 | extern struct dentry *__d_lookup(const struct dentry *, const struct qstr *); |
Linus Torvalds | 8966be9 | 2012-03-02 14:23:30 -0800 | [diff] [blame] | 278 | extern struct dentry *__d_lookup_rcu(const struct dentry *parent, |
Linus Torvalds | da53be1 | 2013-05-21 15:22:44 -0700 | [diff] [blame] | 279 | const struct qstr *name, unsigned *seq); |
Nick Piggin | 31e6b01 | 2011-01-07 17:49:52 +1100 | [diff] [blame] | 280 | |
Peng Tao | 24924a2 | 2013-07-18 22:09:08 +0800 | [diff] [blame] | 281 | static inline unsigned d_count(const struct dentry *dentry) |
Al Viro | 84d08fa | 2013-07-05 18:59:33 +0400 | [diff] [blame] | 282 | { |
Waiman Long | 9847423 | 2013-08-28 18:24:59 -0700 | [diff] [blame] | 283 | return dentry->d_lockref.count; |
Al Viro | 84d08fa | 2013-07-05 18:59:33 +0400 | [diff] [blame] | 284 | } |
| 285 | |
Eric Dumazet | c23fbb6 | 2007-05-08 00:26:18 -0700 | [diff] [blame] | 286 | /* |
| 287 | * helper function for dentry_operations.d_dname() members |
| 288 | */ |
Nicolas Iooss | 8db1486 | 2015-07-17 16:23:42 -0700 | [diff] [blame] | 289 | extern __printf(4, 5) |
| 290 | char *dynamic_dname(struct dentry *, char *, int, const char *, ...); |
Al Viro | 118b230 | 2013-08-24 12:08:17 -0400 | [diff] [blame] | 291 | extern char *simple_dname(struct dentry *, char *, int); |
Eric Dumazet | c23fbb6 | 2007-05-08 00:26:18 -0700 | [diff] [blame] | 292 | |
Al Viro | 02125a8 | 2011-12-05 08:43:34 -0500 | [diff] [blame] | 293 | extern char *__d_path(const struct path *, const struct path *, char *, int); |
| 294 | extern char *d_absolute_path(const struct path *, char *, int); |
Jan Engelhardt | 20d4fdc | 2008-06-09 16:40:36 -0700 | [diff] [blame] | 295 | extern char *d_path(const struct path *, char *, int); |
Nick Piggin | ec2447c | 2011-01-07 17:49:29 +1100 | [diff] [blame] | 296 | extern char *dentry_path_raw(struct dentry *, char *, int); |
Ram Pai | 6092d04 | 2008-03-27 13:06:20 +0100 | [diff] [blame] | 297 | extern char *dentry_path(struct dentry *, char *, int); |
Jan Blunck | cf28b48 | 2008-02-14 19:38:44 -0800 | [diff] [blame] | 298 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | /* Allocation counts.. */ |
| 300 | |
| 301 | /** |
Nick Piggin | dc0474b | 2011-01-07 17:49:43 +1100 | [diff] [blame] | 302 | * dget, dget_dlock - get a reference to a dentry |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | * @dentry: dentry to get a reference to |
| 304 | * |
| 305 | * Given a dentry or %NULL pointer increment the reference count |
| 306 | * if appropriate and return the dentry. A dentry will not be |
Nick Piggin | dc0474b | 2011-01-07 17:49:43 +1100 | [diff] [blame] | 307 | * destroyed when it has references. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | */ |
Nick Piggin | b7ab39f | 2011-01-07 17:49:32 +1100 | [diff] [blame] | 309 | static inline struct dentry *dget_dlock(struct dentry *dentry) |
| 310 | { |
Nick Piggin | dc0474b | 2011-01-07 17:49:43 +1100 | [diff] [blame] | 311 | if (dentry) |
Waiman Long | 9847423 | 2013-08-28 18:24:59 -0700 | [diff] [blame] | 312 | dentry->d_lockref.count++; |
Nick Piggin | b7ab39f | 2011-01-07 17:49:32 +1100 | [diff] [blame] | 313 | return dentry; |
| 314 | } |
Nick Piggin | 2fd6b7f | 2011-01-07 17:49:34 +1100 | [diff] [blame] | 315 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 316 | static inline struct dentry *dget(struct dentry *dentry) |
| 317 | { |
Waiman Long | 9847423 | 2013-08-28 18:24:59 -0700 | [diff] [blame] | 318 | if (dentry) |
| 319 | lockref_get(&dentry->d_lockref); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | return dentry; |
| 321 | } |
| 322 | |
Nick Piggin | b7ab39f | 2011-01-07 17:49:32 +1100 | [diff] [blame] | 323 | extern struct dentry *dget_parent(struct dentry *dentry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 324 | |
| 325 | /** |
| 326 | * d_unhashed - is dentry hashed |
| 327 | * @dentry: entry to check |
| 328 | * |
| 329 | * Returns true if the dentry passed is not currently hashed. |
| 330 | */ |
| 331 | |
Al Viro | f0d3b3d | 2013-09-05 12:11:29 -0400 | [diff] [blame] | 332 | static inline int d_unhashed(const struct dentry *dentry) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 333 | { |
Linus Torvalds | dea3667 | 2011-04-24 07:58:46 -0700 | [diff] [blame] | 334 | return hlist_bl_unhashed(&dentry->d_hash); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | } |
| 336 | |
Al Viro | f0d3b3d | 2013-09-05 12:11:29 -0400 | [diff] [blame] | 337 | static inline int d_unlinked(const struct dentry *dentry) |
Alexey Dobriyan | f3da392 | 2009-05-04 03:32:03 +0400 | [diff] [blame] | 338 | { |
| 339 | return d_unhashed(dentry) && !IS_ROOT(dentry); |
| 340 | } |
| 341 | |
Al Viro | f0d3b3d | 2013-09-05 12:11:29 -0400 | [diff] [blame] | 342 | static inline int cant_mount(const struct dentry *dentry) |
Al Viro | d83c49f | 2010-04-30 17:17:09 -0400 | [diff] [blame] | 343 | { |
| 344 | return (dentry->d_flags & DCACHE_CANT_MOUNT); |
| 345 | } |
| 346 | |
| 347 | static inline void dont_mount(struct dentry *dentry) |
| 348 | { |
| 349 | spin_lock(&dentry->d_lock); |
| 350 | dentry->d_flags |= DCACHE_CANT_MOUNT; |
| 351 | spin_unlock(&dentry->d_lock); |
| 352 | } |
| 353 | |
Al Viro | 85c7f81 | 2016-04-14 19:52:13 -0400 | [diff] [blame] | 354 | extern void __d_lookup_done(struct dentry *); |
| 355 | |
| 356 | static inline int d_in_lookup(struct dentry *dentry) |
| 357 | { |
| 358 | return dentry->d_flags & DCACHE_PAR_LOOKUP; |
| 359 | } |
| 360 | |
| 361 | static inline void d_lookup_done(struct dentry *dentry) |
| 362 | { |
| 363 | if (unlikely(d_in_lookup(dentry))) { |
| 364 | spin_lock(&dentry->d_lock); |
| 365 | __d_lookup_done(dentry); |
| 366 | spin_unlock(&dentry->d_lock); |
| 367 | } |
| 368 | } |
| 369 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 370 | extern void dput(struct dentry *); |
| 371 | |
Al Viro | f0d3b3d | 2013-09-05 12:11:29 -0400 | [diff] [blame] | 372 | static inline bool d_managed(const struct dentry *dentry) |
David Howells | cc53ce5 | 2011-01-14 18:45:26 +0000 | [diff] [blame] | 373 | { |
| 374 | return dentry->d_flags & DCACHE_MANAGED_DENTRY; |
| 375 | } |
| 376 | |
Al Viro | f0d3b3d | 2013-09-05 12:11:29 -0400 | [diff] [blame] | 377 | static inline bool d_mountpoint(const struct dentry *dentry) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 378 | { |
Nick Piggin | 5f57cbc | 2011-01-07 17:49:54 +1100 | [diff] [blame] | 379 | return dentry->d_flags & DCACHE_MOUNTED; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 380 | } |
| 381 | |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 382 | /* |
| 383 | * Directory cache entry type accessor functions. |
| 384 | */ |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 385 | static inline unsigned __d_entry_type(const struct dentry *dentry) |
| 386 | { |
Al Viro | a528aca | 2016-02-29 12:12:46 -0500 | [diff] [blame] | 387 | return dentry->d_flags & DCACHE_ENTRY_TYPE; |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 388 | } |
| 389 | |
David Howells | e7f7d22 | 2015-01-29 12:02:27 +0000 | [diff] [blame] | 390 | static inline bool d_is_miss(const struct dentry *dentry) |
| 391 | { |
| 392 | return __d_entry_type(dentry) == DCACHE_MISS_TYPE; |
| 393 | } |
| 394 | |
| 395 | static inline bool d_is_whiteout(const struct dentry *dentry) |
| 396 | { |
| 397 | return __d_entry_type(dentry) == DCACHE_WHITEOUT_TYPE; |
| 398 | } |
| 399 | |
Miklos Szeredi | 44b1d53 | 2014-04-01 17:08:41 +0200 | [diff] [blame] | 400 | static inline bool d_can_lookup(const struct dentry *dentry) |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 401 | { |
| 402 | return __d_entry_type(dentry) == DCACHE_DIRECTORY_TYPE; |
| 403 | } |
| 404 | |
| 405 | static inline bool d_is_autodir(const struct dentry *dentry) |
| 406 | { |
| 407 | return __d_entry_type(dentry) == DCACHE_AUTODIR_TYPE; |
| 408 | } |
| 409 | |
Miklos Szeredi | 44b1d53 | 2014-04-01 17:08:41 +0200 | [diff] [blame] | 410 | static inline bool d_is_dir(const struct dentry *dentry) |
| 411 | { |
| 412 | return d_can_lookup(dentry) || d_is_autodir(dentry); |
| 413 | } |
| 414 | |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 415 | static inline bool d_is_symlink(const struct dentry *dentry) |
| 416 | { |
| 417 | return __d_entry_type(dentry) == DCACHE_SYMLINK_TYPE; |
| 418 | } |
| 419 | |
David Howells | 44bdb5e | 2015-01-29 12:02:29 +0000 | [diff] [blame] | 420 | static inline bool d_is_reg(const struct dentry *dentry) |
| 421 | { |
| 422 | return __d_entry_type(dentry) == DCACHE_REGULAR_TYPE; |
| 423 | } |
| 424 | |
| 425 | static inline bool d_is_special(const struct dentry *dentry) |
| 426 | { |
| 427 | return __d_entry_type(dentry) == DCACHE_SPECIAL_TYPE; |
| 428 | } |
| 429 | |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 430 | static inline bool d_is_file(const struct dentry *dentry) |
| 431 | { |
David Howells | 44bdb5e | 2015-01-29 12:02:29 +0000 | [diff] [blame] | 432 | return d_is_reg(dentry) || d_is_special(dentry); |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 433 | } |
| 434 | |
| 435 | static inline bool d_is_negative(const struct dentry *dentry) |
| 436 | { |
David Howells | e7f7d22 | 2015-01-29 12:02:27 +0000 | [diff] [blame] | 437 | // TODO: check d_is_whiteout(dentry) also. |
| 438 | return d_is_miss(dentry); |
David Howells | b18825a | 2013-09-12 19:22:53 +0100 | [diff] [blame] | 439 | } |
| 440 | |
| 441 | static inline bool d_is_positive(const struct dentry *dentry) |
| 442 | { |
| 443 | return !d_is_negative(dentry); |
| 444 | } |
| 445 | |
David Howells | 525d27b | 2015-02-11 13:40:17 +0000 | [diff] [blame] | 446 | /** |
| 447 | * d_really_is_negative - Determine if a dentry is really negative (ignoring fallthroughs) |
| 448 | * @dentry: The dentry in question |
| 449 | * |
| 450 | * Returns true if the dentry represents either an absent name or a name that |
| 451 | * doesn't map to an inode (ie. ->d_inode is NULL). The dentry could represent |
| 452 | * a true miss, a whiteout that isn't represented by a 0,0 chardev or a |
| 453 | * fallthrough marker in an opaque directory. |
| 454 | * |
| 455 | * Note! (1) This should be used *only* by a filesystem to examine its own |
| 456 | * dentries. It should not be used to look at some other filesystem's |
| 457 | * dentries. (2) It should also be used in combination with d_inode() to get |
| 458 | * the inode. (3) The dentry may have something attached to ->d_lower and the |
| 459 | * type field of the flags may be set to something other than miss or whiteout. |
| 460 | */ |
| 461 | static inline bool d_really_is_negative(const struct dentry *dentry) |
| 462 | { |
| 463 | return dentry->d_inode == NULL; |
| 464 | } |
| 465 | |
| 466 | /** |
| 467 | * d_really_is_positive - Determine if a dentry is really positive (ignoring fallthroughs) |
| 468 | * @dentry: The dentry in question |
| 469 | * |
| 470 | * Returns true if the dentry represents a name that maps to an inode |
| 471 | * (ie. ->d_inode is not NULL). The dentry might still represent a whiteout if |
| 472 | * that is represented on medium as a 0,0 chardev. |
| 473 | * |
| 474 | * Note! (1) This should be used *only* by a filesystem to examine its own |
| 475 | * dentries. It should not be used to look at some other filesystem's |
| 476 | * dentries. (2) It should also be used in combination with d_inode() to get |
| 477 | * the inode. |
| 478 | */ |
| 479 | static inline bool d_really_is_positive(const struct dentry *dentry) |
| 480 | { |
| 481 | return dentry->d_inode != NULL; |
| 482 | } |
| 483 | |
Al Viro | dc3f419 | 2015-05-18 10:10:34 -0400 | [diff] [blame] | 484 | static inline int simple_positive(struct dentry *dentry) |
| 485 | { |
| 486 | return d_really_is_positive(dentry) && !d_unhashed(dentry); |
| 487 | } |
| 488 | |
David Howells | df1a085 | 2015-01-29 12:02:28 +0000 | [diff] [blame] | 489 | extern void d_set_fallthru(struct dentry *dentry); |
| 490 | |
| 491 | static inline bool d_is_fallthru(const struct dentry *dentry) |
| 492 | { |
| 493 | return dentry->d_flags & DCACHE_FALLTHRU; |
| 494 | } |
| 495 | |
| 496 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 497 | extern int sysctl_vfs_cache_pressure; |
| 498 | |
Glauber Costa | 55f841c | 2013-08-28 10:17:53 +1000 | [diff] [blame] | 499 | static inline unsigned long vfs_pressure_ratio(unsigned long val) |
| 500 | { |
| 501 | return mult_frac(val, sysctl_vfs_cache_pressure, 100); |
| 502 | } |
David Howells | 155e35d | 2015-01-29 12:02:27 +0000 | [diff] [blame] | 503 | |
| 504 | /** |
| 505 | * d_inode - Get the actual inode of this dentry |
| 506 | * @dentry: The dentry to query |
| 507 | * |
| 508 | * This is the helper normal filesystems should use to get at their own inodes |
| 509 | * in their own dentries and ignore the layering superimposed upon them. |
| 510 | */ |
| 511 | static inline struct inode *d_inode(const struct dentry *dentry) |
| 512 | { |
| 513 | return dentry->d_inode; |
| 514 | } |
| 515 | |
| 516 | /** |
| 517 | * d_inode_rcu - Get the actual inode of this dentry with ACCESS_ONCE() |
| 518 | * @dentry: The dentry to query |
| 519 | * |
| 520 | * This is the helper normal filesystems should use to get at their own inodes |
| 521 | * in their own dentries and ignore the layering superimposed upon them. |
| 522 | */ |
| 523 | static inline struct inode *d_inode_rcu(const struct dentry *dentry) |
| 524 | { |
| 525 | return ACCESS_ONCE(dentry->d_inode); |
| 526 | } |
| 527 | |
| 528 | /** |
| 529 | * d_backing_inode - Get upper or lower inode we should be using |
| 530 | * @upper: The upper layer |
| 531 | * |
| 532 | * This is the helper that should be used to get at the inode that will be used |
| 533 | * if this dentry were to be opened as a file. The inode may be on the upper |
| 534 | * dentry or it may be on a lower dentry pinned by the upper. |
| 535 | * |
| 536 | * Normal filesystems should not use this to access their own inodes. |
| 537 | */ |
| 538 | static inline struct inode *d_backing_inode(const struct dentry *upper) |
| 539 | { |
| 540 | struct inode *inode = upper->d_inode; |
| 541 | |
| 542 | return inode; |
| 543 | } |
| 544 | |
| 545 | /** |
| 546 | * d_backing_dentry - Get upper or lower dentry we should be using |
| 547 | * @upper: The upper layer |
| 548 | * |
| 549 | * This is the helper that should be used to get the dentry of the inode that |
| 550 | * will be used if this dentry were opened as a file. It may be the upper |
| 551 | * dentry or it may be a lower dentry pinned by the upper. |
| 552 | * |
| 553 | * Normal filesystems should not use this to access their own dentries. |
| 554 | */ |
| 555 | static inline struct dentry *d_backing_dentry(struct dentry *upper) |
| 556 | { |
| 557 | return upper; |
| 558 | } |
| 559 | |
Miklos Szeredi | e698b8a | 2016-06-30 08:53:27 +0200 | [diff] [blame] | 560 | /** |
| 561 | * d_real - Return the real dentry |
| 562 | * @dentry: the dentry to query |
| 563 | * @inode: inode to select the dentry from multiple layers (can be NULL) |
| 564 | * @flags: open flags to control copy-up behavior |
| 565 | * |
Masahiro Yamada | 03440c4 | 2017-02-27 14:28:49 -0800 | [diff] [blame] | 566 | * If dentry is on a union/overlay, then return the underlying, real dentry. |
Miklos Szeredi | e698b8a | 2016-06-30 08:53:27 +0200 | [diff] [blame] | 567 | * Otherwise return the dentry itself. |
| 568 | * |
| 569 | * See also: Documentation/filesystems/vfs.txt |
| 570 | */ |
Miklos Szeredi | 2d90267 | 2016-06-30 08:53:27 +0200 | [diff] [blame] | 571 | static inline struct dentry *d_real(struct dentry *dentry, |
| 572 | const struct inode *inode, |
| 573 | unsigned int flags) |
Miklos Szeredi | d101a12 | 2016-03-26 16:14:37 -0400 | [diff] [blame] | 574 | { |
| 575 | if (unlikely(dentry->d_flags & DCACHE_OP_REAL)) |
Miklos Szeredi | 2d90267 | 2016-06-30 08:53:27 +0200 | [diff] [blame] | 576 | return dentry->d_op->d_real(dentry, inode, flags); |
Miklos Szeredi | d101a12 | 2016-03-26 16:14:37 -0400 | [diff] [blame] | 577 | else |
| 578 | return dentry; |
| 579 | } |
| 580 | |
Miklos Szeredi | a118084 | 2016-05-20 22:13:45 +0200 | [diff] [blame] | 581 | /** |
| 582 | * d_real_inode - Return the real inode |
| 583 | * @dentry: The dentry to query |
| 584 | * |
Masahiro Yamada | 03440c4 | 2017-02-27 14:28:49 -0800 | [diff] [blame] | 585 | * If dentry is on a union/overlay, then return the underlying, real inode. |
Miklos Szeredi | a118084 | 2016-05-20 22:13:45 +0200 | [diff] [blame] | 586 | * Otherwise return d_inode(). |
| 587 | */ |
Miklos Szeredi | 7b1742e | 2016-09-16 12:44:20 +0200 | [diff] [blame] | 588 | static inline struct inode *d_real_inode(const struct dentry *dentry) |
Miklos Szeredi | a118084 | 2016-05-20 22:13:45 +0200 | [diff] [blame] | 589 | { |
Miklos Szeredi | 7b1742e | 2016-09-16 12:44:20 +0200 | [diff] [blame] | 590 | /* This usage of d_real() results in const dentry */ |
| 591 | return d_backing_inode(d_real((struct dentry *) dentry, NULL, 0)); |
Miklos Szeredi | a118084 | 2016-05-20 22:13:45 +0200 | [diff] [blame] | 592 | } |
| 593 | |
Miklos Szeredi | 54d5ca8 | 2016-05-11 01:16:37 +0200 | [diff] [blame] | 594 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 595 | #endif /* __LINUX_DCACHE_H */ |