blob: e88c23b85a32d4456bf7741a7f218315189153e1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/dcache.c
3 *
4 * Complete reimplementation
5 * (C) 1997 Thomas Schoebel-Theuer,
6 * with heavy changes by Linus Torvalds
7 */
8
9/*
10 * Notes on the allocation strategy:
11 *
12 * The dcache is a master of the icache - whenever a dcache entry
13 * exists, the inode will always exist. "iput()" is done either when
14 * the dcache entry is deleted or garbage collected.
15 */
16
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/syscalls.h>
18#include <linux/string.h>
19#include <linux/mm.h>
Miklos Szeredi31f3e0b2008-06-23 18:11:52 +020020#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/fs.h>
John McCutchan7a91bf72005-08-08 13:52:16 -040022#include <linux/fsnotify.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/slab.h>
24#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/hash.h>
26#include <linux/cache.h>
27#include <linux/module.h>
28#include <linux/mount.h>
29#include <linux/file.h>
30#include <asm/uaccess.h>
31#include <linux/security.h>
32#include <linux/seqlock.h>
33#include <linux/swap.h>
34#include <linux/bootmem.h>
David Howells07f3f052006-09-30 20:52:18 +020035#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Eric Dumazetfa3536c2006-03-26 01:37:24 -080037int sysctl_vfs_cache_pressure __read_mostly = 100;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038EXPORT_SYMBOL_GPL(sysctl_vfs_cache_pressure);
39
40 __cacheline_aligned_in_smp DEFINE_SPINLOCK(dcache_lock);
Al Viro74c3cbe2007-07-22 08:04:18 -040041__cacheline_aligned_in_smp DEFINE_SEQLOCK(rename_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43EXPORT_SYMBOL(dcache_lock);
44
Christoph Lametere18b8902006-12-06 20:33:20 -080045static struct kmem_cache *dentry_cache __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47#define DNAME_INLINE_LEN (sizeof(struct dentry)-offsetof(struct dentry,d_iname))
48
49/*
50 * This is the single most critical data structure when it comes
51 * to the dcache: the hashtable for lookups. Somebody should try
52 * to make this good - I've just made it work.
53 *
54 * This hash-function tries to avoid losing too many bits of hash
55 * information, yet avoid using a prime hash-size or similar.
56 */
57#define D_HASHBITS d_hash_shift
58#define D_HASHMASK d_hash_mask
59
Eric Dumazetfa3536c2006-03-26 01:37:24 -080060static unsigned int d_hash_mask __read_mostly;
61static unsigned int d_hash_shift __read_mostly;
62static struct hlist_head *dentry_hashtable __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64/* Statistics gathering. */
65struct dentry_stat_t dentry_stat = {
66 .age_limit = 45,
67};
68
Eric Dumazetb3423412006-12-06 20:38:48 -080069static void __d_free(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
Arjan van de Venfd217f42008-10-21 06:47:33 -070071 WARN_ON(!list_empty(&dentry->d_alias));
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 if (dname_external(dentry))
73 kfree(dentry->d_name.name);
74 kmem_cache_free(dentry_cache, dentry);
75}
76
Eric Dumazetb3423412006-12-06 20:38:48 -080077static void d_callback(struct rcu_head *head)
78{
79 struct dentry * dentry = container_of(head, struct dentry, d_u.d_rcu);
80 __d_free(dentry);
81}
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083/*
84 * no dcache_lock, please. The caller must decrement dentry_stat.nr_dentry
85 * inside dcache_lock.
86 */
87static void d_free(struct dentry *dentry)
88{
89 if (dentry->d_op && dentry->d_op->d_release)
90 dentry->d_op->d_release(dentry);
Eric Dumazetb3423412006-12-06 20:38:48 -080091 /* if dentry was never inserted into hash, immediate free is OK */
Akinobu Mitae8462ca2008-02-06 01:37:07 -080092 if (hlist_unhashed(&dentry->d_hash))
Eric Dumazetb3423412006-12-06 20:38:48 -080093 __d_free(dentry);
94 else
95 call_rcu(&dentry->d_u.d_rcu, d_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096}
97
98/*
99 * Release the dentry's inode, using the filesystem
100 * d_iput() operation if defined.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 */
Arjan van de Ven858119e2006-01-14 13:20:43 -0800102static void dentry_iput(struct dentry * dentry)
Miklos Szeredi31f3e0b2008-06-23 18:11:52 +0200103 __releases(dentry->d_lock)
104 __releases(dcache_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105{
106 struct inode *inode = dentry->d_inode;
107 if (inode) {
108 dentry->d_inode = NULL;
109 list_del_init(&dentry->d_alias);
110 spin_unlock(&dentry->d_lock);
111 spin_unlock(&dcache_lock);
Linus Torvaldsf805fbd2005-09-19 19:54:29 -0700112 if (!inode->i_nlink)
113 fsnotify_inoderemove(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 if (dentry->d_op && dentry->d_op->d_iput)
115 dentry->d_op->d_iput(dentry, inode);
116 else
117 iput(inode);
118 } else {
119 spin_unlock(&dentry->d_lock);
120 spin_unlock(&dcache_lock);
121 }
122}
123
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700124/*
125 * dentry_lru_(add|add_tail|del|del_init) must be called with dcache_lock held.
126 */
127static void dentry_lru_add(struct dentry *dentry)
128{
129 list_add(&dentry->d_lru, &dentry->d_sb->s_dentry_lru);
130 dentry->d_sb->s_nr_dentry_unused++;
131 dentry_stat.nr_unused++;
132}
133
134static void dentry_lru_add_tail(struct dentry *dentry)
135{
136 list_add_tail(&dentry->d_lru, &dentry->d_sb->s_dentry_lru);
137 dentry->d_sb->s_nr_dentry_unused++;
138 dentry_stat.nr_unused++;
139}
140
141static void dentry_lru_del(struct dentry *dentry)
142{
143 if (!list_empty(&dentry->d_lru)) {
144 list_del(&dentry->d_lru);
145 dentry->d_sb->s_nr_dentry_unused--;
146 dentry_stat.nr_unused--;
147 }
148}
149
150static void dentry_lru_del_init(struct dentry *dentry)
151{
152 if (likely(!list_empty(&dentry->d_lru))) {
153 list_del_init(&dentry->d_lru);
154 dentry->d_sb->s_nr_dentry_unused--;
155 dentry_stat.nr_unused--;
156 }
157}
158
Miklos Szeredid52b9082007-05-08 00:23:46 -0700159/**
160 * d_kill - kill dentry and return parent
161 * @dentry: dentry to kill
162 *
Miklos Szeredi31f3e0b2008-06-23 18:11:52 +0200163 * The dentry must already be unhashed and removed from the LRU.
Miklos Szeredid52b9082007-05-08 00:23:46 -0700164 *
165 * If this is the root of the dentry tree, return NULL.
166 */
167static struct dentry *d_kill(struct dentry *dentry)
Miklos Szeredi31f3e0b2008-06-23 18:11:52 +0200168 __releases(dentry->d_lock)
169 __releases(dcache_lock)
Miklos Szeredid52b9082007-05-08 00:23:46 -0700170{
171 struct dentry *parent;
172
173 list_del(&dentry->d_u.d_child);
174 dentry_stat.nr_dentry--; /* For d_free, below */
175 /*drops the locks, at that point nobody can reach this dentry */
176 dentry_iput(dentry);
OGAWA Hirofumi871c0062008-10-16 07:50:27 +0900177 if (IS_ROOT(dentry))
178 parent = NULL;
179 else
180 parent = dentry->d_parent;
Miklos Szeredid52b9082007-05-08 00:23:46 -0700181 d_free(dentry);
OGAWA Hirofumi871c0062008-10-16 07:50:27 +0900182 return parent;
Miklos Szeredid52b9082007-05-08 00:23:46 -0700183}
184
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185/*
186 * This is dput
187 *
188 * This is complicated by the fact that we do not want to put
189 * dentries that are no longer on any hash chain on the unused
190 * list: we'd much rather just get rid of them immediately.
191 *
192 * However, that implies that we have to traverse the dentry
193 * tree upwards to the parents which might _also_ now be
194 * scheduled for deletion (it may have been only waiting for
195 * its last child to go away).
196 *
197 * This tail recursion is done by hand as we don't want to depend
198 * on the compiler to always get this right (gcc generally doesn't).
199 * Real recursion would eat up our stack space.
200 */
201
202/*
203 * dput - release a dentry
204 * @dentry: dentry to release
205 *
206 * Release a dentry. This will drop the usage count and if appropriate
207 * call the dentry unlink method as well as removing it from the queues and
208 * releasing its resources. If the parent dentries were scheduled for release
209 * they too may now get deleted.
210 *
211 * no dcache lock, please.
212 */
213
214void dput(struct dentry *dentry)
215{
216 if (!dentry)
217 return;
218
219repeat:
220 if (atomic_read(&dentry->d_count) == 1)
221 might_sleep();
222 if (!atomic_dec_and_lock(&dentry->d_count, &dcache_lock))
223 return;
224
225 spin_lock(&dentry->d_lock);
226 if (atomic_read(&dentry->d_count)) {
227 spin_unlock(&dentry->d_lock);
228 spin_unlock(&dcache_lock);
229 return;
230 }
231
232 /*
233 * AV: ->d_delete() is _NOT_ allowed to block now.
234 */
235 if (dentry->d_op && dentry->d_op->d_delete) {
236 if (dentry->d_op->d_delete(dentry))
237 goto unhash_it;
238 }
239 /* Unreachable? Get rid of it */
240 if (d_unhashed(dentry))
241 goto kill_it;
242 if (list_empty(&dentry->d_lru)) {
243 dentry->d_flags |= DCACHE_REFERENCED;
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700244 dentry_lru_add(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 }
246 spin_unlock(&dentry->d_lock);
247 spin_unlock(&dcache_lock);
248 return;
249
250unhash_it:
251 __d_drop(dentry);
Miklos Szeredid52b9082007-05-08 00:23:46 -0700252kill_it:
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700253 /* if dentry was on the d_lru list delete it from there */
254 dentry_lru_del(dentry);
Miklos Szeredid52b9082007-05-08 00:23:46 -0700255 dentry = d_kill(dentry);
256 if (dentry)
257 goto repeat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258}
259
260/**
261 * d_invalidate - invalidate a dentry
262 * @dentry: dentry to invalidate
263 *
264 * Try to invalidate the dentry if it turns out to be
265 * possible. If there are other dentries that can be
266 * reached through this one we can't delete it and we
267 * return -EBUSY. On success we return 0.
268 *
269 * no dcache lock.
270 */
271
272int d_invalidate(struct dentry * dentry)
273{
274 /*
275 * If it's already been dropped, return OK.
276 */
277 spin_lock(&dcache_lock);
278 if (d_unhashed(dentry)) {
279 spin_unlock(&dcache_lock);
280 return 0;
281 }
282 /*
283 * Check whether to do a partial shrink_dcache
284 * to get rid of unused child entries.
285 */
286 if (!list_empty(&dentry->d_subdirs)) {
287 spin_unlock(&dcache_lock);
288 shrink_dcache_parent(dentry);
289 spin_lock(&dcache_lock);
290 }
291
292 /*
293 * Somebody else still using it?
294 *
295 * If it's a directory, we can't drop it
296 * for fear of somebody re-populating it
297 * with children (even though dropping it
298 * would make it unreachable from the root,
299 * we might still populate it if it was a
300 * working directory or similar).
301 */
302 spin_lock(&dentry->d_lock);
303 if (atomic_read(&dentry->d_count) > 1) {
304 if (dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode)) {
305 spin_unlock(&dentry->d_lock);
306 spin_unlock(&dcache_lock);
307 return -EBUSY;
308 }
309 }
310
311 __d_drop(dentry);
312 spin_unlock(&dentry->d_lock);
313 spin_unlock(&dcache_lock);
314 return 0;
315}
316
317/* This should be called _only_ with dcache_lock held */
318
319static inline struct dentry * __dget_locked(struct dentry *dentry)
320{
321 atomic_inc(&dentry->d_count);
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700322 dentry_lru_del_init(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 return dentry;
324}
325
326struct dentry * dget_locked(struct dentry *dentry)
327{
328 return __dget_locked(dentry);
329}
330
331/**
332 * d_find_alias - grab a hashed alias of inode
333 * @inode: inode in question
334 * @want_discon: flag, used by d_splice_alias, to request
335 * that only a DISCONNECTED alias be returned.
336 *
337 * If inode has a hashed alias, or is a directory and has any alias,
338 * acquire the reference to alias and return it. Otherwise return NULL.
339 * Notice that if inode is a directory there can be only one alias and
340 * it can be unhashed only if it has no children, or if it is the root
341 * of a filesystem.
342 *
NeilBrown21c0d8f2006-10-04 02:16:16 -0700343 * If the inode has an IS_ROOT, DCACHE_DISCONNECTED alias, then prefer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 * any other hashed alias over that one unless @want_discon is set,
NeilBrown21c0d8f2006-10-04 02:16:16 -0700345 * in which case only return an IS_ROOT, DCACHE_DISCONNECTED alias.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 */
347
348static struct dentry * __d_find_alias(struct inode *inode, int want_discon)
349{
350 struct list_head *head, *next, *tmp;
351 struct dentry *alias, *discon_alias=NULL;
352
353 head = &inode->i_dentry;
354 next = inode->i_dentry.next;
355 while (next != head) {
356 tmp = next;
357 next = tmp->next;
358 prefetch(next);
359 alias = list_entry(tmp, struct dentry, d_alias);
360 if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) {
NeilBrown21c0d8f2006-10-04 02:16:16 -0700361 if (IS_ROOT(alias) &&
362 (alias->d_flags & DCACHE_DISCONNECTED))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 discon_alias = alias;
364 else if (!want_discon) {
365 __dget_locked(alias);
366 return alias;
367 }
368 }
369 }
370 if (discon_alias)
371 __dget_locked(discon_alias);
372 return discon_alias;
373}
374
375struct dentry * d_find_alias(struct inode *inode)
376{
David Howells214fda12006-03-25 03:06:36 -0800377 struct dentry *de = NULL;
378
379 if (!list_empty(&inode->i_dentry)) {
380 spin_lock(&dcache_lock);
381 de = __d_find_alias(inode, 0);
382 spin_unlock(&dcache_lock);
383 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 return de;
385}
386
387/*
388 * Try to kill dentries associated with this inode.
389 * WARNING: you must own a reference to inode.
390 */
391void d_prune_aliases(struct inode *inode)
392{
Domen Puncer0cdca3f2005-09-10 00:27:07 -0700393 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394restart:
395 spin_lock(&dcache_lock);
Domen Puncer0cdca3f2005-09-10 00:27:07 -0700396 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 spin_lock(&dentry->d_lock);
398 if (!atomic_read(&dentry->d_count)) {
399 __dget_locked(dentry);
400 __d_drop(dentry);
401 spin_unlock(&dentry->d_lock);
402 spin_unlock(&dcache_lock);
403 dput(dentry);
404 goto restart;
405 }
406 spin_unlock(&dentry->d_lock);
407 }
408 spin_unlock(&dcache_lock);
409}
410
411/*
Andrew Mortond702ccb2006-06-22 14:47:31 -0700412 * Throw away a dentry - free the inode, dput the parent. This requires that
413 * the LRU list has already been removed.
414 *
Miklos Szeredi85864e12007-10-16 23:27:09 -0700415 * Try to prune ancestors as well. This is necessary to prevent
416 * quadratic behavior of shrink_dcache_parent(), but is also expected
417 * to be beneficial in reducing dentry cache fragmentation.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 */
Miklos Szeredi85864e12007-10-16 23:27:09 -0700419static void prune_one_dentry(struct dentry * dentry)
Miklos Szeredi31f3e0b2008-06-23 18:11:52 +0200420 __releases(dentry->d_lock)
421 __releases(dcache_lock)
422 __acquires(dcache_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 __d_drop(dentry);
Miklos Szeredid52b9082007-05-08 00:23:46 -0700425 dentry = d_kill(dentry);
Miklos Szeredid52b9082007-05-08 00:23:46 -0700426
427 /*
428 * Prune ancestors. Locking is simpler than in dput(),
429 * because dcache_lock needs to be taken anyway.
430 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 spin_lock(&dcache_lock);
Miklos Szeredid52b9082007-05-08 00:23:46 -0700432 while (dentry) {
433 if (!atomic_dec_and_lock(&dentry->d_count, &dentry->d_lock))
434 return;
435
436 if (dentry->d_op && dentry->d_op->d_delete)
437 dentry->d_op->d_delete(dentry);
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700438 dentry_lru_del_init(dentry);
Miklos Szeredid52b9082007-05-08 00:23:46 -0700439 __d_drop(dentry);
440 dentry = d_kill(dentry);
441 spin_lock(&dcache_lock);
442 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443}
444
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700445/*
446 * Shrink the dentry LRU on a given superblock.
447 * @sb : superblock to shrink dentry LRU.
448 * @count: If count is NULL, we prune all dentries on superblock.
449 * @flags: If flags is non-zero, we need to do special processing based on
450 * which flags are set. This means we don't need to maintain multiple
451 * similar copies of this loop.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 */
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700453static void __shrink_dcache_sb(struct super_block *sb, int *count, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454{
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700455 LIST_HEAD(referenced);
456 LIST_HEAD(tmp);
457 struct dentry *dentry;
458 int cnt = 0;
459
460 BUG_ON(!sb);
461 BUG_ON((flags & DCACHE_REFERENCED) && count == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 spin_lock(&dcache_lock);
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700463 if (count != NULL)
464 /* called from prune_dcache() and shrink_dcache_parent() */
465 cnt = *count;
466restart:
467 if (count == NULL)
468 list_splice_init(&sb->s_dentry_lru, &tmp);
469 else {
470 while (!list_empty(&sb->s_dentry_lru)) {
471 dentry = list_entry(sb->s_dentry_lru.prev,
472 struct dentry, d_lru);
473 BUG_ON(dentry->d_sb != sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700475 spin_lock(&dentry->d_lock);
476 /*
477 * If we are honouring the DCACHE_REFERENCED flag and
478 * the dentry has this flag set, don't free it. Clear
479 * the flag and put it back on the LRU.
NeilBrown0feae5c2006-06-22 14:47:28 -0700480 */
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700481 if ((flags & DCACHE_REFERENCED)
482 && (dentry->d_flags & DCACHE_REFERENCED)) {
483 dentry->d_flags &= ~DCACHE_REFERENCED;
484 list_move_tail(&dentry->d_lru, &referenced);
485 spin_unlock(&dentry->d_lock);
486 } else {
487 list_move_tail(&dentry->d_lru, &tmp);
488 spin_unlock(&dentry->d_lock);
489 cnt--;
490 if (!cnt)
491 break;
NeilBrown0feae5c2006-06-22 14:47:28 -0700492 }
Kentaro Makitaf3c6ba92008-07-25 19:44:40 -0700493 cond_resched_lock(&dcache_lock);
NeilBrown0feae5c2006-06-22 14:47:28 -0700494 }
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700495 }
496 while (!list_empty(&tmp)) {
497 dentry = list_entry(tmp.prev, struct dentry, d_lru);
498 dentry_lru_del_init(dentry);
499 spin_lock(&dentry->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 /*
501 * We found an inuse dentry which was not removed from
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700502 * the LRU because of laziness during lookup. Do not free
503 * it - just keep it off the LRU list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 */
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700505 if (atomic_read(&dentry->d_count)) {
506 spin_unlock(&dentry->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 continue;
508 }
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700509 prune_one_dentry(dentry);
510 /* dentry->d_lock was dropped in prune_one_dentry() */
511 cond_resched_lock(&dcache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 }
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700513 if (count == NULL && !list_empty(&sb->s_dentry_lru))
514 goto restart;
515 if (count != NULL)
516 *count = cnt;
517 if (!list_empty(&referenced))
518 list_splice(&referenced, &sb->s_dentry_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 spin_unlock(&dcache_lock);
520}
521
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700522/**
523 * prune_dcache - shrink the dcache
524 * @count: number of entries to try to free
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 *
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700526 * Shrink the dcache. This is done when we need more memory, or simply when we
527 * need to unmount something (at which point we need to unuse all dentries).
528 *
529 * This function may fail to free any resources if all the dentries are in use.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 */
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700531static void prune_dcache(int count)
532{
533 struct super_block *sb;
534 int w_count;
535 int unused = dentry_stat.nr_unused;
536 int prune_ratio;
537 int pruned;
538
539 if (unused == 0 || count == 0)
540 return;
541 spin_lock(&dcache_lock);
542restart:
543 if (count >= unused)
544 prune_ratio = 1;
545 else
546 prune_ratio = unused / count;
547 spin_lock(&sb_lock);
548 list_for_each_entry(sb, &super_blocks, s_list) {
549 if (sb->s_nr_dentry_unused == 0)
550 continue;
551 sb->s_count++;
552 /* Now, we reclaim unused dentrins with fairness.
553 * We reclaim them same percentage from each superblock.
554 * We calculate number of dentries to scan on this sb
555 * as follows, but the implementation is arranged to avoid
556 * overflows:
557 * number of dentries to scan on this sb =
558 * count * (number of dentries on this sb /
559 * number of dentries in the machine)
560 */
561 spin_unlock(&sb_lock);
562 if (prune_ratio != 1)
563 w_count = (sb->s_nr_dentry_unused / prune_ratio) + 1;
564 else
565 w_count = sb->s_nr_dentry_unused;
566 pruned = w_count;
567 /*
568 * We need to be sure this filesystem isn't being unmounted,
569 * otherwise we could race with generic_shutdown_super(), and
570 * end up holding a reference to an inode while the filesystem
571 * is unmounted. So we try to get s_umount, and make sure
572 * s_root isn't NULL.
573 */
574 if (down_read_trylock(&sb->s_umount)) {
575 if ((sb->s_root != NULL) &&
576 (!list_empty(&sb->s_dentry_lru))) {
577 spin_unlock(&dcache_lock);
578 __shrink_dcache_sb(sb, &w_count,
579 DCACHE_REFERENCED);
580 pruned -= w_count;
581 spin_lock(&dcache_lock);
582 }
583 up_read(&sb->s_umount);
584 }
585 spin_lock(&sb_lock);
586 count -= pruned;
587 /*
588 * restart only when sb is no longer on the list and
589 * we have more work to do.
590 */
591 if (__put_super_and_need_restart(sb) && count > 0) {
592 spin_unlock(&sb_lock);
593 goto restart;
594 }
595 }
596 spin_unlock(&sb_lock);
597 spin_unlock(&dcache_lock);
598}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
600/**
601 * shrink_dcache_sb - shrink dcache for a superblock
602 * @sb: superblock
603 *
604 * Shrink the dcache for the specified super block. This
605 * is used to free the dcache before unmounting a file
606 * system
607 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608void shrink_dcache_sb(struct super_block * sb)
609{
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700610 __shrink_dcache_sb(sb, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611}
612
613/*
David Howellsc636ebd2006-10-11 01:22:19 -0700614 * destroy a single subtree of dentries for unmount
615 * - see the comments on shrink_dcache_for_umount() for a description of the
616 * locking
617 */
618static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
619{
620 struct dentry *parent;
David Howellsf8713572006-10-28 10:38:46 -0700621 unsigned detached = 0;
David Howellsc636ebd2006-10-11 01:22:19 -0700622
623 BUG_ON(!IS_ROOT(dentry));
624
625 /* detach this root from the system */
626 spin_lock(&dcache_lock);
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700627 dentry_lru_del_init(dentry);
David Howellsc636ebd2006-10-11 01:22:19 -0700628 __d_drop(dentry);
629 spin_unlock(&dcache_lock);
630
631 for (;;) {
632 /* descend to the first leaf in the current subtree */
633 while (!list_empty(&dentry->d_subdirs)) {
634 struct dentry *loop;
635
636 /* this is a branch with children - detach all of them
637 * from the system in one go */
638 spin_lock(&dcache_lock);
639 list_for_each_entry(loop, &dentry->d_subdirs,
640 d_u.d_child) {
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700641 dentry_lru_del_init(loop);
David Howellsc636ebd2006-10-11 01:22:19 -0700642 __d_drop(loop);
643 cond_resched_lock(&dcache_lock);
644 }
645 spin_unlock(&dcache_lock);
646
647 /* move to the first child */
648 dentry = list_entry(dentry->d_subdirs.next,
649 struct dentry, d_u.d_child);
650 }
651
652 /* consume the dentries from this leaf up through its parents
653 * until we find one with children or run out altogether */
654 do {
655 struct inode *inode;
656
657 if (atomic_read(&dentry->d_count) != 0) {
658 printk(KERN_ERR
659 "BUG: Dentry %p{i=%lx,n=%s}"
660 " still in use (%d)"
661 " [unmount of %s %s]\n",
662 dentry,
663 dentry->d_inode ?
664 dentry->d_inode->i_ino : 0UL,
665 dentry->d_name.name,
666 atomic_read(&dentry->d_count),
667 dentry->d_sb->s_type->name,
668 dentry->d_sb->s_id);
669 BUG();
670 }
671
OGAWA Hirofumi871c0062008-10-16 07:50:27 +0900672 if (IS_ROOT(dentry))
David Howellsc636ebd2006-10-11 01:22:19 -0700673 parent = NULL;
OGAWA Hirofumi871c0062008-10-16 07:50:27 +0900674 else {
675 parent = dentry->d_parent;
David Howellsc636ebd2006-10-11 01:22:19 -0700676 atomic_dec(&parent->d_count);
OGAWA Hirofumi871c0062008-10-16 07:50:27 +0900677 }
David Howellsc636ebd2006-10-11 01:22:19 -0700678
679 list_del(&dentry->d_u.d_child);
David Howellsf8713572006-10-28 10:38:46 -0700680 detached++;
David Howellsc636ebd2006-10-11 01:22:19 -0700681
682 inode = dentry->d_inode;
683 if (inode) {
684 dentry->d_inode = NULL;
685 list_del_init(&dentry->d_alias);
686 if (dentry->d_op && dentry->d_op->d_iput)
687 dentry->d_op->d_iput(dentry, inode);
688 else
689 iput(inode);
690 }
691
692 d_free(dentry);
693
694 /* finished when we fall off the top of the tree,
695 * otherwise we ascend to the parent and move to the
696 * next sibling if there is one */
697 if (!parent)
David Howellsf8713572006-10-28 10:38:46 -0700698 goto out;
David Howellsc636ebd2006-10-11 01:22:19 -0700699
700 dentry = parent;
701
702 } while (list_empty(&dentry->d_subdirs));
703
704 dentry = list_entry(dentry->d_subdirs.next,
705 struct dentry, d_u.d_child);
706 }
David Howellsf8713572006-10-28 10:38:46 -0700707out:
708 /* several dentries were freed, need to correct nr_dentry */
709 spin_lock(&dcache_lock);
710 dentry_stat.nr_dentry -= detached;
711 spin_unlock(&dcache_lock);
David Howellsc636ebd2006-10-11 01:22:19 -0700712}
713
714/*
715 * destroy the dentries attached to a superblock on unmounting
716 * - we don't need to use dentry->d_lock, and only need dcache_lock when
717 * removing the dentry from the system lists and hashes because:
718 * - the superblock is detached from all mountings and open files, so the
719 * dentry trees will not be rearranged by the VFS
720 * - s_umount is write-locked, so the memory pressure shrinker will ignore
721 * any dentries belonging to this superblock that it comes across
722 * - the filesystem itself is no longer permitted to rearrange the dentries
723 * in this superblock
724 */
725void shrink_dcache_for_umount(struct super_block *sb)
726{
727 struct dentry *dentry;
728
729 if (down_read_trylock(&sb->s_umount))
730 BUG();
731
732 dentry = sb->s_root;
733 sb->s_root = NULL;
734 atomic_dec(&dentry->d_count);
735 shrink_dcache_for_umount_subtree(dentry);
736
737 while (!hlist_empty(&sb->s_anon)) {
738 dentry = hlist_entry(sb->s_anon.first, struct dentry, d_hash);
739 shrink_dcache_for_umount_subtree(dentry);
740 }
741}
742
743/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 * Search for at least 1 mount point in the dentry's subdirs.
745 * We descend to the next level whenever the d_subdirs
746 * list is non-empty and continue searching.
747 */
748
749/**
750 * have_submounts - check for mounts over a dentry
751 * @parent: dentry to check.
752 *
753 * Return true if the parent or its subdirectories contain
754 * a mount point
755 */
756
757int have_submounts(struct dentry *parent)
758{
759 struct dentry *this_parent = parent;
760 struct list_head *next;
761
762 spin_lock(&dcache_lock);
763 if (d_mountpoint(parent))
764 goto positive;
765repeat:
766 next = this_parent->d_subdirs.next;
767resume:
768 while (next != &this_parent->d_subdirs) {
769 struct list_head *tmp = next;
Eric Dumazet5160ee62006-01-08 01:03:32 -0800770 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 next = tmp->next;
772 /* Have we found a mount point ? */
773 if (d_mountpoint(dentry))
774 goto positive;
775 if (!list_empty(&dentry->d_subdirs)) {
776 this_parent = dentry;
777 goto repeat;
778 }
779 }
780 /*
781 * All done at this level ... ascend and resume the search.
782 */
783 if (this_parent != parent) {
Eric Dumazet5160ee62006-01-08 01:03:32 -0800784 next = this_parent->d_u.d_child.next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 this_parent = this_parent->d_parent;
786 goto resume;
787 }
788 spin_unlock(&dcache_lock);
789 return 0; /* No mount points found in tree */
790positive:
791 spin_unlock(&dcache_lock);
792 return 1;
793}
794
795/*
796 * Search the dentry child list for the specified parent,
797 * and move any unused dentries to the end of the unused
798 * list for prune_dcache(). We descend to the next level
799 * whenever the d_subdirs list is non-empty and continue
800 * searching.
801 *
802 * It returns zero iff there are no unused children,
803 * otherwise it returns the number of children moved to
804 * the end of the unused list. This may not be the total
805 * number of unused children, because select_parent can
806 * drop the lock and return early due to latency
807 * constraints.
808 */
809static int select_parent(struct dentry * parent)
810{
811 struct dentry *this_parent = parent;
812 struct list_head *next;
813 int found = 0;
814
815 spin_lock(&dcache_lock);
816repeat:
817 next = this_parent->d_subdirs.next;
818resume:
819 while (next != &this_parent->d_subdirs) {
820 struct list_head *tmp = next;
Eric Dumazet5160ee62006-01-08 01:03:32 -0800821 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 next = tmp->next;
823
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700824 dentry_lru_del_init(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 /*
826 * move only zero ref count dentries to the end
827 * of the unused list for prune_dcache
828 */
829 if (!atomic_read(&dentry->d_count)) {
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700830 dentry_lru_add_tail(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 found++;
832 }
833
834 /*
835 * We can return to the caller if we have found some (this
836 * ensures forward progress). We'll be coming back to find
837 * the rest.
838 */
839 if (found && need_resched())
840 goto out;
841
842 /*
843 * Descend a level if the d_subdirs list is non-empty.
844 */
845 if (!list_empty(&dentry->d_subdirs)) {
846 this_parent = dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 goto repeat;
848 }
849 }
850 /*
851 * All done at this level ... ascend and resume the search.
852 */
853 if (this_parent != parent) {
Eric Dumazet5160ee62006-01-08 01:03:32 -0800854 next = this_parent->d_u.d_child.next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 this_parent = this_parent->d_parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 goto resume;
857 }
858out:
859 spin_unlock(&dcache_lock);
860 return found;
861}
862
863/**
864 * shrink_dcache_parent - prune dcache
865 * @parent: parent of entries to prune
866 *
867 * Prune the dcache to remove unused children of the parent dentry.
868 */
869
870void shrink_dcache_parent(struct dentry * parent)
871{
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700872 struct super_block *sb = parent->d_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 int found;
874
875 while ((found = select_parent(parent)) != 0)
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700876 __shrink_dcache_sb(sb, &found, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877}
878
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879/*
880 * Scan `nr' dentries and return the number which remain.
881 *
882 * We need to avoid reentering the filesystem if the caller is performing a
883 * GFP_NOFS allocation attempt. One example deadlock is:
884 *
885 * ext2_new_block->getblk->GFP->shrink_dcache_memory->prune_dcache->
886 * prune_one_dentry->dput->dentry_iput->iput->inode->i_sb->s_op->put_inode->
887 * ext2_discard_prealloc->ext2_free_blocks->lock_super->DEADLOCK.
888 *
889 * In this case we return -1 to tell the caller that we baled.
890 */
Al Viro27496a82005-10-21 03:20:48 -0400891static int shrink_dcache_memory(int nr, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892{
893 if (nr) {
894 if (!(gfp_mask & __GFP_FS))
895 return -1;
Kentaro Makitada3bbdd2008-07-23 21:27:13 -0700896 prune_dcache(nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 }
898 return (dentry_stat.nr_unused / 100) * sysctl_vfs_cache_pressure;
899}
900
Rusty Russell8e1f9362007-07-17 04:03:17 -0700901static struct shrinker dcache_shrinker = {
902 .shrink = shrink_dcache_memory,
903 .seeks = DEFAULT_SEEKS,
904};
905
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906/**
907 * d_alloc - allocate a dcache entry
908 * @parent: parent of entry to allocate
909 * @name: qstr of the name
910 *
911 * Allocates a dentry. It returns %NULL if there is insufficient memory
912 * available. On a success the dentry is returned. The name passed in is
913 * copied and the copy passed in may be reused after this call.
914 */
915
916struct dentry *d_alloc(struct dentry * parent, const struct qstr *name)
917{
918 struct dentry *dentry;
919 char *dname;
920
Mel Gormane12ba742007-10-16 01:25:52 -0700921 dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 if (!dentry)
923 return NULL;
924
925 if (name->len > DNAME_INLINE_LEN-1) {
926 dname = kmalloc(name->len + 1, GFP_KERNEL);
927 if (!dname) {
928 kmem_cache_free(dentry_cache, dentry);
929 return NULL;
930 }
931 } else {
932 dname = dentry->d_iname;
933 }
934 dentry->d_name.name = dname;
935
936 dentry->d_name.len = name->len;
937 dentry->d_name.hash = name->hash;
938 memcpy(dname, name->name, name->len);
939 dname[name->len] = 0;
940
941 atomic_set(&dentry->d_count, 1);
942 dentry->d_flags = DCACHE_UNHASHED;
943 spin_lock_init(&dentry->d_lock);
944 dentry->d_inode = NULL;
945 dentry->d_parent = NULL;
946 dentry->d_sb = NULL;
947 dentry->d_op = NULL;
948 dentry->d_fsdata = NULL;
949 dentry->d_mounted = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 INIT_HLIST_NODE(&dentry->d_hash);
951 INIT_LIST_HEAD(&dentry->d_lru);
952 INIT_LIST_HEAD(&dentry->d_subdirs);
953 INIT_LIST_HEAD(&dentry->d_alias);
954
955 if (parent) {
956 dentry->d_parent = dget(parent);
957 dentry->d_sb = parent->d_sb;
958 } else {
Eric Dumazet5160ee62006-01-08 01:03:32 -0800959 INIT_LIST_HEAD(&dentry->d_u.d_child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 }
961
962 spin_lock(&dcache_lock);
963 if (parent)
Eric Dumazet5160ee62006-01-08 01:03:32 -0800964 list_add(&dentry->d_u.d_child, &parent->d_subdirs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 dentry_stat.nr_dentry++;
966 spin_unlock(&dcache_lock);
967
968 return dentry;
969}
970
971struct dentry *d_alloc_name(struct dentry *parent, const char *name)
972{
973 struct qstr q;
974
975 q.name = name;
976 q.len = strlen(name);
977 q.hash = full_name_hash(q.name, q.len);
978 return d_alloc(parent, &q);
979}
980
OGAWA Hirofumi360da902008-10-16 07:50:28 +0900981/* the caller must hold dcache_lock */
982static void __d_instantiate(struct dentry *dentry, struct inode *inode)
983{
984 if (inode)
985 list_add(&dentry->d_alias, &inode->i_dentry);
986 dentry->d_inode = inode;
987 fsnotify_d_instantiate(dentry, inode);
988}
989
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990/**
991 * d_instantiate - fill in inode information for a dentry
992 * @entry: dentry to complete
993 * @inode: inode to attach to this dentry
994 *
995 * Fill in inode information in the entry.
996 *
997 * This turns negative dentries into productive full members
998 * of society.
999 *
1000 * NOTE! This assumes that the inode count has been incremented
1001 * (or otherwise set) by the caller to indicate that it is now
1002 * in use by the dcache.
1003 */
1004
1005void d_instantiate(struct dentry *entry, struct inode * inode)
1006{
Eric Sesterhenn28133c72006-03-26 18:25:39 +02001007 BUG_ON(!list_empty(&entry->d_alias));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 spin_lock(&dcache_lock);
OGAWA Hirofumi360da902008-10-16 07:50:28 +09001009 __d_instantiate(entry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 spin_unlock(&dcache_lock);
1011 security_d_instantiate(entry, inode);
1012}
1013
1014/**
1015 * d_instantiate_unique - instantiate a non-aliased dentry
1016 * @entry: dentry to instantiate
1017 * @inode: inode to attach to this dentry
1018 *
1019 * Fill in inode information in the entry. On success, it returns NULL.
1020 * If an unhashed alias of "entry" already exists, then we return the
Oleg Drokine866cfa2006-01-09 20:52:51 -08001021 * aliased dentry instead and drop one reference to inode.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 *
1023 * Note that in order to avoid conflicts with rename() etc, the caller
1024 * had better be holding the parent directory semaphore.
Oleg Drokine866cfa2006-01-09 20:52:51 -08001025 *
1026 * This also assumes that the inode count has been incremented
1027 * (or otherwise set) by the caller to indicate that it is now
1028 * in use by the dcache.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 */
David Howells770bfad2006-08-22 20:06:07 -04001030static struct dentry *__d_instantiate_unique(struct dentry *entry,
1031 struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032{
1033 struct dentry *alias;
1034 int len = entry->d_name.len;
1035 const char *name = entry->d_name.name;
1036 unsigned int hash = entry->d_name.hash;
1037
David Howells770bfad2006-08-22 20:06:07 -04001038 if (!inode) {
OGAWA Hirofumi360da902008-10-16 07:50:28 +09001039 __d_instantiate(entry, NULL);
David Howells770bfad2006-08-22 20:06:07 -04001040 return NULL;
1041 }
1042
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 list_for_each_entry(alias, &inode->i_dentry, d_alias) {
1044 struct qstr *qstr = &alias->d_name;
1045
1046 if (qstr->hash != hash)
1047 continue;
1048 if (alias->d_parent != entry->d_parent)
1049 continue;
1050 if (qstr->len != len)
1051 continue;
1052 if (memcmp(qstr->name, name, len))
1053 continue;
1054 dget_locked(alias);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 return alias;
1056 }
David Howells770bfad2006-08-22 20:06:07 -04001057
OGAWA Hirofumi360da902008-10-16 07:50:28 +09001058 __d_instantiate(entry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 return NULL;
1060}
David Howells770bfad2006-08-22 20:06:07 -04001061
1062struct dentry *d_instantiate_unique(struct dentry *entry, struct inode *inode)
1063{
1064 struct dentry *result;
1065
1066 BUG_ON(!list_empty(&entry->d_alias));
1067
1068 spin_lock(&dcache_lock);
1069 result = __d_instantiate_unique(entry, inode);
1070 spin_unlock(&dcache_lock);
1071
1072 if (!result) {
1073 security_d_instantiate(entry, inode);
1074 return NULL;
1075 }
1076
1077 BUG_ON(!d_unhashed(result));
1078 iput(inode);
1079 return result;
1080}
1081
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082EXPORT_SYMBOL(d_instantiate_unique);
1083
1084/**
1085 * d_alloc_root - allocate root dentry
1086 * @root_inode: inode to allocate the root for
1087 *
1088 * Allocate a root ("/") dentry for the inode given. The inode is
1089 * instantiated and returned. %NULL is returned if there is insufficient
1090 * memory or the inode passed is %NULL.
1091 */
1092
1093struct dentry * d_alloc_root(struct inode * root_inode)
1094{
1095 struct dentry *res = NULL;
1096
1097 if (root_inode) {
1098 static const struct qstr name = { .name = "/", .len = 1 };
1099
1100 res = d_alloc(NULL, &name);
1101 if (res) {
1102 res->d_sb = root_inode->i_sb;
1103 res->d_parent = res;
1104 d_instantiate(res, root_inode);
1105 }
1106 }
1107 return res;
1108}
1109
1110static inline struct hlist_head *d_hash(struct dentry *parent,
1111 unsigned long hash)
1112{
1113 hash += ((unsigned long) parent ^ GOLDEN_RATIO_PRIME) / L1_CACHE_BYTES;
1114 hash = hash ^ ((hash ^ GOLDEN_RATIO_PRIME) >> D_HASHBITS);
1115 return dentry_hashtable + (hash & D_HASHMASK);
1116}
1117
1118/**
Christoph Hellwig4ea3ada2008-08-11 15:48:57 +02001119 * d_obtain_alias - find or allocate a dentry for a given inode
1120 * @inode: inode to allocate the dentry for
1121 *
1122 * Obtain a dentry for an inode resulting from NFS filehandle conversion or
1123 * similar open by handle operations. The returned dentry may be anonymous,
1124 * or may have a full name (if the inode was already in the cache).
1125 *
1126 * When called on a directory inode, we must ensure that the inode only ever
1127 * has one dentry. If a dentry is found, that is returned instead of
1128 * allocating a new one.
1129 *
1130 * On successful return, the reference to the inode has been transferred
Christoph Hellwig44003722008-08-11 15:49:04 +02001131 * to the dentry. In case of an error the reference on the inode is released.
1132 * To make it easier to use in export operations a %NULL or IS_ERR inode may
1133 * be passed in and will be the error will be propagate to the return value,
1134 * with a %NULL @inode replaced by ERR_PTR(-ESTALE).
Christoph Hellwig4ea3ada2008-08-11 15:48:57 +02001135 */
1136struct dentry *d_obtain_alias(struct inode *inode)
1137{
Christoph Hellwig9308a612008-08-11 15:49:12 +02001138 static const struct qstr anonstring = { .name = "" };
1139 struct dentry *tmp;
1140 struct dentry *res;
Christoph Hellwig4ea3ada2008-08-11 15:48:57 +02001141
1142 if (!inode)
Christoph Hellwig44003722008-08-11 15:49:04 +02001143 return ERR_PTR(-ESTALE);
Christoph Hellwig4ea3ada2008-08-11 15:48:57 +02001144 if (IS_ERR(inode))
1145 return ERR_CAST(inode);
1146
Christoph Hellwig9308a612008-08-11 15:49:12 +02001147 res = d_find_alias(inode);
1148 if (res)
1149 goto out_iput;
1150
1151 tmp = d_alloc(NULL, &anonstring);
1152 if (!tmp) {
1153 res = ERR_PTR(-ENOMEM);
1154 goto out_iput;
Christoph Hellwig4ea3ada2008-08-11 15:48:57 +02001155 }
Christoph Hellwig9308a612008-08-11 15:49:12 +02001156 tmp->d_parent = tmp; /* make sure dput doesn't croak */
1157
1158 spin_lock(&dcache_lock);
1159 res = __d_find_alias(inode, 0);
1160 if (res) {
1161 spin_unlock(&dcache_lock);
1162 dput(tmp);
1163 goto out_iput;
1164 }
1165
1166 /* attach a disconnected dentry */
1167 spin_lock(&tmp->d_lock);
1168 tmp->d_sb = inode->i_sb;
1169 tmp->d_inode = inode;
1170 tmp->d_flags |= DCACHE_DISCONNECTED;
1171 tmp->d_flags &= ~DCACHE_UNHASHED;
1172 list_add(&tmp->d_alias, &inode->i_dentry);
1173 hlist_add_head(&tmp->d_hash, &inode->i_sb->s_anon);
1174 spin_unlock(&tmp->d_lock);
1175
1176 spin_unlock(&dcache_lock);
1177 return tmp;
1178
1179 out_iput:
1180 iput(inode);
1181 return res;
Christoph Hellwig4ea3ada2008-08-11 15:48:57 +02001182}
1183EXPORT_SYMBOL_GPL(d_obtain_alias);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
1185/**
1186 * d_splice_alias - splice a disconnected dentry into the tree if one exists
1187 * @inode: the inode which may have a disconnected dentry
1188 * @dentry: a negative dentry which we want to point to the inode.
1189 *
1190 * If inode is a directory and has a 'disconnected' dentry (i.e. IS_ROOT and
1191 * DCACHE_DISCONNECTED), then d_move that in place of the given dentry
1192 * and return it, else simply d_add the inode to the dentry and return NULL.
1193 *
1194 * This is needed in the lookup routine of any filesystem that is exportable
1195 * (via knfsd) so that we can build dcache paths to directories effectively.
1196 *
1197 * If a dentry was found and moved, then it is returned. Otherwise NULL
1198 * is returned. This matches the expected return value of ->lookup.
1199 *
1200 */
1201struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
1202{
1203 struct dentry *new = NULL;
1204
NeilBrown21c0d8f2006-10-04 02:16:16 -07001205 if (inode && S_ISDIR(inode->i_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 spin_lock(&dcache_lock);
1207 new = __d_find_alias(inode, 1);
1208 if (new) {
1209 BUG_ON(!(new->d_flags & DCACHE_DISCONNECTED));
1210 spin_unlock(&dcache_lock);
1211 security_d_instantiate(new, inode);
1212 d_rehash(dentry);
1213 d_move(new, dentry);
1214 iput(inode);
1215 } else {
OGAWA Hirofumi360da902008-10-16 07:50:28 +09001216 /* already taking dcache_lock, so d_add() by hand */
1217 __d_instantiate(dentry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 spin_unlock(&dcache_lock);
1219 security_d_instantiate(dentry, inode);
1220 d_rehash(dentry);
1221 }
1222 } else
1223 d_add(dentry, inode);
1224 return new;
1225}
1226
Barry Naujok94035402008-05-21 16:50:46 +10001227/**
1228 * d_add_ci - lookup or allocate new dentry with case-exact name
1229 * @inode: the inode case-insensitive lookup has found
1230 * @dentry: the negative dentry that was passed to the parent's lookup func
1231 * @name: the case-exact name to be associated with the returned dentry
1232 *
1233 * This is to avoid filling the dcache with case-insensitive names to the
1234 * same inode, only the actual correct case is stored in the dcache for
1235 * case-insensitive filesystems.
1236 *
1237 * For a case-insensitive lookup match and if the the case-exact dentry
1238 * already exists in in the dcache, use it and return it.
1239 *
1240 * If no entry exists with the exact case name, allocate new dentry with
1241 * the exact case, and return the spliced entry.
1242 */
Christoph Hellwige45b5902008-08-07 23:49:07 +02001243struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
Barry Naujok94035402008-05-21 16:50:46 +10001244 struct qstr *name)
1245{
1246 int error;
1247 struct dentry *found;
1248 struct dentry *new;
1249
1250 /* Does a dentry matching the name exist already? */
1251 found = d_hash_and_lookup(dentry->d_parent, name);
1252 /* If not, create it now and return */
1253 if (!found) {
1254 new = d_alloc(dentry->d_parent, name);
1255 if (!new) {
1256 error = -ENOMEM;
1257 goto err_out;
1258 }
1259 found = d_splice_alias(inode, new);
1260 if (found) {
1261 dput(new);
1262 return found;
1263 }
1264 return new;
1265 }
1266 /* Matching dentry exists, check if it is negative. */
1267 if (found->d_inode) {
1268 if (unlikely(found->d_inode != inode)) {
1269 /* This can't happen because bad inodes are unhashed. */
1270 BUG_ON(!is_bad_inode(inode));
1271 BUG_ON(!is_bad_inode(found->d_inode));
1272 }
1273 /*
1274 * Already have the inode and the dentry attached, decrement
1275 * the reference count to balance the iget() done
1276 * earlier on. We found the dentry using d_lookup() so it
1277 * cannot be disconnected and thus we do not need to worry
1278 * about any NFS/disconnectedness issues here.
1279 */
1280 iput(inode);
1281 return found;
1282 }
1283 /*
1284 * Negative dentry: instantiate it unless the inode is a directory and
1285 * has a 'disconnected' dentry (i.e. IS_ROOT and DCACHE_DISCONNECTED),
1286 * in which case d_move() that in place of the found dentry.
1287 */
1288 if (!S_ISDIR(inode->i_mode)) {
1289 /* Not a directory; everything is easy. */
1290 d_instantiate(found, inode);
1291 return found;
1292 }
1293 spin_lock(&dcache_lock);
1294 if (list_empty(&inode->i_dentry)) {
1295 /*
1296 * Directory without a 'disconnected' dentry; we need to do
1297 * d_instantiate() by hand because it takes dcache_lock which
1298 * we already hold.
1299 */
OGAWA Hirofumi360da902008-10-16 07:50:28 +09001300 __d_instantiate(found, inode);
Barry Naujok94035402008-05-21 16:50:46 +10001301 spin_unlock(&dcache_lock);
1302 security_d_instantiate(found, inode);
1303 return found;
1304 }
1305 /*
1306 * Directory with a 'disconnected' dentry; get a reference to the
1307 * 'disconnected' dentry.
1308 */
1309 new = list_entry(inode->i_dentry.next, struct dentry, d_alias);
1310 dget_locked(new);
1311 spin_unlock(&dcache_lock);
1312 /* Do security vodoo. */
1313 security_d_instantiate(found, inode);
1314 /* Move new in place of found. */
1315 d_move(new, found);
1316 /* Balance the iget() we did above. */
1317 iput(inode);
1318 /* Throw away found. */
1319 dput(found);
1320 /* Use new as the actual dentry. */
1321 return new;
1322
1323err_out:
1324 iput(inode);
1325 return ERR_PTR(error);
1326}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327
1328/**
1329 * d_lookup - search for a dentry
1330 * @parent: parent dentry
1331 * @name: qstr of name we wish to find
1332 *
1333 * Searches the children of the parent dentry for the name in question. If
1334 * the dentry is found its reference count is incremented and the dentry
Zhaoleibe42c4c2008-12-01 14:34:58 -08001335 * is returned. The caller must use dput to free the entry when it has
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 * finished using it. %NULL is returned on failure.
1337 *
1338 * __d_lookup is dcache_lock free. The hash list is protected using RCU.
1339 * Memory barriers are used while updating and doing lockless traversal.
1340 * To avoid races with d_move while rename is happening, d_lock is used.
1341 *
1342 * Overflows in memcmp(), while d_move, are avoided by keeping the length
1343 * and name pointer in one structure pointed by d_qstr.
1344 *
1345 * rcu_read_lock() and rcu_read_unlock() are used to disable preemption while
1346 * lookup is going on.
1347 *
Kentaro Makitada3bbdd2008-07-23 21:27:13 -07001348 * The dentry unused LRU is not updated even if lookup finds the required dentry
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 * in there. It is updated in places such as prune_dcache, shrink_dcache_sb,
1350 * select_parent and __dget_locked. This laziness saves lookup from dcache_lock
1351 * acquisition.
1352 *
1353 * d_lookup() is protected against the concurrent renames in some unrelated
1354 * directory using the seqlockt_t rename_lock.
1355 */
1356
1357struct dentry * d_lookup(struct dentry * parent, struct qstr * name)
1358{
1359 struct dentry * dentry = NULL;
1360 unsigned long seq;
1361
1362 do {
1363 seq = read_seqbegin(&rename_lock);
1364 dentry = __d_lookup(parent, name);
1365 if (dentry)
1366 break;
1367 } while (read_seqretry(&rename_lock, seq));
1368 return dentry;
1369}
1370
1371struct dentry * __d_lookup(struct dentry * parent, struct qstr * name)
1372{
1373 unsigned int len = name->len;
1374 unsigned int hash = name->hash;
1375 const unsigned char *str = name->name;
1376 struct hlist_head *head = d_hash(parent,hash);
1377 struct dentry *found = NULL;
1378 struct hlist_node *node;
Paul E. McKenney665a7582005-11-07 00:59:17 -08001379 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380
1381 rcu_read_lock();
1382
Paul E. McKenney665a7582005-11-07 00:59:17 -08001383 hlist_for_each_entry_rcu(dentry, node, head, d_hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 struct qstr *qstr;
1385
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 if (dentry->d_name.hash != hash)
1387 continue;
1388 if (dentry->d_parent != parent)
1389 continue;
1390
1391 spin_lock(&dentry->d_lock);
1392
1393 /*
1394 * Recheck the dentry after taking the lock - d_move may have
1395 * changed things. Don't bother checking the hash because we're
1396 * about to compare the whole name anyway.
1397 */
1398 if (dentry->d_parent != parent)
1399 goto next;
1400
Linus Torvaldsd0185c02008-09-29 07:42:57 -07001401 /* non-existing due to RCU? */
1402 if (d_unhashed(dentry))
1403 goto next;
1404
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 /*
1406 * It is safe to compare names since d_move() cannot
1407 * change the qstr (protected by d_lock).
1408 */
1409 qstr = &dentry->d_name;
1410 if (parent->d_op && parent->d_op->d_compare) {
1411 if (parent->d_op->d_compare(parent, qstr, name))
1412 goto next;
1413 } else {
1414 if (qstr->len != len)
1415 goto next;
1416 if (memcmp(qstr->name, str, len))
1417 goto next;
1418 }
1419
Linus Torvaldsd0185c02008-09-29 07:42:57 -07001420 atomic_inc(&dentry->d_count);
1421 found = dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 spin_unlock(&dentry->d_lock);
1423 break;
1424next:
1425 spin_unlock(&dentry->d_lock);
1426 }
1427 rcu_read_unlock();
1428
1429 return found;
1430}
1431
1432/**
Eric W. Biederman3e7e2412006-03-31 02:31:43 -08001433 * d_hash_and_lookup - hash the qstr then search for a dentry
1434 * @dir: Directory to search in
1435 * @name: qstr of name we wish to find
1436 *
1437 * On hash failure or on lookup failure NULL is returned.
1438 */
1439struct dentry *d_hash_and_lookup(struct dentry *dir, struct qstr *name)
1440{
1441 struct dentry *dentry = NULL;
1442
1443 /*
1444 * Check for a fs-specific hash function. Note that we must
1445 * calculate the standard hash first, as the d_op->d_hash()
1446 * routine may choose to leave the hash value unchanged.
1447 */
1448 name->hash = full_name_hash(name->name, name->len);
1449 if (dir->d_op && dir->d_op->d_hash) {
1450 if (dir->d_op->d_hash(dir, name) < 0)
1451 goto out;
1452 }
1453 dentry = d_lookup(dir, name);
1454out:
1455 return dentry;
1456}
1457
1458/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 * d_validate - verify dentry provided from insecure source
1460 * @dentry: The dentry alleged to be valid child of @dparent
1461 * @dparent: The parent dentry (known to be valid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 *
1463 * An insecure source has sent us a dentry, here we verify it and dget() it.
1464 * This is used by ncpfs in its readdir implementation.
1465 * Zero is returned in the dentry is invalid.
1466 */
1467
1468int d_validate(struct dentry *dentry, struct dentry *dparent)
1469{
1470 struct hlist_head *base;
1471 struct hlist_node *lhp;
1472
1473 /* Check whether the ptr might be valid at all.. */
1474 if (!kmem_ptr_validate(dentry_cache, dentry))
1475 goto out;
1476
1477 if (dentry->d_parent != dparent)
1478 goto out;
1479
1480 spin_lock(&dcache_lock);
1481 base = d_hash(dparent, dentry->d_name.hash);
1482 hlist_for_each(lhp,base) {
Paul E. McKenney665a7582005-11-07 00:59:17 -08001483 /* hlist_for_each_entry_rcu() not required for d_hash list
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 * as it is parsed under dcache_lock
1485 */
1486 if (dentry == hlist_entry(lhp, struct dentry, d_hash)) {
1487 __dget_locked(dentry);
1488 spin_unlock(&dcache_lock);
1489 return 1;
1490 }
1491 }
1492 spin_unlock(&dcache_lock);
1493out:
1494 return 0;
1495}
1496
1497/*
1498 * When a file is deleted, we have two options:
1499 * - turn this dentry into a negative dentry
1500 * - unhash this dentry and free it.
1501 *
1502 * Usually, we want to just turn this into
1503 * a negative dentry, but if anybody else is
1504 * currently using the dentry or the inode
1505 * we can't do that and we fall back on removing
1506 * it from the hash queues and waiting for
1507 * it to be deleted later when it has no users
1508 */
1509
1510/**
1511 * d_delete - delete a dentry
1512 * @dentry: The dentry to delete
1513 *
1514 * Turn the dentry into a negative dentry if possible, otherwise
1515 * remove it from the hash queues so it can be deleted later
1516 */
1517
1518void d_delete(struct dentry * dentry)
1519{
John McCutchan7a91bf72005-08-08 13:52:16 -04001520 int isdir = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 /*
1522 * Are we the only user?
1523 */
1524 spin_lock(&dcache_lock);
1525 spin_lock(&dentry->d_lock);
John McCutchan7a91bf72005-08-08 13:52:16 -04001526 isdir = S_ISDIR(dentry->d_inode->i_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 if (atomic_read(&dentry->d_count) == 1) {
1528 dentry_iput(dentry);
John McCutchan7a91bf72005-08-08 13:52:16 -04001529 fsnotify_nameremove(dentry, isdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 return;
1531 }
1532
1533 if (!d_unhashed(dentry))
1534 __d_drop(dentry);
1535
1536 spin_unlock(&dentry->d_lock);
1537 spin_unlock(&dcache_lock);
John McCutchan7a91bf72005-08-08 13:52:16 -04001538
1539 fsnotify_nameremove(dentry, isdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540}
1541
1542static void __d_rehash(struct dentry * entry, struct hlist_head *list)
1543{
1544
1545 entry->d_flags &= ~DCACHE_UNHASHED;
1546 hlist_add_head_rcu(&entry->d_hash, list);
1547}
1548
David Howells770bfad2006-08-22 20:06:07 -04001549static void _d_rehash(struct dentry * entry)
1550{
1551 __d_rehash(entry, d_hash(entry->d_parent, entry->d_name.hash));
1552}
1553
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554/**
1555 * d_rehash - add an entry back to the hash
1556 * @entry: dentry to add to the hash
1557 *
1558 * Adds a dentry to the hash according to its name.
1559 */
1560
1561void d_rehash(struct dentry * entry)
1562{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 spin_lock(&dcache_lock);
1564 spin_lock(&entry->d_lock);
David Howells770bfad2006-08-22 20:06:07 -04001565 _d_rehash(entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 spin_unlock(&entry->d_lock);
1567 spin_unlock(&dcache_lock);
1568}
1569
1570#define do_switch(x,y) do { \
1571 __typeof__ (x) __tmp = x; \
1572 x = y; y = __tmp; } while (0)
1573
1574/*
1575 * When switching names, the actual string doesn't strictly have to
1576 * be preserved in the target - because we're dropping the target
1577 * anyway. As such, we can just do a simple memcpy() to copy over
1578 * the new name before we switch.
1579 *
1580 * Note that we have to be a lot more careful about getting the hash
1581 * switched - we have to switch the hash value properly even if it
1582 * then no longer matches the actual (corrupted) string of the target.
1583 * The hash value has to match the hash queue that the dentry is on..
1584 */
1585static void switch_names(struct dentry *dentry, struct dentry *target)
1586{
1587 if (dname_external(target)) {
1588 if (dname_external(dentry)) {
1589 /*
1590 * Both external: swap the pointers
1591 */
1592 do_switch(target->d_name.name, dentry->d_name.name);
1593 } else {
1594 /*
1595 * dentry:internal, target:external. Steal target's
1596 * storage and make target internal.
1597 */
J. Bruce Fields321bcf92007-10-21 16:41:38 -07001598 memcpy(target->d_iname, dentry->d_name.name,
1599 dentry->d_name.len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 dentry->d_name.name = target->d_name.name;
1601 target->d_name.name = target->d_iname;
1602 }
1603 } else {
1604 if (dname_external(dentry)) {
1605 /*
1606 * dentry:external, target:internal. Give dentry's
1607 * storage to target and make dentry internal
1608 */
1609 memcpy(dentry->d_iname, target->d_name.name,
1610 target->d_name.len + 1);
1611 target->d_name.name = dentry->d_name.name;
1612 dentry->d_name.name = dentry->d_iname;
1613 } else {
1614 /*
1615 * Both are internal. Just copy target to dentry
1616 */
1617 memcpy(dentry->d_iname, target->d_name.name,
1618 target->d_name.len + 1);
Al Virodc711ca2008-11-03 15:03:50 -05001619 dentry->d_name.len = target->d_name.len;
1620 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 }
1622 }
Al Virodc711ca2008-11-03 15:03:50 -05001623 do_switch(dentry->d_name.len, target->d_name.len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624}
1625
1626/*
1627 * We cannibalize "target" when moving dentry on top of it,
1628 * because it's going to be thrown away anyway. We could be more
1629 * polite about it, though.
1630 *
1631 * This forceful removal will result in ugly /proc output if
1632 * somebody holds a file open that got deleted due to a rename.
1633 * We could be nicer about the deleted file, and let it show
J. Bruce Fieldsbc154b12007-10-16 23:29:42 -07001634 * up under the name it had before it was deleted rather than
1635 * under the original name of the file that was moved on top of it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 */
1637
Trond Myklebust9eaef272006-10-21 10:24:20 -07001638/*
1639 * d_move_locked - move a dentry
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 * @dentry: entry to move
1641 * @target: new dentry
1642 *
1643 * Update the dcache to reflect the move of a file name. Negative
1644 * dcache entries should not be moved in this way.
1645 */
Trond Myklebust9eaef272006-10-21 10:24:20 -07001646static void d_move_locked(struct dentry * dentry, struct dentry * target)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647{
1648 struct hlist_head *list;
1649
1650 if (!dentry->d_inode)
1651 printk(KERN_WARNING "VFS: moving negative dcache entry\n");
1652
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 write_seqlock(&rename_lock);
1654 /*
1655 * XXXX: do we really need to take target->d_lock?
1656 */
1657 if (target < dentry) {
1658 spin_lock(&target->d_lock);
Ingo Molnara90b9c02006-07-03 00:25:04 -07001659 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 } else {
1661 spin_lock(&dentry->d_lock);
Ingo Molnara90b9c02006-07-03 00:25:04 -07001662 spin_lock_nested(&target->d_lock, DENTRY_D_LOCK_NESTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 }
1664
1665 /* Move the dentry to the target hash queue, if on different bucket */
Denis Chengf77e3492007-10-16 23:30:11 -07001666 if (d_unhashed(dentry))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 goto already_unhashed;
1668
1669 hlist_del_rcu(&dentry->d_hash);
1670
1671already_unhashed:
1672 list = d_hash(target->d_parent, target->d_name.hash);
1673 __d_rehash(dentry, list);
1674
1675 /* Unhash the target: dput() will then get rid of it */
1676 __d_drop(target);
1677
Eric Dumazet5160ee62006-01-08 01:03:32 -08001678 list_del(&dentry->d_u.d_child);
1679 list_del(&target->d_u.d_child);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680
1681 /* Switch the names.. */
1682 switch_names(dentry, target);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 do_switch(dentry->d_name.hash, target->d_name.hash);
1684
1685 /* ... and switch the parents */
1686 if (IS_ROOT(dentry)) {
1687 dentry->d_parent = target->d_parent;
1688 target->d_parent = target;
Eric Dumazet5160ee62006-01-08 01:03:32 -08001689 INIT_LIST_HEAD(&target->d_u.d_child);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 } else {
1691 do_switch(dentry->d_parent, target->d_parent);
1692
1693 /* And add them back to the (new) parent lists */
Eric Dumazet5160ee62006-01-08 01:03:32 -08001694 list_add(&target->d_u.d_child, &target->d_parent->d_subdirs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 }
1696
Eric Dumazet5160ee62006-01-08 01:03:32 -08001697 list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 spin_unlock(&target->d_lock);
Nick Pigginc32ccd82006-03-25 03:07:09 -08001699 fsnotify_d_move(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 spin_unlock(&dentry->d_lock);
1701 write_sequnlock(&rename_lock);
Trond Myklebust9eaef272006-10-21 10:24:20 -07001702}
1703
1704/**
1705 * d_move - move a dentry
1706 * @dentry: entry to move
1707 * @target: new dentry
1708 *
1709 * Update the dcache to reflect the move of a file name. Negative
1710 * dcache entries should not be moved in this way.
1711 */
1712
1713void d_move(struct dentry * dentry, struct dentry * target)
1714{
1715 spin_lock(&dcache_lock);
1716 d_move_locked(dentry, target);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 spin_unlock(&dcache_lock);
1718}
1719
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09001720/**
1721 * d_ancestor - search for an ancestor
1722 * @p1: ancestor dentry
1723 * @p2: child dentry
1724 *
1725 * Returns the ancestor dentry of p2 which is a child of p1, if p1 is
1726 * an ancestor of p2, else NULL.
Trond Myklebust9eaef272006-10-21 10:24:20 -07001727 */
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09001728struct dentry *d_ancestor(struct dentry *p1, struct dentry *p2)
Trond Myklebust9eaef272006-10-21 10:24:20 -07001729{
1730 struct dentry *p;
1731
OGAWA Hirofumi871c0062008-10-16 07:50:27 +09001732 for (p = p2; !IS_ROOT(p); p = p->d_parent) {
Trond Myklebust9eaef272006-10-21 10:24:20 -07001733 if (p->d_parent == p1)
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09001734 return p;
Trond Myklebust9eaef272006-10-21 10:24:20 -07001735 }
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09001736 return NULL;
Trond Myklebust9eaef272006-10-21 10:24:20 -07001737}
1738
1739/*
1740 * This helper attempts to cope with remotely renamed directories
1741 *
1742 * It assumes that the caller is already holding
1743 * dentry->d_parent->d_inode->i_mutex and the dcache_lock
1744 *
1745 * Note: If ever the locking in lock_rename() changes, then please
1746 * remember to update this too...
Trond Myklebust9eaef272006-10-21 10:24:20 -07001747 */
1748static struct dentry *__d_unalias(struct dentry *dentry, struct dentry *alias)
Miklos Szeredi31f3e0b2008-06-23 18:11:52 +02001749 __releases(dcache_lock)
Trond Myklebust9eaef272006-10-21 10:24:20 -07001750{
1751 struct mutex *m1 = NULL, *m2 = NULL;
1752 struct dentry *ret;
1753
1754 /* If alias and dentry share a parent, then no extra locks required */
1755 if (alias->d_parent == dentry->d_parent)
1756 goto out_unalias;
1757
1758 /* Check for loops */
1759 ret = ERR_PTR(-ELOOP);
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09001760 if (d_ancestor(alias, dentry))
Trond Myklebust9eaef272006-10-21 10:24:20 -07001761 goto out_err;
1762
1763 /* See lock_rename() */
1764 ret = ERR_PTR(-EBUSY);
1765 if (!mutex_trylock(&dentry->d_sb->s_vfs_rename_mutex))
1766 goto out_err;
1767 m1 = &dentry->d_sb->s_vfs_rename_mutex;
1768 if (!mutex_trylock(&alias->d_parent->d_inode->i_mutex))
1769 goto out_err;
1770 m2 = &alias->d_parent->d_inode->i_mutex;
1771out_unalias:
1772 d_move_locked(alias, dentry);
1773 ret = alias;
1774out_err:
1775 spin_unlock(&dcache_lock);
1776 if (m2)
1777 mutex_unlock(m2);
1778 if (m1)
1779 mutex_unlock(m1);
1780 return ret;
1781}
1782
1783/*
David Howells770bfad2006-08-22 20:06:07 -04001784 * Prepare an anonymous dentry for life in the superblock's dentry tree as a
1785 * named dentry in place of the dentry to be replaced.
1786 */
1787static void __d_materialise_dentry(struct dentry *dentry, struct dentry *anon)
1788{
1789 struct dentry *dparent, *aparent;
1790
1791 switch_names(dentry, anon);
David Howells770bfad2006-08-22 20:06:07 -04001792 do_switch(dentry->d_name.hash, anon->d_name.hash);
1793
1794 dparent = dentry->d_parent;
1795 aparent = anon->d_parent;
1796
1797 dentry->d_parent = (aparent == anon) ? dentry : aparent;
1798 list_del(&dentry->d_u.d_child);
1799 if (!IS_ROOT(dentry))
1800 list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs);
1801 else
1802 INIT_LIST_HEAD(&dentry->d_u.d_child);
1803
1804 anon->d_parent = (dparent == dentry) ? anon : dparent;
1805 list_del(&anon->d_u.d_child);
1806 if (!IS_ROOT(anon))
1807 list_add(&anon->d_u.d_child, &anon->d_parent->d_subdirs);
1808 else
1809 INIT_LIST_HEAD(&anon->d_u.d_child);
1810
1811 anon->d_flags &= ~DCACHE_DISCONNECTED;
1812}
1813
1814/**
1815 * d_materialise_unique - introduce an inode into the tree
1816 * @dentry: candidate dentry
1817 * @inode: inode to bind to the dentry, to which aliases may be attached
1818 *
1819 * Introduces an dentry into the tree, substituting an extant disconnected
1820 * root directory alias in its place if there is one
1821 */
1822struct dentry *d_materialise_unique(struct dentry *dentry, struct inode *inode)
1823{
Trond Myklebust9eaef272006-10-21 10:24:20 -07001824 struct dentry *actual;
David Howells770bfad2006-08-22 20:06:07 -04001825
1826 BUG_ON(!d_unhashed(dentry));
1827
1828 spin_lock(&dcache_lock);
1829
1830 if (!inode) {
1831 actual = dentry;
OGAWA Hirofumi360da902008-10-16 07:50:28 +09001832 __d_instantiate(dentry, NULL);
David Howells770bfad2006-08-22 20:06:07 -04001833 goto found_lock;
1834 }
1835
Trond Myklebust9eaef272006-10-21 10:24:20 -07001836 if (S_ISDIR(inode->i_mode)) {
1837 struct dentry *alias;
David Howells770bfad2006-08-22 20:06:07 -04001838
Trond Myklebust9eaef272006-10-21 10:24:20 -07001839 /* Does an aliased dentry already exist? */
1840 alias = __d_find_alias(inode, 0);
1841 if (alias) {
1842 actual = alias;
1843 /* Is this an anonymous mountpoint that we could splice
1844 * into our tree? */
1845 if (IS_ROOT(alias)) {
1846 spin_lock(&alias->d_lock);
1847 __d_materialise_dentry(dentry, alias);
1848 __d_drop(alias);
1849 goto found;
1850 }
1851 /* Nope, but we must(!) avoid directory aliasing */
1852 actual = __d_unalias(dentry, alias);
1853 if (IS_ERR(actual))
1854 dput(alias);
1855 goto out_nolock;
1856 }
David Howells770bfad2006-08-22 20:06:07 -04001857 }
1858
1859 /* Add a unique reference */
1860 actual = __d_instantiate_unique(dentry, inode);
1861 if (!actual)
1862 actual = dentry;
1863 else if (unlikely(!d_unhashed(actual)))
1864 goto shouldnt_be_hashed;
1865
1866found_lock:
1867 spin_lock(&actual->d_lock);
1868found:
1869 _d_rehash(actual);
1870 spin_unlock(&actual->d_lock);
1871 spin_unlock(&dcache_lock);
Trond Myklebust9eaef272006-10-21 10:24:20 -07001872out_nolock:
David Howells770bfad2006-08-22 20:06:07 -04001873 if (actual == dentry) {
1874 security_d_instantiate(dentry, inode);
1875 return NULL;
1876 }
1877
1878 iput(inode);
1879 return actual;
1880
David Howells770bfad2006-08-22 20:06:07 -04001881shouldnt_be_hashed:
1882 spin_unlock(&dcache_lock);
1883 BUG();
David Howells770bfad2006-08-22 20:06:07 -04001884}
1885
Miklos Szeredicdd16d02008-06-23 18:11:53 +02001886static int prepend(char **buffer, int *buflen, const char *str, int namelen)
Ram Pai6092d042008-03-27 13:06:20 +01001887{
1888 *buflen -= namelen;
1889 if (*buflen < 0)
1890 return -ENAMETOOLONG;
1891 *buffer -= namelen;
1892 memcpy(*buffer, str, namelen);
1893 return 0;
1894}
1895
Miklos Szeredicdd16d02008-06-23 18:11:53 +02001896static int prepend_name(char **buffer, int *buflen, struct qstr *name)
1897{
1898 return prepend(buffer, buflen, name->name, name->len);
1899}
1900
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901/**
Miklos Szeredi31f3e0b2008-06-23 18:11:52 +02001902 * __d_path - return the path of a dentry
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +01001903 * @path: the dentry/vfsmount to report
1904 * @root: root vfsmnt/dentry (may be modified by this function)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 * @buffer: buffer to return value in
1906 * @buflen: buffer length
1907 *
Linus Torvalds552ce542007-02-13 12:08:18 -08001908 * Convert a dentry into an ASCII path name. If the entry has been deleted
1909 * the string " (deleted)" is appended. Note that this is ambiguous.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 *
Arjan van de Ven52afeef2008-12-01 14:35:00 -08001911 * Returns a pointer into the buffer or an error code if the
1912 * path was too long.
Linus Torvalds552ce542007-02-13 12:08:18 -08001913 *
1914 * "buflen" should be positive. Caller holds the dcache_lock.
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +01001915 *
1916 * If path is not reachable from the supplied root, then the value of
1917 * root is changed (without modifying refcounts).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 */
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +01001919char *__d_path(const struct path *path, struct path *root,
1920 char *buffer, int buflen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921{
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +01001922 struct dentry *dentry = path->dentry;
1923 struct vfsmount *vfsmnt = path->mnt;
Miklos Szeredicdd16d02008-06-23 18:11:53 +02001924 char *end = buffer + buflen;
1925 char *retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926
Andreas Gruenbacherbe285c72008-06-16 13:28:07 +02001927 spin_lock(&vfsmount_lock);
Ram Pai6092d042008-03-27 13:06:20 +01001928 prepend(&end, &buflen, "\0", 1);
1929 if (!IS_ROOT(dentry) && d_unhashed(dentry) &&
1930 (prepend(&end, &buflen, " (deleted)", 10) != 0))
Linus Torvalds552ce542007-02-13 12:08:18 -08001931 goto Elong;
Linus Torvalds552ce542007-02-13 12:08:18 -08001932
1933 if (buflen < 1)
1934 goto Elong;
1935 /* Get '/' right */
1936 retval = end-1;
1937 *retval = '/';
1938
1939 for (;;) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 struct dentry * parent;
1941
Jan Blunck329c97f2008-02-14 19:38:31 -08001942 if (dentry == root->dentry && vfsmnt == root->mnt)
Linus Torvalds552ce542007-02-13 12:08:18 -08001943 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 if (dentry == vfsmnt->mnt_root || IS_ROOT(dentry)) {
Linus Torvalds552ce542007-02-13 12:08:18 -08001945 /* Global root? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 if (vfsmnt->mnt_parent == vfsmnt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 goto global_root;
1948 }
1949 dentry = vfsmnt->mnt_mountpoint;
1950 vfsmnt = vfsmnt->mnt_parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 continue;
1952 }
1953 parent = dentry->d_parent;
1954 prefetch(parent);
Miklos Szeredicdd16d02008-06-23 18:11:53 +02001955 if ((prepend_name(&end, &buflen, &dentry->d_name) != 0) ||
Ram Pai6092d042008-03-27 13:06:20 +01001956 (prepend(&end, &buflen, "/", 1) != 0))
Linus Torvalds552ce542007-02-13 12:08:18 -08001957 goto Elong;
Linus Torvalds552ce542007-02-13 12:08:18 -08001958 retval = end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 dentry = parent;
1960 }
1961
Andreas Gruenbacherbe285c72008-06-16 13:28:07 +02001962out:
1963 spin_unlock(&vfsmount_lock);
Linus Torvalds552ce542007-02-13 12:08:18 -08001964 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965
1966global_root:
Ram Pai6092d042008-03-27 13:06:20 +01001967 retval += 1; /* hit the slash */
Miklos Szeredicdd16d02008-06-23 18:11:53 +02001968 if (prepend_name(&retval, &buflen, &dentry->d_name) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 goto Elong;
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +01001970 root->mnt = vfsmnt;
1971 root->dentry = dentry;
Andreas Gruenbacherbe285c72008-06-16 13:28:07 +02001972 goto out;
1973
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974Elong:
Andreas Gruenbacherbe285c72008-06-16 13:28:07 +02001975 retval = ERR_PTR(-ENAMETOOLONG);
1976 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977}
1978
Jan Bluncka03a8a702008-02-14 19:38:32 -08001979/**
1980 * d_path - return the path of a dentry
Jan Blunckcf28b482008-02-14 19:38:44 -08001981 * @path: path to report
Jan Bluncka03a8a702008-02-14 19:38:32 -08001982 * @buf: buffer to return value in
1983 * @buflen: buffer length
1984 *
1985 * Convert a dentry into an ASCII path name. If the entry has been deleted
1986 * the string " (deleted)" is appended. Note that this is ambiguous.
1987 *
Arjan van de Ven52afeef2008-12-01 14:35:00 -08001988 * Returns a pointer into the buffer or an error code if the path was
1989 * too long. Note: Callers should use the returned pointer, not the passed
1990 * in buffer, to use the name! The implementation often starts at an offset
1991 * into the buffer, and may leave 0 bytes at the start.
Jan Bluncka03a8a702008-02-14 19:38:32 -08001992 *
Miklos Szeredi31f3e0b2008-06-23 18:11:52 +02001993 * "buflen" should be positive.
Jan Bluncka03a8a702008-02-14 19:38:32 -08001994 */
Jan Engelhardt20d4fdc2008-06-09 16:40:36 -07001995char *d_path(const struct path *path, char *buf, int buflen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996{
1997 char *res;
Jan Blunck6ac08c32008-02-14 19:34:38 -08001998 struct path root;
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +01001999 struct path tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000
Eric Dumazetc23fbb62007-05-08 00:26:18 -07002001 /*
2002 * We have various synthetic filesystems that never get mounted. On
2003 * these filesystems dentries are never used for lookup purposes, and
2004 * thus don't need to be hashed. They also don't need a name until a
2005 * user wants to identify the object in /proc/pid/fd/. The little hack
2006 * below allows us to generate a name for these objects on demand:
2007 */
Jan Blunckcf28b482008-02-14 19:38:44 -08002008 if (path->dentry->d_op && path->dentry->d_op->d_dname)
2009 return path->dentry->d_op->d_dname(path->dentry, buf, buflen);
Eric Dumazetc23fbb62007-05-08 00:26:18 -07002010
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 read_lock(&current->fs->lock);
Jan Blunck6ac08c32008-02-14 19:34:38 -08002012 root = current->fs->root;
Ram Pai6092d042008-03-27 13:06:20 +01002013 path_get(&root);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 read_unlock(&current->fs->lock);
Linus Torvalds552ce542007-02-13 12:08:18 -08002015 spin_lock(&dcache_lock);
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +01002016 tmp = root;
2017 res = __d_path(path, &tmp, buf, buflen);
Linus Torvalds552ce542007-02-13 12:08:18 -08002018 spin_unlock(&dcache_lock);
Jan Blunck6ac08c32008-02-14 19:34:38 -08002019 path_put(&root);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 return res;
2021}
2022
2023/*
Eric Dumazetc23fbb62007-05-08 00:26:18 -07002024 * Helper function for dentry_operations.d_dname() members
2025 */
2026char *dynamic_dname(struct dentry *dentry, char *buffer, int buflen,
2027 const char *fmt, ...)
2028{
2029 va_list args;
2030 char temp[64];
2031 int sz;
2032
2033 va_start(args, fmt);
2034 sz = vsnprintf(temp, sizeof(temp), fmt, args) + 1;
2035 va_end(args);
2036
2037 if (sz > sizeof(temp) || sz > buflen)
2038 return ERR_PTR(-ENAMETOOLONG);
2039
2040 buffer += buflen - sz;
2041 return memcpy(buffer, temp, sz);
2042}
2043
2044/*
Ram Pai6092d042008-03-27 13:06:20 +01002045 * Write full pathname from the root of the filesystem into the buffer.
2046 */
2047char *dentry_path(struct dentry *dentry, char *buf, int buflen)
2048{
2049 char *end = buf + buflen;
2050 char *retval;
2051
2052 spin_lock(&dcache_lock);
2053 prepend(&end, &buflen, "\0", 1);
2054 if (!IS_ROOT(dentry) && d_unhashed(dentry) &&
2055 (prepend(&end, &buflen, "//deleted", 9) != 0))
2056 goto Elong;
2057 if (buflen < 1)
2058 goto Elong;
2059 /* Get '/' right */
2060 retval = end-1;
2061 *retval = '/';
2062
Miklos Szeredicdd16d02008-06-23 18:11:53 +02002063 while (!IS_ROOT(dentry)) {
2064 struct dentry *parent = dentry->d_parent;
Ram Pai6092d042008-03-27 13:06:20 +01002065
Ram Pai6092d042008-03-27 13:06:20 +01002066 prefetch(parent);
Miklos Szeredicdd16d02008-06-23 18:11:53 +02002067 if ((prepend_name(&end, &buflen, &dentry->d_name) != 0) ||
Ram Pai6092d042008-03-27 13:06:20 +01002068 (prepend(&end, &buflen, "/", 1) != 0))
2069 goto Elong;
2070
2071 retval = end;
2072 dentry = parent;
2073 }
2074 spin_unlock(&dcache_lock);
2075 return retval;
2076Elong:
2077 spin_unlock(&dcache_lock);
2078 return ERR_PTR(-ENAMETOOLONG);
2079}
2080
2081/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 * NOTE! The user-level library version returns a
2083 * character pointer. The kernel system call just
2084 * returns the length of the buffer filled (which
2085 * includes the ending '\0' character), or a negative
2086 * error value. So libc would do something like
2087 *
2088 * char *getcwd(char * buf, size_t size)
2089 * {
2090 * int retval;
2091 *
2092 * retval = sys_getcwd(buf, size);
2093 * if (retval >= 0)
2094 * return buf;
2095 * errno = -retval;
2096 * return NULL;
2097 * }
2098 */
2099asmlinkage long sys_getcwd(char __user *buf, unsigned long size)
2100{
Linus Torvalds552ce542007-02-13 12:08:18 -08002101 int error;
Jan Blunck6ac08c32008-02-14 19:34:38 -08002102 struct path pwd, root;
Linus Torvalds552ce542007-02-13 12:08:18 -08002103 char *page = (char *) __get_free_page(GFP_USER);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104
2105 if (!page)
2106 return -ENOMEM;
2107
2108 read_lock(&current->fs->lock);
Jan Blunck6ac08c32008-02-14 19:34:38 -08002109 pwd = current->fs->pwd;
Ram Pai6092d042008-03-27 13:06:20 +01002110 path_get(&pwd);
Jan Blunck6ac08c32008-02-14 19:34:38 -08002111 root = current->fs->root;
Ram Pai6092d042008-03-27 13:06:20 +01002112 path_get(&root);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113 read_unlock(&current->fs->lock);
2114
Linus Torvalds552ce542007-02-13 12:08:18 -08002115 error = -ENOENT;
2116 /* Has the current directory has been unlinked? */
2117 spin_lock(&dcache_lock);
Miklos Szeredicdd16d02008-06-23 18:11:53 +02002118 if (IS_ROOT(pwd.dentry) || !d_unhashed(pwd.dentry)) {
Linus Torvalds552ce542007-02-13 12:08:18 -08002119 unsigned long len;
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +01002120 struct path tmp = root;
Linus Torvalds552ce542007-02-13 12:08:18 -08002121 char * cwd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122
Miklos Szeredi9d1bc6012008-03-27 13:06:21 +01002123 cwd = __d_path(&pwd, &tmp, page, PAGE_SIZE);
Linus Torvalds552ce542007-02-13 12:08:18 -08002124 spin_unlock(&dcache_lock);
2125
2126 error = PTR_ERR(cwd);
2127 if (IS_ERR(cwd))
2128 goto out;
2129
2130 error = -ERANGE;
2131 len = PAGE_SIZE + page - cwd;
2132 if (len <= size) {
2133 error = len;
2134 if (copy_to_user(buf, cwd, len))
2135 error = -EFAULT;
2136 }
2137 } else
2138 spin_unlock(&dcache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139
2140out:
Jan Blunck6ac08c32008-02-14 19:34:38 -08002141 path_put(&pwd);
2142 path_put(&root);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143 free_page((unsigned long) page);
2144 return error;
2145}
2146
2147/*
2148 * Test whether new_dentry is a subdirectory of old_dentry.
2149 *
2150 * Trivially implemented using the dcache structure
2151 */
2152
2153/**
2154 * is_subdir - is new dentry a subdirectory of old_dentry
2155 * @new_dentry: new dentry
2156 * @old_dentry: old dentry
2157 *
2158 * Returns 1 if new_dentry is a subdirectory of the parent (at any depth).
2159 * Returns 0 otherwise.
2160 * Caller must ensure that "new_dentry" is pinned before calling is_subdir()
2161 */
2162
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09002163int is_subdir(struct dentry *new_dentry, struct dentry *old_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164{
2165 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166 unsigned long seq;
2167
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09002168 /* FIXME: This is old behavior, needed? Please check callers. */
2169 if (new_dentry == old_dentry)
2170 return 1;
2171
2172 /*
2173 * Need rcu_readlock to protect against the d_parent trashing
2174 * due to d_move
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 */
2176 rcu_read_lock();
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09002177 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178 /* for restarting inner loop in case of seq retry */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 seq = read_seqbegin(&rename_lock);
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09002180 if (d_ancestor(old_dentry, new_dentry))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181 result = 1;
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09002182 else
2183 result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 } while (read_seqretry(&rename_lock, seq));
2185 rcu_read_unlock();
2186
2187 return result;
2188}
2189
2190void d_genocide(struct dentry *root)
2191{
2192 struct dentry *this_parent = root;
2193 struct list_head *next;
2194
2195 spin_lock(&dcache_lock);
2196repeat:
2197 next = this_parent->d_subdirs.next;
2198resume:
2199 while (next != &this_parent->d_subdirs) {
2200 struct list_head *tmp = next;
Eric Dumazet5160ee62006-01-08 01:03:32 -08002201 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 next = tmp->next;
2203 if (d_unhashed(dentry)||!dentry->d_inode)
2204 continue;
2205 if (!list_empty(&dentry->d_subdirs)) {
2206 this_parent = dentry;
2207 goto repeat;
2208 }
2209 atomic_dec(&dentry->d_count);
2210 }
2211 if (this_parent != root) {
Eric Dumazet5160ee62006-01-08 01:03:32 -08002212 next = this_parent->d_u.d_child.next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 atomic_dec(&this_parent->d_count);
2214 this_parent = this_parent->d_parent;
2215 goto resume;
2216 }
2217 spin_unlock(&dcache_lock);
2218}
2219
2220/**
2221 * find_inode_number - check for dentry with name
2222 * @dir: directory to check
2223 * @name: Name to find.
2224 *
2225 * Check whether a dentry already exists for the given name,
2226 * and return the inode number if it has an inode. Otherwise
2227 * 0 is returned.
2228 *
2229 * This routine is used to post-process directory listings for
2230 * filesystems using synthetic inode numbers, and is necessary
2231 * to keep getcwd() working.
2232 */
2233
2234ino_t find_inode_number(struct dentry *dir, struct qstr *name)
2235{
2236 struct dentry * dentry;
2237 ino_t ino = 0;
2238
Eric W. Biederman3e7e2412006-03-31 02:31:43 -08002239 dentry = d_hash_and_lookup(dir, name);
2240 if (dentry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 if (dentry->d_inode)
2242 ino = dentry->d_inode->i_ino;
2243 dput(dentry);
2244 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 return ino;
2246}
2247
2248static __initdata unsigned long dhash_entries;
2249static int __init set_dhash_entries(char *str)
2250{
2251 if (!str)
2252 return 0;
2253 dhash_entries = simple_strtoul(str, &str, 0);
2254 return 1;
2255}
2256__setup("dhash_entries=", set_dhash_entries);
2257
2258static void __init dcache_init_early(void)
2259{
2260 int loop;
2261
2262 /* If hashes are distributed across NUMA nodes, defer
2263 * hash allocation until vmalloc space is available.
2264 */
2265 if (hashdist)
2266 return;
2267
2268 dentry_hashtable =
2269 alloc_large_system_hash("Dentry cache",
2270 sizeof(struct hlist_head),
2271 dhash_entries,
2272 13,
2273 HASH_EARLY,
2274 &d_hash_shift,
2275 &d_hash_mask,
2276 0);
2277
2278 for (loop = 0; loop < (1 << d_hash_shift); loop++)
2279 INIT_HLIST_HEAD(&dentry_hashtable[loop]);
2280}
2281
Denis Cheng74bf17c2007-10-16 23:26:30 -07002282static void __init dcache_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283{
2284 int loop;
2285
2286 /*
2287 * A constructor could be added for stable state like the lists,
2288 * but it is probably not worth it because of the cache nature
2289 * of the dcache.
2290 */
Christoph Lameter0a31bd52007-05-06 14:49:57 -07002291 dentry_cache = KMEM_CACHE(dentry,
2292 SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293
Rusty Russell8e1f9362007-07-17 04:03:17 -07002294 register_shrinker(&dcache_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295
2296 /* Hash may have been set up in dcache_init_early */
2297 if (!hashdist)
2298 return;
2299
2300 dentry_hashtable =
2301 alloc_large_system_hash("Dentry cache",
2302 sizeof(struct hlist_head),
2303 dhash_entries,
2304 13,
2305 0,
2306 &d_hash_shift,
2307 &d_hash_mask,
2308 0);
2309
2310 for (loop = 0; loop < (1 << d_hash_shift); loop++)
2311 INIT_HLIST_HEAD(&dentry_hashtable[loop]);
2312}
2313
2314/* SLAB cache for __getname() consumers */
Christoph Lametere18b8902006-12-06 20:33:20 -08002315struct kmem_cache *names_cachep __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317EXPORT_SYMBOL(d_genocide);
2318
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319void __init vfs_caches_init_early(void)
2320{
2321 dcache_init_early();
2322 inode_init_early();
2323}
2324
2325void __init vfs_caches_init(unsigned long mempages)
2326{
2327 unsigned long reserve;
2328
2329 /* Base hash sizes on available memory, with a reserve equal to
2330 150% of current kernel size */
2331
2332 reserve = min((mempages - nr_free_pages()) * 3/2, mempages - 1);
2333 mempages -= reserve;
2334
2335 names_cachep = kmem_cache_create("names_cache", PATH_MAX, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09002336 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337
Denis Cheng74bf17c2007-10-16 23:26:30 -07002338 dcache_init();
2339 inode_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 files_init(mempages);
Denis Cheng74bf17c2007-10-16 23:26:30 -07002341 mnt_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342 bdev_cache_init();
2343 chrdev_init();
2344}
2345
2346EXPORT_SYMBOL(d_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347EXPORT_SYMBOL(d_alloc_root);
2348EXPORT_SYMBOL(d_delete);
2349EXPORT_SYMBOL(d_find_alias);
2350EXPORT_SYMBOL(d_instantiate);
2351EXPORT_SYMBOL(d_invalidate);
2352EXPORT_SYMBOL(d_lookup);
2353EXPORT_SYMBOL(d_move);
David Howells770bfad2006-08-22 20:06:07 -04002354EXPORT_SYMBOL_GPL(d_materialise_unique);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355EXPORT_SYMBOL(d_path);
2356EXPORT_SYMBOL(d_prune_aliases);
2357EXPORT_SYMBOL(d_rehash);
2358EXPORT_SYMBOL(d_splice_alias);
Barry Naujok94035402008-05-21 16:50:46 +10002359EXPORT_SYMBOL(d_add_ci);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360EXPORT_SYMBOL(d_validate);
2361EXPORT_SYMBOL(dget_locked);
2362EXPORT_SYMBOL(dput);
2363EXPORT_SYMBOL(find_inode_number);
2364EXPORT_SYMBOL(have_submounts);
2365EXPORT_SYMBOL(names_cachep);
2366EXPORT_SYMBOL(shrink_dcache_parent);
2367EXPORT_SYMBOL(shrink_dcache_sb);