dcache.h 12.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
#ifndef __LINUX_DCACHE_H
#define __LINUX_DCACHE_H

#include <asm/atomic.h>
#include <linux/list.h>
6
#include <linux/rculist.h>
7
#include <linux/rculist_bl.h>
Linus Torvalds's avatar
Linus Torvalds committed
8
#include <linux/spinlock.h>
Nick Piggin's avatar
Nick Piggin committed
9
#include <linux/seqlock.h>
Linus Torvalds's avatar
Linus Torvalds committed
10
11
12
13
#include <linux/cache.h>
#include <linux/rcupdate.h>

struct nameidata;
14
struct path;
Linus Torvalds's avatar
Linus Torvalds committed
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
struct vfsmount;

/*
 * linux/include/linux/dcache.h
 *
 * Dirent cache data structures
 *
 * (C) Copyright 1997 Thomas Schoebel-Theuer,
 * with heavy changes by Linus Torvalds
 */

#define IS_ROOT(x) ((x) == (x)->d_parent)

/*
 * "quick string" -- eases parameter passing, but more importantly
 * saves "metadata" about the string (ie length and the hash).
 *
 * hash comes first so it snuggles against d_parent in the
 * dentry.
 */
struct qstr {
	unsigned int hash;
	unsigned int len;
	const unsigned char *name;
};

struct dentry_stat_t {
	int nr_dentry;
	int nr_unused;
	int age_limit;          /* age in seconds */
	int want_pages;         /* pages requested by system */
	int dummy[2];
};
extern struct dentry_stat_t dentry_stat;

50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/*
 * Compare 2 name strings, return 0 if they match, otherwise non-zero.
 * The strings are both count bytes long, and count is non-zero.
 */
static inline int dentry_cmp(const unsigned char *cs, size_t scount,
				const unsigned char *ct, size_t tcount)
{
	int ret;
	if (scount != tcount)
		return 1;
	do {
		ret = (*cs != *ct);
		if (ret)
			break;
		cs++;
		ct++;
		tcount--;
	} while (tcount);
	return ret;
}

Linus Torvalds's avatar
Linus Torvalds committed
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
/* Name hashing routines. Initial hash value */
/* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
#define init_name_hash()		0

/* partial hash update function. Assume roughly 4 bits per character */
static inline unsigned long
partial_name_hash(unsigned long c, unsigned long prevhash)
{
	return (prevhash + (c << 4) + (c >> 4)) * 11;
}

/*
 * Finally: cut down the number of bits to a int value (and try to avoid
 * losing bits)
 */
static inline unsigned long end_name_hash(unsigned long hash)
{
	return (unsigned int) hash;
}

/* Compute the hash for a name string. */
static inline unsigned int
full_name_hash(const unsigned char *name, unsigned int len)
{
	unsigned long hash = init_name_hash();
	while (len--)
		hash = partial_name_hash(*name++, hash);
	return end_name_hash(hash);
}

Nick Piggin's avatar
Nick Piggin committed
101
102
103
104
105
106
/*
 * Try to keep struct dentry aligned on 64 byte cachelines (this will
 * give reasonable cacheline footprint with larger lines without the
 * large memory footprint increase).
 */
#ifdef CONFIG_64BIT
107
# define DNAME_INLINE_LEN 32 /* 192 bytes */
Nick Piggin's avatar
Nick Piggin committed
108
#else
109
110
111
112
113
# ifdef CONFIG_SMP
#  define DNAME_INLINE_LEN 36 /* 128 bytes */
# else
#  define DNAME_INLINE_LEN 40 /* 128 bytes */
# endif
Nick Piggin's avatar
Nick Piggin committed
114
#endif
Linus Torvalds's avatar
Linus Torvalds committed
115
116

struct dentry {
117
	/* RCU lookup touched fields */
Linus Torvalds's avatar
Linus Torvalds committed
118
	unsigned int d_flags;		/* protected by d_lock */
Nick Piggin's avatar
Nick Piggin committed
119
	seqcount_t d_seq;		/* per dentry seqlock */
120
	struct hlist_bl_node d_hash;	/* lookup hash list */
Linus Torvalds's avatar
Linus Torvalds committed
121
122
	struct dentry *d_parent;	/* parent directory */
	struct qstr d_name;
123
124
125
126
127
128
129
130
131
132
133
	struct inode *d_inode;		/* Where the name belongs to - NULL is
					 * negative */
	unsigned char d_iname[DNAME_INLINE_LEN];	/* small names */

