blob: d67ae119cf4eb9d3143d5019108f1d7fbf252b88 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef __LINUX_DCACHE_H
2#define __LINUX_DCACHE_H
3
Arun Sharma600634972011-07-26 16:09:06 -07004#include <linux/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005#include <linux/list.h>
Franck Bui-Huu82524742008-05-12 21:21:05 +02006#include <linux/rculist.h>
Nick Pigginceb5bdc2011-01-07 17:50:05 +11007#include <linux/rculist_bl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/spinlock.h>
Nick Piggin31e6b012011-01-07 17:49:52 +11009#include <linux/seqlock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/cache.h>
11#include <linux/rcupdate.h>
Waiman Long98474232013-08-28 18:24:59 -070012#include <linux/lockref.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013
Jan Blunckcf28b482008-02-14 19:38:44 -080014struct path;
Linus Torvalds1da177e2005-04-16 15:20:36 -070015struct 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
Linus Torvalds26fe5752012-05-10 13:14:12 -070028/* The hash is always the low bits of hash_len */
29#ifdef __LITTLE_ENDIAN
30 #define HASH_LEN_DECLARE u32 hash; u32 len;
Will Deacona5c21dc2013-12-12 17:40:21 +000031 #define bytemask_from_count(cnt) (~(~0ul << (cnt)*8))
Linus Torvalds26fe5752012-05-10 13:14:12 -070032#else
33 #define HASH_LEN_DECLARE u32 len; u32 hash;
Will Deacona5c21dc2013-12-12 17:40:21 +000034 #define bytemask_from_count(cnt) (~(~0ul >> (cnt)*8))
Linus Torvalds26fe5752012-05-10 13:14:12 -070035#endif
36
Linus Torvalds1da177e2005-04-16 15:20:36 -070037/*
38 * "quick string" -- eases parameter passing, but more importantly
39 * saves "metadata" about the string (ie length and the hash).
40 *
41 * hash comes first so it snuggles against d_parent in the
42 * dentry.
43 */
44struct qstr {
Linus Torvalds26fe5752012-05-10 13:14:12 -070045 union {
46 struct {
47 HASH_LEN_DECLARE;
48 };
49 u64 hash_len;
50 };
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 const unsigned char *name;
52};
53
Linus Torvalds26fe5752012-05-10 13:14:12 -070054#define QSTR_INIT(n,l) { { { .len = l } }, .name = n }
55#define hashlen_hash(hashlen) ((u32) (hashlen))
56#define hashlen_len(hashlen) ((u32)((hashlen) >> 32))
Linus Torvalds9226b5b2014-09-14 17:28:32 -070057#define hashlen_create(hash,len) (((u64)(len)<<32)|(u32)(hash))
Linus Torvalds26fe5752012-05-10 13:14:12 -070058
Linus Torvalds1da177e2005-04-16 15:20:36 -070059struct dentry_stat_t {
Glauber Costa3942c072013-08-28 10:17:53 +100060 long nr_dentry;
61 long nr_unused;
62 long age_limit; /* age in seconds */
63 long want_pages; /* pages requested by system */
64 long dummy[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -070065};
66extern struct dentry_stat_t dentry_stat;
67
68/* Name hashing routines. Initial hash value */
69/* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
70#define init_name_hash() 0
71
72/* partial hash update function. Assume roughly 4 bits per character */
73static inline unsigned long
74partial_name_hash(unsigned long c, unsigned long prevhash)
75{
76 return (prevhash + (c << 4) + (c >> 4)) * 11;
77}
78
79/*
80 * Finally: cut down the number of bits to a int value (and try to avoid
81 * losing bits)
82 */
83static inline unsigned long end_name_hash(unsigned long hash)
84{
85 return (unsigned int) hash;
86}
87
88/* Compute the hash for a name string. */
Linus Torvalds0145acc2012-03-02 14:32:59 -080089extern unsigned int full_name_hash(const unsigned char *, unsigned int);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Nick Pigginc2452f32008-12-01 09:33:43 +010091/*
92 * Try to keep struct dentry aligned on 64 byte cachelines (this will
93 * give reasonable cacheline footprint with larger lines without the
94 * large memory footprint increase).
95 */
96#ifdef CONFIG_64BIT
Nick Piggin44a7d7a2011-01-07 17:49:56 +110097# define DNAME_INLINE_LEN 32 /* 192 bytes */
Nick Pigginc2452f32008-12-01 09:33:43 +010098#else
Nick Piggin44a7d7a2011-01-07 17:49:56 +110099# ifdef CONFIG_SMP
100# define DNAME_INLINE_LEN 36 /* 128 bytes */
101# else
102# define DNAME_INLINE_LEN 40 /* 128 bytes */
103# endif
Nick Pigginc2452f32008-12-01 09:33:43 +0100104#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
Waiman Long98474232013-08-28 18:24:59 -0700106#define d_lock d_lockref.lock
107
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108struct dentry {
Nick Piggin44a7d7a2011-01-07 17:49:56 +1100109 /* RCU lookup touched fields */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 unsigned int d_flags; /* protected by d_lock */
Nick Piggin31e6b012011-01-07 17:49:52 +1100111 seqcount_t d_seq; /* per dentry seqlock */
Nick Pigginceb5bdc2011-01-07 17:50:05 +1100112 struct hlist_bl_node d_hash; /* lookup hash list */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 struct dentry *d_parent; /* parent directory */
114 struct qstr d_name;
Nick Piggin44a7d7a2011-01-07 17:49:56 +1100115 struct inode *d_inode; /* Where the name belongs to - NULL is
116 * negative */
117 unsigned char d_iname[DNAME_INLINE_LEN]; /* small names */
118
119 /* Ref lookup also touches following */
Waiman Long98474232013-08-28 18:24:59 -0700120 struct lockref d_lockref; /* per-dentry lock and refcount */
Nick Piggin44a7d7a2011-01-07 17:49:56 +1100121 const struct dentry_operations *d_op;
122 struct super_block *d_sb; /* The root of the dentry tree */
123 unsigned long d_time; /* used by d_revalidate */
124 void *d_fsdata; /* fs-specific data */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
126 struct list_head d_lru; /* LRU list */
Al Viro946e51f2014-10-26 19:19:16 -0400127 struct list_head d_child; /* child of parent list */
128 struct list_head d_subdirs; /* our children */
Eric Dumazet5160ee62006-01-08 01:03:32 -0800129 /*
Al Viro946e51f2014-10-26 19:19:16 -0400130 * d_alias and d_rcu can share memory
Eric Dumazet5160ee62006-01-08 01:03:32 -0800131 */
132 union {
Al Viro946e51f2014-10-26 19:19:16 -0400133 struct hlist_node d_alias; /* inode alias list */
Eric Dumazet5160ee62006-01-08 01:03:32 -0800134 struct rcu_head d_rcu;
135 } d_u;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136};
137
Ingo Molnara90b9c02006-07-03 00:25:04 -0700138/*
139 * dentry->d_lock spinlock nesting subclasses:
140 *
141 * 0: normal
142 * 1: nested
143 */
144enum dentry_d_lock_class
145{
146 DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */
147 DENTRY_D_LOCK_NESTED
148};
149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150struct dentry_operations {
Al Viro0b728e12012-06-10 16:03:43 -0400151 int (*d_revalidate)(struct dentry *, unsigned int);
Jeff Laytonecf3d1f2013-02-20 11:19:05 -0500152 int (*d_weak_revalidate)(struct dentry *, unsigned int);
Linus Torvaldsda53be12013-05-21 15:22:44 -0700153 int (*d_hash)(const struct dentry *, struct qstr *);
154 int (*d_compare)(const struct dentry *, const struct dentry *,
Nick Piggin621e1552011-01-07 17:49:27 +1100155 unsigned int, const char *, const struct qstr *);
Nick Pigginfe15ce42011-01-07 17:49:23 +1100156 int (*d_delete)(const struct dentry *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 void (*d_release)(struct dentry *);
Sage Weilf0023bc2011-10-28 10:02:42 -0700158 void (*d_prune)(struct dentry *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 void (*d_iput)(struct dentry *, struct inode *);
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700160 char *(*d_dname)(struct dentry *, char *, int);
David Howells9875cf82011-01-14 18:45:21 +0000161 struct vfsmount *(*d_automount)(struct path *);
Al Viro1aed3e42011-03-18 09:09:02 -0400162 int (*d_manage)(struct dentry *, bool);
David Howells4bacc9c2015-06-18 14:32:31 +0100163 struct inode *(*d_select_inode)(struct dentry *, unsigned);
Nick Piggin44a7d7a2011-01-07 17:49:56 +1100164} ____cacheline_aligned;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
Nick Piggin5eef7fa2011-01-07 17:49:22 +1100166/*
167 * Locking rules for dentry_operations callbacks are to be found in
168 * Documentation/filesystems/Locking. Keep it updated!
169 *
Nick Piggin621e1552011-01-07 17:49:27 +1100170 * FUrther descriptions are found in Documentation/filesystems/vfs.txt.
171 * Keep it updated too!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 */
173
174/* d_flags entries */
David Howellsb18825a2013-09-12 19:22:53 +0100175#define DCACHE_OP_HASH 0x00000001
176#define DCACHE_OP_COMPARE 0x00000002
177#define DCACHE_OP_REVALIDATE 0x00000004
178#define DCACHE_OP_DELETE 0x00000008
179#define DCACHE_OP_PRUNE 0x00000010
Nick Piggin5f57cbc2011-01-07 17:49:54 +1100180
David Howellsb18825a2013-09-12 19:22:53 +0100181#define DCACHE_DISCONNECTED 0x00000020
Nick Piggin5f57cbc2011-01-07 17:49:54 +1100182 /* This dentry is possibly not currently connected to the dcache tree, in
183 * which case its parent will either be itself, or will have this flag as
184 * well. nfsd will not use a dentry with this bit set, but will first
185 * endeavour to clear the bit either by discovering that it is connected,
186 * or by performing lookup operations. Any filesystem which supports
187 * nfsd_operations MUST have a lookup function which, if it finds a
188 * directory inode with a DCACHE_DISCONNECTED dentry, will d_move that
189 * dentry into place and return that dentry rather than the passed one,
190 * typically using d_splice_alias. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
David Howellsb18825a2013-09-12 19:22:53 +0100192#define DCACHE_REFERENCED 0x00000040 /* Recently used, don't discard. */
193#define DCACHE_RCUACCESS 0x00000080 /* Entry has ever been RCU-visible */
Eric Parisc28f7e52009-05-21 17:01:29 -0400194
David Howellsb18825a2013-09-12 19:22:53 +0100195#define DCACHE_CANT_MOUNT 0x00000100
196#define DCACHE_GENOCIDE 0x00000200
197#define DCACHE_SHRINK_LIST 0x00000400
Nick Piggin5f57cbc2011-01-07 17:49:54 +1100198
David Howellsb18825a2013-09-12 19:22:53 +0100199#define DCACHE_OP_WEAK_REVALIDATE 0x00000800
Jeff Laytonecf3d1f2013-02-20 11:19:05 -0500200
David Howellsb18825a2013-09-12 19:22:53 +0100201#define DCACHE_NFSFS_RENAMED 0x00001000
Linus Torvalds830c0f02011-08-06 22:41:50 -0700202 /* this dentry has been "silly renamed" and has to be deleted on the last
203 * dput() */
David Howellsb18825a2013-09-12 19:22:53 +0100204#define DCACHE_COOKIE 0x00002000 /* For use by dcookie subsystem */
205#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x00004000
Linus Torvalds830c0f02011-08-06 22:41:50 -0700206 /* Parent inode is watched by some fsnotify listener */
Nick Pigginfb045ad2011-01-07 17:49:55 +1100207
David Howellsb18825a2013-09-12 19:22:53 +0100208#define DCACHE_DENTRY_KILLED 0x00008000
209
210#define DCACHE_MOUNTED 0x00010000 /* is a mountpoint */
211#define DCACHE_NEED_AUTOMOUNT 0x00020000 /* handle automount on this dir */
212#define DCACHE_MANAGE_TRANSIT 0x00040000 /* manage transit from this dirent */
David Howells9875cf82011-01-14 18:45:21 +0000213#define DCACHE_MANAGED_DENTRY \
David Howellscc53ce52011-01-14 18:45:26 +0000214 (DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT)
David Howells9875cf82011-01-14 18:45:21 +0000215
David Howellsb18825a2013-09-12 19:22:53 +0100216#define DCACHE_LRU_LIST 0x00080000
217
218#define DCACHE_ENTRY_TYPE 0x00700000
David Howellse7f7d222015-01-29 12:02:27 +0000219#define DCACHE_MISS_TYPE 0x00000000 /* Negative dentry (maybe fallthru to nowhere) */
220#define DCACHE_WHITEOUT_TYPE 0x00100000 /* Whiteout dentry (stop pathwalk) */
221#define DCACHE_DIRECTORY_TYPE 0x00200000 /* Normal directory */
222#define DCACHE_AUTODIR_TYPE 0x00300000 /* Lookupless directory (presumed automount) */
David Howells44bdb5e2015-01-29 12:02:29 +0000223#define DCACHE_REGULAR_TYPE 0x00400000 /* Regular file type (or fallthru to such) */
224#define DCACHE_SPECIAL_TYPE 0x00500000 /* Other file type (or fallthru to such) */
225#define DCACHE_SYMLINK_TYPE 0x00600000 /* Symlink (or fallthru to such) */
Miklos Szeredib161dfa62012-09-17 22:31:38 +0200226
Al Viro41edf272014-05-01 10:30:00 -0400227#define DCACHE_MAY_FREE 0x00800000
David Howellsdf1a0852015-01-29 12:02:28 +0000228#define DCACHE_FALLTHRU 0x01000000 /* Fall through to lower layer */
David Howells4bacc9c2015-06-18 14:32:31 +0100229#define DCACHE_OP_SELECT_INODE 0x02000000 /* Unioned entry: dcache op selects inode */
Al Viro41edf272014-05-01 10:30:00 -0400230
Al Viro74c3cbe2007-07-22 08:04:18 -0400231extern seqlock_t rename_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233/*
234 * These are the low-level FS interfaces to the dcache..
235 */
236extern void d_instantiate(struct dentry *, struct inode *);
237extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
Miklos Szeredib70a80e2013-10-01 16:44:54 +0200238extern int d_instantiate_no_diralias(struct dentry *, struct inode *);
Nick Piggin789680d2011-01-07 17:49:30 +1100239extern void __d_drop(struct dentry *dentry);
240extern void d_drop(struct dentry *dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241extern void d_delete(struct dentry *);
Nick Pigginfb045ad2011-01-07 17:49:55 +1100242extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244/* allocate/de-allocate */
245extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
Nick Piggin4b936882011-01-07 17:50:07 +1100246extern struct dentry * d_alloc_pseudo(struct super_block *, const struct qstr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
Christoph Hellwige45b5902008-08-07 23:49:07 +0200248extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
Sage Weil46f72b32012-01-10 09:04:37 -0800249extern struct dentry *d_find_any_alias(struct inode *inode);
Christoph Hellwig4ea3ada2008-08-11 15:48:57 +0200250extern struct dentry * d_obtain_alias(struct inode *);
J. Bruce Fields1a0a3972014-02-14 17:35:37 -0500251extern struct dentry * d_obtain_root(struct inode *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252extern void shrink_dcache_sb(struct super_block *);
253extern void shrink_dcache_parent(struct dentry *);
David Howellsc636ebd2006-10-11 01:22:19 -0700254extern void shrink_dcache_for_umount(struct super_block *);
Eric W. Biederman5542aa22014-02-13 09:46:25 -0800255extern void d_invalidate(struct dentry *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257/* only used at mount-time */
Al Viroadc0e912012-01-08 16:49:21 -0500258extern struct dentry * d_make_root(struct inode *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
260/* <clickety>-<click> the ramfs-type tree */
261extern void d_genocide(struct dentry *);
262
Al Viro60545d02013-06-07 01:20:27 -0400263extern void d_tmpfile(struct dentry *, struct inode *);
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265extern struct dentry *d_find_alias(struct inode *);
266extern void d_prune_aliases(struct inode *);
267
268/* test whether we have any submounts in a subdir tree */
269extern int have_submounts(struct dentry *);
270
271/*
272 * This adds the entry to the hash queues.
273 */
274extern void d_rehash(struct dentry *);
275
276/**
277 * d_add - add dentry to hash queues
278 * @entry: dentry to add
279 * @inode: The inode to attach to this dentry
280 *
281 * This adds the entry to the hash queues and initializes @inode.
282 * The entry was actually filled in earlier during d_alloc().
283 */
284
285static inline void d_add(struct dentry *entry, struct inode *inode)
286{
287 d_instantiate(entry, inode);
288 d_rehash(entry);
289}
290
291/**
292 * d_add_unique - add dentry to hash queues without aliasing
293 * @entry: dentry to add
294 * @inode: The inode to attach to this dentry
295 *
296 * This adds the entry to the hash queues and initializes @inode.
297 * The entry was actually filled in earlier during d_alloc().
298 */
299static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
300{
301 struct dentry *res;
302
303 res = d_instantiate_unique(entry, inode);
304 d_rehash(res != NULL ? res : entry);
305 return res;
306}
307
Nick Pigginfb2d5b82011-01-07 17:49:26 +1100308extern void dentry_update_name_case(struct dentry *, struct qstr *);
309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310/* used for rename() and baskets */
311extern void d_move(struct dentry *, struct dentry *);
Miklos Szeredida1ce062014-04-01 17:08:43 +0200312extern void d_exchange(struct dentry *, struct dentry *);
OGAWA Hirofumie2761a12008-10-16 07:50:28 +0900313extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
315/* appendix may either be NULL or be used for transname suffixes */
Al Viroda2d8452013-01-24 18:29:34 -0500316extern struct dentry *d_lookup(const struct dentry *, const struct qstr *);
Nick Piggin31e6b012011-01-07 17:49:52 +1100317extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
Al Viroa713ca22013-01-24 18:27:00 -0500318extern struct dentry *__d_lookup(const struct dentry *, const struct qstr *);
Linus Torvalds8966be92012-03-02 14:23:30 -0800319extern struct dentry *__d_lookup_rcu(const struct dentry *parent,
Linus Torvaldsda53be12013-05-21 15:22:44 -0700320 const struct qstr *name, unsigned *seq);
Nick Piggin31e6b012011-01-07 17:49:52 +1100321
Peng Tao24924a22013-07-18 22:09:08 +0800322static inline unsigned d_count(const struct dentry *dentry)
Al Viro84d08fa2013-07-05 18:59:33 +0400323{
Waiman Long98474232013-08-28 18:24:59 -0700324 return dentry->d_lockref.count;
Al Viro84d08fa2013-07-05 18:59:33 +0400325}
326
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700327/*
328 * helper function for dentry_operations.d_dname() members
329 */
Nicolas Iooss8db14862015-07-17 16:23:42 -0700330extern __printf(4, 5)
331char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
Al Viro118b2302013-08-24 12:08:17 -0400332extern char *simple_dname(struct dentry *, char *, int);
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700333
Al Viro02125a82011-12-05 08:43:34 -0500334extern char *__d_path(const struct path *, const struct path *, char *, int);
335extern char *d_absolute_path(const struct path *, char *, int);
Jan Engelhardt20d4fdc2008-06-09 16:40:36 -0700336extern char *d_path(const struct path *, char *, int);
Nick Pigginec2447c2011-01-07 17:49:29 +1100337extern char *dentry_path_raw(struct dentry *, char *, int);
Ram Pai6092d042008-03-27 13:06:20 +0100338extern char *dentry_path(struct dentry *, char *, int);
Jan Blunckcf28b482008-02-14 19:38:44 -0800339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340/* Allocation counts.. */
341
342/**
Nick Piggindc0474b2011-01-07 17:49:43 +1100343 * dget, dget_dlock - get a reference to a dentry
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 * @dentry: dentry to get a reference to
345 *
346 * Given a dentry or %NULL pointer increment the reference count
347 * if appropriate and return the dentry. A dentry will not be
Nick Piggindc0474b2011-01-07 17:49:43 +1100348 * destroyed when it has references.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 */
Nick Pigginb7ab39f2011-01-07 17:49:32 +1100350static inline struct dentry *dget_dlock(struct dentry *dentry)
351{
Nick Piggindc0474b2011-01-07 17:49:43 +1100352 if (dentry)
Waiman Long98474232013-08-28 18:24:59 -0700353 dentry->d_lockref.count++;
Nick Pigginb7ab39f2011-01-07 17:49:32 +1100354 return dentry;
355}
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100356
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357static inline struct dentry *dget(struct dentry *dentry)
358{
Waiman Long98474232013-08-28 18:24:59 -0700359 if (dentry)
360 lockref_get(&dentry->d_lockref);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 return dentry;
362}
363
Nick Pigginb7ab39f2011-01-07 17:49:32 +1100364extern struct dentry *dget_parent(struct dentry *dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
366/**
367 * d_unhashed - is dentry hashed
368 * @dentry: entry to check
369 *
370 * Returns true if the dentry passed is not currently hashed.
371 */
372
Al Virof0d3b3d2013-09-05 12:11:29 -0400373static inline int d_unhashed(const struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374{
Linus Torvaldsdea36672011-04-24 07:58:46 -0700375 return hlist_bl_unhashed(&dentry->d_hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376}
377
Al Virof0d3b3d2013-09-05 12:11:29 -0400378static inline int d_unlinked(const struct dentry *dentry)
Alexey Dobriyanf3da3922009-05-04 03:32:03 +0400379{
380 return d_unhashed(dentry) && !IS_ROOT(dentry);
381}
382
Al Virof0d3b3d2013-09-05 12:11:29 -0400383static inline int cant_mount(const struct dentry *dentry)
Al Virod83c49f2010-04-30 17:17:09 -0400384{
385 return (dentry->d_flags & DCACHE_CANT_MOUNT);
386}
387
388static inline void dont_mount(struct dentry *dentry)
389{
390 spin_lock(&dentry->d_lock);
391 dentry->d_flags |= DCACHE_CANT_MOUNT;
392 spin_unlock(&dentry->d_lock);
393}
394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395extern void dput(struct dentry *);
396
Al Virof0d3b3d2013-09-05 12:11:29 -0400397static inline bool d_managed(const struct dentry *dentry)
David Howellscc53ce52011-01-14 18:45:26 +0000398{
399 return dentry->d_flags & DCACHE_MANAGED_DENTRY;
400}
401
Al Virof0d3b3d2013-09-05 12:11:29 -0400402static inline bool d_mountpoint(const struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403{
Nick Piggin5f57cbc2011-01-07 17:49:54 +1100404 return dentry->d_flags & DCACHE_MOUNTED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405}
406
David Howellsb18825a2013-09-12 19:22:53 +0100407/*
408 * Directory cache entry type accessor functions.
409 */
David Howellsb18825a2013-09-12 19:22:53 +0100410static inline unsigned __d_entry_type(const struct dentry *dentry)
411{
David Howells4bf46a22015-03-05 14:09:22 +0000412 unsigned type = READ_ONCE(dentry->d_flags);
413 smp_rmb();
414 return type & DCACHE_ENTRY_TYPE;
David Howellsb18825a2013-09-12 19:22:53 +0100415}
416
David Howellse7f7d222015-01-29 12:02:27 +0000417static inline bool d_is_miss(const struct dentry *dentry)
418{
419 return __d_entry_type(dentry) == DCACHE_MISS_TYPE;
420}
421
422static inline bool d_is_whiteout(const struct dentry *dentry)
423{
424 return __d_entry_type(dentry) == DCACHE_WHITEOUT_TYPE;
425}
426
Miklos Szeredi44b1d532014-04-01 17:08:41 +0200427static inline bool d_can_lookup(const struct dentry *dentry)
David Howellsb18825a2013-09-12 19:22:53 +0100428{
429 return __d_entry_type(dentry) == DCACHE_DIRECTORY_TYPE;
430}
431
432static inline bool d_is_autodir(const struct dentry *dentry)
433{
434 return __d_entry_type(dentry) == DCACHE_AUTODIR_TYPE;
435}
436
Miklos Szeredi44b1d532014-04-01 17:08:41 +0200437static inline bool d_is_dir(const struct dentry *dentry)
438{
439 return d_can_lookup(dentry) || d_is_autodir(dentry);
440}
441
David Howellsb18825a2013-09-12 19:22:53 +0100442static inline bool d_is_symlink(const struct dentry *dentry)
443{
444 return __d_entry_type(dentry) == DCACHE_SYMLINK_TYPE;
445}
446
David Howells44bdb5e2015-01-29 12:02:29 +0000447static inline bool d_is_reg(const struct dentry *dentry)
448{
449 return __d_entry_type(dentry) == DCACHE_REGULAR_TYPE;
450}
451
452static inline bool d_is_special(const struct dentry *dentry)
453{
454 return __d_entry_type(dentry) == DCACHE_SPECIAL_TYPE;
455}
456
David Howellsb18825a2013-09-12 19:22:53 +0100457static inline bool d_is_file(const struct dentry *dentry)
458{
David Howells44bdb5e2015-01-29 12:02:29 +0000459 return d_is_reg(dentry) || d_is_special(dentry);
David Howellsb18825a2013-09-12 19:22:53 +0100460}
461
462static inline bool d_is_negative(const struct dentry *dentry)
463{
David Howellse7f7d222015-01-29 12:02:27 +0000464 // TODO: check d_is_whiteout(dentry) also.
465 return d_is_miss(dentry);
David Howellsb18825a2013-09-12 19:22:53 +0100466}
467
468static inline bool d_is_positive(const struct dentry *dentry)
469{
470 return !d_is_negative(dentry);
471}
472
David Howells525d27b2015-02-11 13:40:17 +0000473/**
474 * d_really_is_negative - Determine if a dentry is really negative (ignoring fallthroughs)
475 * @dentry: The dentry in question
476 *
477 * Returns true if the dentry represents either an absent name or a name that
478 * doesn't map to an inode (ie. ->d_inode is NULL). The dentry could represent
479 * a true miss, a whiteout that isn't represented by a 0,0 chardev or a
480 * fallthrough marker in an opaque directory.
481 *
482 * Note! (1) This should be used *only* by a filesystem to examine its own
483 * dentries. It should not be used to look at some other filesystem's
484 * dentries. (2) It should also be used in combination with d_inode() to get
485 * the inode. (3) The dentry may have something attached to ->d_lower and the
486 * type field of the flags may be set to something other than miss or whiteout.
487 */
488static inline bool d_really_is_negative(const struct dentry *dentry)
489{
490 return dentry->d_inode == NULL;
491}
492
493/**
494 * d_really_is_positive - Determine if a dentry is really positive (ignoring fallthroughs)
495 * @dentry: The dentry in question
496 *
497 * Returns true if the dentry represents a name that maps to an inode
498 * (ie. ->d_inode is not NULL). The dentry might still represent a whiteout if
499 * that is represented on medium as a 0,0 chardev.
500 *
501 * Note! (1) This should be used *only* by a filesystem to examine its own
502 * dentries. It should not be used to look at some other filesystem's
503 * dentries. (2) It should also be used in combination with d_inode() to get
504 * the inode.
505 */
506static inline bool d_really_is_positive(const struct dentry *dentry)
507{
508 return dentry->d_inode != NULL;
509}
510
Al Virodc3f4192015-05-18 10:10:34 -0400511static inline int simple_positive(struct dentry *dentry)
512{
513 return d_really_is_positive(dentry) && !d_unhashed(dentry);
514}
515
David Howellsdf1a0852015-01-29 12:02:28 +0000516extern void d_set_fallthru(struct dentry *dentry);
517
518static inline bool d_is_fallthru(const struct dentry *dentry)
519{
520 return dentry->d_flags & DCACHE_FALLTHRU;
521}
522
523
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524extern int sysctl_vfs_cache_pressure;
525
Glauber Costa55f841c2013-08-28 10:17:53 +1000526static inline unsigned long vfs_pressure_ratio(unsigned long val)
527{
528 return mult_frac(val, sysctl_vfs_cache_pressure, 100);
529}
David Howells155e35d2015-01-29 12:02:27 +0000530
531/**
532 * d_inode - Get the actual inode of this dentry
533 * @dentry: The dentry to query
534 *
535 * This is the helper normal filesystems should use to get at their own inodes
536 * in their own dentries and ignore the layering superimposed upon them.
537 */
538static inline struct inode *d_inode(const struct dentry *dentry)
539{
540 return dentry->d_inode;
541}
542
543/**
544 * d_inode_rcu - Get the actual inode of this dentry with ACCESS_ONCE()
545 * @dentry: The dentry to query
546 *
547 * This is the helper normal filesystems should use to get at their own inodes
548 * in their own dentries and ignore the layering superimposed upon them.
549 */
550static inline struct inode *d_inode_rcu(const struct dentry *dentry)
551{
552 return ACCESS_ONCE(dentry->d_inode);
553}
554
555/**
556 * d_backing_inode - Get upper or lower inode we should be using
557 * @upper: The upper layer
558 *
559 * This is the helper that should be used to get at the inode that will be used
560 * if this dentry were to be opened as a file. The inode may be on the upper
561 * dentry or it may be on a lower dentry pinned by the upper.
562 *
563 * Normal filesystems should not use this to access their own inodes.
564 */
565static inline struct inode *d_backing_inode(const struct dentry *upper)
566{
567 struct inode *inode = upper->d_inode;
568
569 return inode;
570}
571
572/**
573 * d_backing_dentry - Get upper or lower dentry we should be using
574 * @upper: The upper layer
575 *
576 * This is the helper that should be used to get the dentry of the inode that
577 * will be used if this dentry were opened as a file. It may be the upper
578 * dentry or it may be a lower dentry pinned by the upper.
579 *
580 * Normal filesystems should not use this to access their own dentries.
581 */
582static inline struct dentry *d_backing_dentry(struct dentry *upper)
583{
584 return upper;
585}
586
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587#endif /* __LINUX_DCACHE_H */