	/* Ref lookup also touches following */
	unsigned int d_count;		/* protected by d_lock */
	spinlock_t d_lock;		/* per dentry lock */
	const struct dentry_operations *d_op;
	struct super_block *d_sb;	/* The root of the dentry tree */
	unsigned long d_time;		/* used by d_revalidate */
	void *d_fsdata;			/* fs-specific data */
Linus Torvalds's avatar
Linus Torvalds committed
134
135

	struct list_head d_lru;		/* LRU list */
Eric Dumazet's avatar
Eric Dumazet committed
136
137
138
139
140
141
142
	/*
	 * d_child and d_rcu can share memory
	 */
	union {
		struct list_head d_child;	/* child of parent list */
	 	struct rcu_head d_rcu;
	} d_u;
Linus Torvalds's avatar
Linus Torvalds committed
143
144
145
146
	struct list_head d_subdirs;	/* our children */
	struct list_head d_alias;	/* inode alias list */
};

Ingo Molnar's avatar
Ingo Molnar committed
147
148
149
150
151
152
153
154
155
156
157
158
/*
 * dentry->d_lock spinlock nesting subclasses:
 *
 * 0: normal
 * 1: nested
 */
enum dentry_d_lock_class
{
	DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */
	DENTRY_D_LOCK_NESTED
};

Linus Torvalds's avatar
Linus Torvalds committed
159
160
struct dentry_operations {
	int (*d_revalidate)(struct dentry *, struct nameidata *);
Nick Piggin's avatar
Nick Piggin committed
161
162
	int (*d_hash)(const struct dentry *, const struct inode *,
			struct qstr *);
163
164
165
	int (*d_compare)(const struct dentry *, const struct inode *,
			const struct dentry *, const struct inode *,
			unsigned int, const char *, const struct qstr *);
Nick Piggin's avatar
Nick Piggin committed
166
	int (*d_delete)(const struct dentry *);
Linus Torvalds's avatar
Linus Torvalds committed
167
168
	void (*d_release)(struct dentry *);
	void (*d_iput)(struct dentry *, struct inode *);
169
	char *(*d_dname)(struct dentry *, char *, int);
170
	struct vfsmount *(*d_automount)(struct path *);
171
	int (*d_manage)(struct dentry *, bool);
172
} ____cacheline_aligned;
Linus Torvalds's avatar
Linus Torvalds committed
173

Nick Piggin's avatar
Nick Piggin committed
174
175
176
177
/*
 * Locking rules for dentry_operations callbacks are to be found in
 * Documentation/filesystems/Locking. Keep it updated!
 *
178
179
 * FUrther descriptions are found in Documentation/filesystems/vfs.txt.
 * Keep it updated too!
Linus Torvalds's avatar
Linus Torvalds committed
180
181
182
183
 */

/* d_flags entries */
#define DCACHE_AUTOFS_PENDING 0x0001    /* autofs: "under construction" */
Nick Piggin's avatar
Nick Piggin committed
184
185
186
187
188
189
190
191
192
193
194
195
196
197
#define DCACHE_NFSFS_RENAMED  0x0002
     /* this dentry has been "silly renamed" and has to be deleted on the last
      * dput() */

#define	DCACHE_DISCONNECTED	0x0004
     /* This dentry is possibly not currently connected to the dcache tree, in
      * which case its parent will either be itself, or will have this flag as
      * well.  nfsd will not use a dentry with this bit set, but will first
      * endeavour to clear the bit either by discovering that it is connected,
      * or by performing lookup operations.   Any filesystem which supports
      * nfsd_operations MUST have a lookup function which, if it finds a
      * directory inode with a DCACHE_DISCONNECTED dentry, will d_move that
      * dentry into place and return that dentry rather than the passed one,
      * typically using d_splice_alias. */
Linus Torvalds's avatar
Linus Torvalds committed
198
199

#define DCACHE_REFERENCED	0x0008  /* Recently used, don't discard. */
200
#define DCACHE_RCUACCESS	0x0010	/* Entry has ever been RCU-visible */
Nick Piggin's avatar
Nick Piggin committed
201
202
#define DCACHE_INOTIFY_PARENT_WATCHED 0x0020
     /* Parent inode is watched by inotify */
203

Nick Piggin's avatar
Nick Piggin committed
204
#define DCACHE_COOKIE		0x0040	/* For use by dcookie subsystem */
Nick Piggin's avatar
Nick Piggin committed
205
206
#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x0080
     /* Parent inode is watched by some fsnotify listener */
207

208
#define DCACHE_CANT_MOUNT	0x0100
209
#define DCACHE_GENOCIDE		0x0200
Nick Piggin's avatar
Nick Piggin committed
210

211
212
213
214
215
#define DCACHE_OP_HASH		0x1000
#define DCACHE_OP_COMPARE	0x2000
#define DCACHE_OP_REVALIDATE	0x4000
#define DCACHE_OP_DELETE	0x8000

216
217
#define DCACHE_MOUNTED		0x10000	/* is a mountpoint */
#define DCACHE_NEED_AUTOMOUNT	0x20000	/* handle automount on this dir */
218
#define DCACHE_MANAGE_TRANSIT	0x40000	/* manage transit from this dirent */
219
#define DCACHE_MANAGED_DENTRY \
220
	(DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT)
221

Al Viro's avatar
Al Viro committed
222
extern seqlock_t rename_lock;
Linus Torvalds's avatar
Linus Torvalds committed
223
224
225
226
227
228
229
230
231
232
233

static inline int dname_external(struct dentry *dentry)
{
	return dentry->d_name.name != dentry->d_iname;
}

/*
 * These are the low-level FS interfaces to the dcache..
 */
extern void d_instantiate(struct dentry *, struct inode *);
extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
234
extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
Nick Piggin's avatar
Nick Piggin committed
235
236
extern void __d_drop(struct dentry *dentry);
extern void d_drop(struct dentry *dentry);
Linus Torvalds's avatar
Linus Torvalds committed
237
extern void d_delete(struct dentry *);
238
extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
Linus Torvalds's avatar
Linus Torvalds committed
239
240
241

/* allocate/de-allocate */
extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
242
extern struct dentry * d_alloc_pseudo(struct super_block *, const struct qstr *);
Linus Torvalds's avatar
Linus Torvalds committed
243
extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
244
extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
245
extern struct dentry * d_obtain_alias(struct inode *);
Linus Torvalds's avatar
Linus Torvalds committed
246
247
extern void shrink_dcache_sb(struct super_block *);
extern void shrink_dcache_parent(struct dentry *);
248
extern void shrink_dcache_for_umount(struct super_block *);
Linus Torvalds's avatar
Linus Torvalds committed
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
extern int d_invalidate(struct dentry *);

/* only used at mount-time */
extern struct dentry * d_alloc_root(struct inode *);

/* <clickety>-<click> the ramfs-type tree */
extern void d_genocide(struct dentry *);

extern struct dentry *d_find_alias(struct inode *);
extern void d_prune_aliases(struct inode *);

/* test whether we have any submounts in a subdir tree */
extern int have_submounts(struct dentry *);

/*
 * This adds the entry to the hash queues.
 */
extern void d_rehash(struct dentry *);

/**
 * d_add - add dentry to hash queues
 * @entry: dentry to add
 * @inode: The inode to attach to this dentry
 *
 * This adds the entry to the hash queues and initializes @inode.
 * The entry was actually filled in earlier during d_alloc().
 */
 
static inline void d_add(struct dentry *entry, struct inode *inode)
{
	d_instantiate(entry, inode);
	d_rehash(entry);
}

/**
 * d_add_unique - add dentry to hash queues without aliasing
 * @entry: dentry to add
 * @inode: The inode to attach to this dentry
 *
 * This adds the entry to the hash queues and initializes @inode.
 * The entry was actually filled in earlier during d_alloc().
 */
static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
{
	struct dentry *res;

	res = d_instantiate_unique(entry, inode);
	d_rehash(res != NULL ? res : entry);
	return res;
}

Nick Piggin's avatar
Nick Piggin committed
300
301
extern void dentry_update_name_case(struct dentry *, struct qstr *);

Linus Torvalds's avatar
Linus Torvalds committed
302
303
/* used for rename() and baskets */
extern void d_move(struct dentry *, struct dentry *);
304
extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
Linus Torvalds's avatar
Linus Torvalds committed
305
306

/* appendix may either be NULL or be used for transname suffixes */
Nick Piggin's avatar
Nick Piggin committed
307
308
309
310
311
312
313
314
315
316
extern struct dentry *d_lookup(struct dentry *, struct qstr *);
extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
extern struct dentry *__d_lookup(struct dentry *, struct qstr *);
extern struct dentry *__d_lookup_rcu(struct dentry *parent, struct qstr *name,
				unsigned *seq, struct inode **inode);

/**
 * __d_rcu_to_refcount - take a refcount on dentry if sequence check is ok
 * @dentry: dentry to take a ref on
 * @seq: seqcount to verify against
317
 * Returns: 0 on failure, else 1.
Nick Piggin's avatar
Nick Piggin committed
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
 *
 * __d_rcu_to_refcount operates on a dentry,seq pair that was returned
 * by __d_lookup_rcu, to get a reference on an rcu-walk dentry.
 */
static inline int __d_rcu_to_refcount(struct dentry *dentry, unsigned seq)
{
	int ret = 0;

	assert_spin_locked(&dentry->d_lock);
	if (!read_seqcount_retry(&dentry->d_seq, seq)) {
		ret = 1;
		dentry->d_count++;
	}

	return ret;
}
Linus Torvalds's avatar
Linus Torvalds committed
334
335
336
337

/* validate "insecure" dentry pointer */
extern int d_validate(struct dentry *, struct dentry *);

338
339
340
341
342
/*
 * helper function for dentry_operations.d_dname() members
 */
extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);

343
extern char *__d_path(const struct path *path, struct path *root, char *, int);
344
extern char *d_path(const struct path *, char *, int);
345
extern char *d_path_with_unreachable(const struct path *, char *, int);
Nick Piggin's avatar
Nick Piggin committed
346
extern char *dentry_path_raw(struct dentry *, char *, int);
347
extern char *dentry_path(struct dentry *, char *, int);
348

Linus Torvalds's avatar
Linus Torvalds committed
349
350
351
/* Allocation counts.. */

/**
352
 *	dget, dget_dlock -	get a reference to a dentry
Linus Torvalds's avatar
Linus Torvalds committed
353
354
355
356
 *	@dentry: dentry to get a reference to
 *
 *	Given a dentry or %NULL pointer increment the reference count
 *	if appropriate and return the dentry. A dentry will not be 
357
 *	destroyed when it has references.
Linus Torvalds's avatar
Linus Torvalds committed
358
 */
Nick Piggin's avatar
Nick Piggin committed
359
360
static inline struct dentry *dget_dlock(struct dentry *dentry)
{
361
	if (dentry)
Nick Piggin's avatar
Nick Piggin committed
362
363
364
		dentry->d_count++;
	return dentry;
}
Nick Piggin's avatar
Nick Piggin committed
365

Linus Torvalds's avatar
Linus Torvalds committed
366
367
368
static inline struct dentry *dget(struct dentry *dentry)
{
	if (dentry) {
Nick Piggin's avatar
Nick Piggin committed
369
370
371
		spin_lock(&dentry->d_lock);
		dget_dlock(dentry);
		spin_unlock(&dentry->d_lock);
Linus Torvalds's avatar
Linus Torvalds committed
372
373
374
375
	}
	return dentry;
}

Nick Piggin's avatar
Nick Piggin committed
376
extern struct dentry *dget_parent(struct dentry *dentry);
Linus Torvalds's avatar
Linus Torvalds committed
377
378
379
380
381
382
383
384
385
386

/**
 *	d_unhashed -	is dentry hashed
 *	@dentry: entry to check
 *
 *	Returns true if the dentry passed is not currently hashed.
 */
 
static inline int d_unhashed(struct dentry *dentry)
{
387
	return hlist_bl_unhashed(&dentry->d_hash);
Linus Torvalds's avatar
Linus Torvalds committed
388
389
}

390
391
392
393
394
static inline int d_unlinked(struct dentry *dentry)
{
	return d_unhashed(dentry) && !IS_ROOT(dentry);
}

395
396
397
398
399
400
401
402
403
404
405
406
static inline int cant_mount(struct dentry *dentry)
{
	return (dentry->d_flags & DCACHE_CANT_MOUNT);
}

static inline void dont_mount(struct dentry *dentry)
{
	spin_lock(&dentry->d_lock);
	dentry->d_flags |= DCACHE_CANT_MOUNT;
	spin_unlock(&dentry->d_lock);
}

Linus Torvalds's avatar
Linus Torvalds committed
407
408
extern void dput(struct dentry *);

409
410
411
412
413
414
static inline bool d_managed(struct dentry *dentry)
{
	return dentry->d_flags & DCACHE_MANAGED_DENTRY;
}

static inline bool d_mountpoint(struct dentry *dentry)
Linus Torvalds's avatar
Linus Torvalds committed
415
{
Nick Piggin's avatar
Nick Piggin committed
416
	return dentry->d_flags & DCACHE_MOUNTED;
Linus Torvalds's avatar
Linus Torvalds committed
417
418
419
420
421
422
423
}

extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);

extern int sysctl_vfs_cache_pressure;

#endif	/* __LINUX_DCACHE_H */