1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/syscalls.h>
18#include <linux/string.h>
19#include <linux/mm.h>
20#include <linux/fdtable.h>
21#include <linux/fs.h>
22#include <linux/fsnotify.h>
23#include <linux/slab.h>
24#include <linux/init.h>
25#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>
35#include "internal.h"
36
37
38int sysctl_vfs_cache_pressure __read_mostly = 100;
39EXPORT_SYMBOL_GPL(sysctl_vfs_cache_pressure);
40
41 __cacheline_aligned_in_smp DEFINE_SPINLOCK(dcache_lock);
42__cacheline_aligned_in_smp DEFINE_SEQLOCK(rename_lock);
43
44EXPORT_SYMBOL(dcache_lock);
45
46static struct kmem_cache *dentry_cache __read_mostly;
47
48#define DNAME_INLINE_LEN (sizeof(struct dentry)-offsetof(struct dentry,d_iname))
49
50
51
52
53
54
55
56
57
58#define D_HASHBITS d_hash_shift
59#define D_HASHMASK d_hash_mask
60
61static unsigned int d_hash_mask __read_mostly;
62static unsigned int d_hash_shift __read_mostly;
63static struct hlist_head *dentry_hashtable __read_mostly;
64
65
66struct dentry_stat_t dentry_stat = {
67 .age_limit = 45,
68};
69
70static void __d_free(struct dentry *dentry)
71{
72 WARN_ON(!list_empty(&dentry->d_alias));
73 if (dname_external(dentry))
74 kfree(dentry->d_name.name);
75 kmem_cache_free(dentry_cache, dentry);
76}
77
78static void d_callback(struct rcu_head *head)
79{
80 struct dentry * dentry = container_of(head, struct dentry, d_u.d_rcu);
81 __d_free(dentry);
82}
83
84
85
86
87
88static void d_free(struct dentry *dentry)
89{
90 if (dentry->d_op && dentry->d_op->d_release)
91 dentry->d_op->d_release(dentry);
92
93 if (hlist_unhashed(&dentry->d_hash))
94 __d_free(dentry);
95 else
96 call_rcu(&dentry->d_u.d_rcu, d_callback);
97}
98
99
100
101
102
103static void dentry_iput(struct dentry * dentry)
104 __releases(dentry->d_lock)
105 __releases(dcache_lock)
106{
107 struct inode *inode = dentry->d_inode;
108 if (inode) {
109 dentry->d_inode = NULL;
110 list_del_init(&dentry->d_alias);
111 spin_unlock(&dentry->d_lock);
112 spin_unlock(&dcache_lock);
113 if (!inode->i_nlink)
114 fsnotify_inoderemove(inode);
115 if (dentry->d_op && dentry->d_op->d_iput)
116 dentry->d_op->d_iput(dentry, inode);
117 else
118 iput(inode);
119 } else {
120 spin_unlock(&dentry->d_lock);
121 spin_unlock(&dcache_lock);
122 }
123}
124
125
126
127
128static void dentry_lru_add(struct dentry *dentry)
129{
130 list_add(&dentry->d_lru, &dentry->d_sb->s_dentry_lru);
131 dentry->d_sb->s_nr_dentry_unused++;
132 dentry_stat.nr_unused++;
133}
134
135static void dentry_lru_add_tail(struct dentry *dentry)
136{
137 list_add_tail(&dentry->d_lru, &dentry->d_sb->s_dentry_lru);
138 dentry->d_sb->s_nr_dentry_unused++;
139 dentry_stat.nr_unused++;
140}
141
142static void dentry_lru_del(struct dentry *dentry)
143{
144 if (!list_empty(&dentry->d_lru)) {
145 list_del(&dentry->d_lru);
146 dentry->d_sb->s_nr_dentry_unused--;
147 dentry_stat.nr_unused--;
148 }
149}
150
151static void dentry_lru_del_init(struct dentry *dentry)
152{
153 if (likely(!list_empty(&dentry->d_lru))) {
154 list_del_init(&dentry->d_lru);
155 dentry->d_sb->s_nr_dentry_unused--;
156 dentry_stat.nr_unused--;
157 }
158}
159
160
161
162
163
164
165
166
167
168static struct dentry *d_kill(struct dentry *dentry)
169 __releases(dentry->d_lock)
170 __releases(dcache_lock)
171{
172 struct dentry *parent;
173
174 list_del(&dentry->d_u.d_child);
175 dentry_stat.nr_dentry--;
176
177 dentry_iput(dentry);
178 if (IS_ROOT(dentry))
179 parent = NULL;
180 else
181 parent = dentry->d_parent;
182 d_free(dentry);
183 return parent;
184}
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215void dput(struct dentry *dentry)
216{
217 if (!dentry)
218 return;
219
220repeat:
221 if (atomic_read(&dentry->d_count) == 1)
222 might_sleep();
223 if (!atomic_dec_and_lock(&dentry->d_count, &dcache_lock))
224 return;
225
226 spin_lock(&dentry->d_lock);
227 if (atomic_read(&dentry->d_count)) {
228 spin_unlock(&dentry->d_lock);
229 spin_unlock(&dcache_lock);
230 return;
231 }
232
233
234
235
236 if (dentry->d_op && dentry->d_op->d_delete) {
237 if (dentry->d_op->d_delete(dentry))
238 goto unhash_it;
239 }
240
241 if (d_unhashed(dentry))
242 goto kill_it;
243 if (list_empty(&dentry->d_lru)) {
244 dentry->d_flags |= DCACHE_REFERENCED;
245 dentry_lru_add(dentry);
246 }
247 spin_unlock(&dentry->d_lock);
248 spin_unlock(&dcache_lock);
249 return;
250
251unhash_it:
252 __d_drop(dentry);
253kill_it:
254
255 dentry_lru_del(dentry);
256 dentry = d_kill(dentry);
257 if (dentry)
258 goto repeat;
259}
260
261
262
263
264
265
266
267
268
269
270
271
272
273int d_invalidate(struct dentry * dentry)
274{
275
276
277
278 spin_lock(&dcache_lock);
279 if (d_unhashed(dentry)) {
280 spin_unlock(&dcache_lock);
281 return 0;
282 }
283
284
285
286
287 if (!list_empty(&dentry->d_subdirs)) {
288 spin_unlock(&dcache_lock);
289 shrink_dcache_parent(dentry);
290 spin_lock(&dcache_lock);
291 }
292
293
294
295
296
297
298
299
300
301
302
303 spin_lock(&dentry->d_lock);
304 if (atomic_read(&dentry->d_count) > 1) {
305 if (dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode)) {
306 spin_unlock(&dentry->d_lock);
307 spin_unlock(&dcache_lock);
308 return -EBUSY;
309 }
310 }
311
312 __d_drop(dentry);
313 spin_unlock(&dentry->d_lock);
314 spin_unlock(&dcache_lock);
315 return 0;
316}
317
318
319
320static inline struct dentry * __dget_locked(struct dentry *dentry)
321{
322 atomic_inc(&dentry->d_count);
323 dentry_lru_del_init(dentry);
324 return dentry;
325}
326
327struct dentry * dget_locked(struct dentry *dentry)
328{
329 return __dget_locked(dentry);
330}
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349static struct dentry * __d_find_alias(struct inode *inode, int want_discon)
350{
351 struct list_head *head, *next, *tmp;
352 struct dentry *alias, *discon_alias=NULL;
353
354 head = &inode->i_dentry;
355 next = inode->i_dentry.next;
356 while (next != head) {
357 tmp = next;
358 next = tmp->next;
359 prefetch(next);
360 alias = list_entry(tmp, struct dentry, d_alias);
361 if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) {
362 if (IS_ROOT(alias) &&
363 (alias->d_flags & DCACHE_DISCONNECTED))
364 discon_alias = alias;
365 else if (!want_discon) {
366 __dget_locked(alias);
367 return alias;
368 }
369 }
370 }
371 if (discon_alias)
372 __dget_locked(discon_alias);
373 return discon_alias;
374}
375
376struct dentry * d_find_alias(struct inode *inode)
377{
378 struct dentry *de = NULL;
379
380 if (!list_empty(&inode->i_dentry)) {
381 spin_lock(&dcache_lock);
382 de = __d_find_alias(inode, 0);
383 spin_unlock(&dcache_lock);
384 }
385 return de;
386}
387
388
389
390
391
392void d_prune_aliases(struct inode *inode)
393{
394 struct dentry *dentry;
395restart:
396 spin_lock(&dcache_lock);
397 list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
398 spin_lock(&dentry->d_lock);
399 if (!atomic_read(&dentry->d_count)) {
400 __dget_locked(dentry);
401 __d_drop(dentry);
402 spin_unlock(&dentry->d_lock);
403 spin_unlock(&dcache_lock);
404 dput(dentry);
405 goto restart;
406 }
407 spin_unlock(&dentry->d_lock);
408 }
409 spin_unlock(&dcache_lock);
410}
411
412
413
414
415
416
417
418
419
420static void prune_one_dentry(struct dentry * dentry)
421 __releases(dentry->d_lock)
422 __releases(dcache_lock)
423 __acquires(dcache_lock)
424{
425 __d_drop(dentry);
426 dentry = d_kill(dentry);
427
428
429
430
431
432 spin_lock(&dcache_lock);
433 while (dentry) {
434 if (!atomic_dec_and_lock(&dentry->d_count, &dentry->d_lock))
435 return;
436
437 if (dentry->d_op && dentry->d_op->d_delete)
438 dentry->d_op->d_delete(dentry);
439 dentry_lru_del_init(dentry);
440 __d_drop(dentry);
441 dentry = d_kill(dentry);
442 spin_lock(&dcache_lock);
443 }
444}
445
446
447
448
449
450
451
452
453
454static void __shrink_dcache_sb(struct super_block *sb, int *count, int flags)
455{
456 LIST_HEAD(referenced);
457 LIST_HEAD(tmp);
458 struct dentry *dentry;
459 int cnt = 0;
460
461 BUG_ON(!sb);
462 BUG_ON((flags & DCACHE_REFERENCED) && count == NULL);
463 spin_lock(&dcache_lock);
464 if (count != NULL)
465
466 cnt = *count;
467restart:
468 if (count == NULL)
469 list_splice_init(&sb->s_dentry_lru, &tmp);
470 else {
471 while (!list_empty(&sb->s_dentry_lru)) {
472 dentry = list_entry(sb->s_dentry_lru.prev,
473 struct dentry, d_lru);
474 BUG_ON(dentry->d_sb != sb);
475
476 spin_lock(&dentry->d_lock);
477
478
479
480
481
482 if ((flags & DCACHE_REFERENCED)
483 && (dentry->d_flags & DCACHE_REFERENCED)) {
484 dentry->d_flags &= ~DCACHE_REFERENCED;
485 list_move_tail(&dentry->d_lru, &referenced);
486 spin_unlock(&dentry->d_lock);
487 } else {
488 list_move_tail(&dentry->d_lru, &tmp);
489 spin_unlock(&dentry->d_lock);
490 cnt--;
491 if (!cnt)
492 break;
493 }
494 cond_resched_lock(&dcache_lock);
495 }
496 }
497 while (!list_empty(&tmp)) {
498 dentry = list_entry(tmp.prev, struct dentry, d_lru);
499 dentry_lru_del_init(dentry);
500 spin_lock(&dentry->d_lock);
501
502
503
504
505
506 if (atomic_read(&dentry->d_count)) {
507 spin_unlock(&dentry->d_lock);
508 continue;
509 }
510 prune_one_dentry(dentry);
511
512 cond_resched_lock(&dcache_lock);
513 }
514 if (count == NULL && !list_empty(&sb->s_dentry_lru))
515 goto restart;
516 if (count != NULL)
517 *count = cnt;
518 if (!list_empty(&referenced))
519 list_splice(&referenced, &sb->s_dentry_lru);
520 spin_unlock(&dcache_lock);
521}
522
523
524
525
526
527
528
529
530
531
532static void prune_dcache(int count)
533{
534 struct super_block *sb;
535 int w_count;
536 int unused = dentry_stat.nr_unused;
537 int prune_ratio;
538 int pruned;
539
540 if (unused == 0 || count == 0)
541 return;
542 spin_lock(&dcache_lock);
543restart:
544 if (count >= unused)
545 prune_ratio = 1;
546 else
547 prune_ratio = unused / count;
548 spin_lock(&sb_lock);
549 list_for_each_entry(sb, &super_blocks, s_list) {
550 if (sb->s_nr_dentry_unused == 0)
551 continue;
552 sb->s_count++;
553
554
555
556
557
558
559
560
561
562 spin_unlock(&sb_lock);
563 if (prune_ratio != 1)
564 w_count = (sb->s_nr_dentry_unused / prune_ratio) + 1;
565 else
566 w_count = sb->s_nr_dentry_unused;
567 pruned = w_count;
568
569
570
571
572
573
574
575 if (down_read_trylock(&sb->s_umount)) {
576 if ((sb->s_root != NULL) &&
577 (!list_empty(&sb->s_dentry_lru))) {
578 spin_unlock(&dcache_lock);
579 __shrink_dcache_sb(sb, &w_count,
580 DCACHE_REFERENCED);
581 pruned -= w_count;
582 spin_lock(&dcache_lock);
583 }
584 up_read(&sb->s_umount);
585 }
586 spin_lock(&sb_lock);
587 count -= pruned;
588
589
590
591
592 if (__put_super_and_need_restart(sb) && count > 0) {
593 spin_unlock(&sb_lock);
594 goto restart;
595 }
596 }
597 spin_unlock(&sb_lock);
598 spin_unlock(&dcache_lock);
599}
600
601
602
603
604
605
606
607
608
609void shrink_dcache_sb(struct super_block * sb)
610{
611 __shrink_dcache_sb(sb, NULL, 0);
612}
613
614
615
616
617
618
619static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
620{
621 struct dentry *parent;
622 unsigned detached = 0;
623
624 BUG_ON(!IS_ROOT(dentry));
625
626
627 spin_lock(&dcache_lock);
628 dentry_lru_del_init(dentry);
629 __d_drop(dentry);
630 spin_unlock(&dcache_lock);
631
632 for (;;) {
633
634 while (!list_empty(&dentry->d_subdirs)) {
635 struct dentry *loop;
636
637
638
639 spin_lock(&dcache_lock);
640 list_for_each_entry(loop, &dentry->d_subdirs,
641 d_u.d_child) {
642 dentry_lru_del_init(loop);
643 __d_drop(loop);
644 cond_resched_lock(&dcache_lock);
645 }
646 spin_unlock(&dcache_lock);
647
648
649 dentry = list_entry(dentry->d_subdirs.next,
650 struct dentry, d_u.d_child);
651 }
652
653
654
655 do {
656 struct inode *inode;
657
658 if (atomic_read(&dentry->d_count) != 0) {
659 printk(KERN_ERR
660 "BUG: Dentry %p{i=%lx,n=%s}"
661 " still in use (%d)"
662 " [unmount of %s %s]\n",
663 dentry,
664 dentry->d_inode ?
665 dentry->d_inode->i_ino : 0UL,
666 dentry->d_name.name,
667 atomic_read(&dentry->d_count),
668 dentry->d_sb->s_type->name,
669 dentry->d_sb->s_id);
670 BUG();
671 }
672
673 if (IS_ROOT(dentry))
674 parent = NULL;
675 else {
676 parent = dentry->d_parent;
677 atomic_dec(&parent->d_count);
678 }
679
680 list_del(&dentry->d_u.d_child);
681 detached++;
682
683 inode = dentry->d_inode;
684 if (inode) {
685 dentry->d_inode = NULL;
686 list_del_init(&dentry->d_alias);
687 if (dentry->d_op && dentry->d_op->d_iput)
688 dentry->d_op->d_iput(dentry, inode);
689 else
690 iput(inode);
691 }
692
693 d_free(dentry);
694
695
696
697
698 if (!parent)
699 goto out;
700
701 dentry = parent;
702
703 } while (list_empty(&dentry->d_subdirs));
704
705 dentry = list_entry(dentry->d_subdirs.next,
706 struct dentry, d_u.d_child);
707 }
708out:
709
710 spin_lock(&dcache_lock);
711 dentry_stat.nr_dentry -= detached;
712 spin_unlock(&dcache_lock);
713}
714
715
716
717
718
719
720
721
722
723
724
725
726void shrink_dcache_for_umount(struct super_block *sb)
727{
728 struct dentry *dentry;
729
730 if (down_read_trylock(&sb->s_umount))
731 BUG();
732
733 dentry = sb->s_root;
734 sb->s_root = NULL;
735 atomic_dec(&dentry->d_count);
736 shrink_dcache_for_umount_subtree(dentry);
737
738 while (!hlist_empty(&sb->s_anon)) {
739 dentry = hlist_entry(sb->s_anon.first, struct dentry, d_hash);
740 shrink_dcache_for_umount_subtree(dentry);
741 }
742}
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758int have_submounts(struct dentry *parent)
759{
760 struct dentry *this_parent = parent;
761 struct list_head *next;
762
763 spin_lock(&dcache_lock);
764 if (d_mountpoint(parent))
765 goto positive;
766repeat:
767 next = this_parent->d_subdirs.next;
768resume:
769 while (next != &this_parent->d_subdirs) {
770 struct list_head *tmp = next;
771 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
772 next = tmp->next;
773
774 if (d_mountpoint(dentry))
775 goto positive;
776 if (!list_empty(&dentry->d_subdirs)) {
777 this_parent = dentry;
778 goto repeat;
779 }
780 }
781
782
783
784 if (this_parent != parent) {
785 next = this_parent->d_u.d_child.next;
786 this_parent = this_parent->d_parent;
787 goto resume;
788 }
789 spin_unlock(&dcache_lock);
790 return 0;
791positive:
792 spin_unlock(&dcache_lock);
793 return 1;
794}
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810static int select_parent(struct dentry * parent)
811{
812 struct dentry *this_parent = parent;
813 struct list_head *next;
814 int found = 0;
815
816 spin_lock(&dcache_lock);
817repeat:
818 next = this_parent->d_subdirs.next;
819resume:
820 while (next != &this_parent->d_subdirs) {
821 struct list_head *tmp = next;
822 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
823 next = tmp->next;
824
825 dentry_lru_del_init(dentry);
826
827
828
829
830 if (!atomic_read(&dentry->d_count)) {
831 dentry_lru_add_tail(dentry);
832 found++;
833 }
834
835
836
837
838
839
840 if (found && need_resched())
841 goto out;
842
843
844
845
846 if (!list_empty(&dentry->d_subdirs)) {
847 this_parent = dentry;
848 goto repeat;
849 }
850 }
851
852
853
854 if (this_parent != parent) {
855 next = this_parent->d_u.d_child.next;
856 this_parent = this_parent->d_parent;
857 goto resume;
858 }
859out:
860 spin_unlock(&dcache_lock);
861 return found;
862}
863
864
865
866
867
868
869
870
871void shrink_dcache_parent(struct dentry * parent)
872{
873 struct super_block *sb = parent->d_sb;
874 int found;
875
876 while ((found = select_parent(parent)) != 0)
877 __shrink_dcache_sb(sb, &found, 0);
878}
879
880
881
882
883
884
885
886
887
888
889
890
891
892static int shrink_dcache_memory(int nr, gfp_t gfp_mask)
893{
894 if (nr) {
895 if (!(gfp_mask & __GFP_FS))
896 return -1;
897 prune_dcache(nr);
898 }
899 return (dentry_stat.nr_unused / 100) * sysctl_vfs_cache_pressure;
900}
901
902static struct shrinker dcache_shrinker = {
903 .shrink = shrink_dcache_memory,
904 .seeks = DEFAULT_SEEKS,
905};
906
907
908
909
910
911
912
913
914
915
916
917struct dentry *d_alloc(struct dentry * parent, const struct qstr *name)
918{
919 struct dentry *dentry;
920 char *dname;
921
922 dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL);
923 if (!dentry)
924 return NULL;
925
926 if (name->len > DNAME_INLINE_LEN-1) {
927 dname = kmalloc(name->len + 1, GFP_KERNEL);
928 if (!dname) {
929 kmem_cache_free(dentry_cache, dentry);
930 return NULL;
931 }
932 } else {
933 dname = dentry->d_iname;
934 }
935 dentry->d_name.name = dname;
936
937 dentry->d_name.len = name->len;
938 dentry->d_name.hash = name->hash;
939 memcpy(dname, name->name, name->len);
940 dname[name->len] = 0;
941
942 atomic_set(&dentry->d_count, 1);
943 dentry->d_flags = DCACHE_UNHASHED;
944 spin_lock_init(&dentry->d_lock);
945 dentry->d_inode = NULL;
946 dentry->d_parent = NULL;
947 dentry->d_sb = NULL;
948 dentry->d_op = NULL;
949 dentry->d_fsdata = NULL;
950 dentry->d_mounted = 0;
951#ifdef CONFIG_PROFILING
952 dentry->d_cookie = NULL;
953#endif
954 INIT_HLIST_NODE(&dentry->d_hash);
955 INIT_LIST_HEAD(&dentry->d_lru);
956 INIT_LIST_HEAD(&dentry->d_subdirs);
957 INIT_LIST_HEAD(&dentry->d_alias);
958
959 if (parent) {
960 dentry->d_parent = dget(parent);
961 dentry->d_sb = parent->d_sb;
962 } else {
963 INIT_LIST_HEAD(&dentry->d_u.d_child);
964 }
965
966 spin_lock(&dcache_lock);
967 if (parent)
968 list_add(&dentry->d_u.d_child, &parent->d_subdirs);
969 dentry_stat.nr_dentry++;
970 spin_unlock(&dcache_lock);
971
972 return dentry;
973}
974
975struct dentry *d_alloc_name(struct dentry *parent, const char *name)
976{
977 struct qstr q;
978
979 q.name = name;
980 q.len = strlen(name);
981 q.hash = full_name_hash(q.name, q.len);
982 return d_alloc(parent, &q);
983}
984
985
986static void __d_instantiate(struct dentry *dentry, struct inode *inode)
987{
988 if (inode)
989 list_add(&dentry->d_alias, &inode->i_dentry);
990 dentry->d_inode = inode;
991 fsnotify_d_instantiate(dentry, inode);
992}
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009void d_instantiate(struct dentry *entry, struct inode * inode)
1010{
1011 BUG_ON(!list_empty(&entry->d_alias));
1012 spin_lock(&dcache_lock);
1013 __d_instantiate(entry, inode);
1014 spin_unlock(&dcache_lock);
1015 security_d_instantiate(entry, inode);
1016}
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034static struct dentry *__d_instantiate_unique(struct dentry *entry,
1035 struct inode *inode)
1036{
1037 struct dentry *alias;
1038 int len = entry->d_name.len;
1039 const char *name = entry->d_name.name;
1040 unsigned int hash = entry->d_name.hash;
1041
1042 if (!inode) {
1043 __d_instantiate(entry, NULL);
1044 return NULL;
1045 }
1046
1047 list_for_each_entry(alias, &inode->i_dentry, d_alias) {
1048 struct qstr *qstr = &alias->d_name;
1049
1050 if (qstr->hash != hash)
1051 continue;
1052 if (alias->d_parent != entry->d_parent)
1053 continue;
1054 if (qstr->len != len)
1055 continue;
1056 if (memcmp(qstr->name, name, len))
1057 continue;
1058 dget_locked(alias);
1059 return alias;
1060 }
1061
1062 __d_instantiate(entry, inode);
1063 return NULL;
1064}
1065
1066struct dentry *d_instantiate_unique(struct dentry *entry, struct inode *inode)
1067{
1068 struct dentry *result;
1069
1070 BUG_ON(!list_empty(&entry->d_alias));
1071
1072 spin_lock(&dcache_lock);
1073 result = __d_instantiate_unique(entry, inode);
1074 spin_unlock(&dcache_lock);
1075
1076 if (!result) {
1077 security_d_instantiate(entry, inode);
1078 return NULL;
1079 }
1080
1081 BUG_ON(!d_unhashed(result));
1082 iput(inode);
1083 return result;
1084}
1085
1086EXPORT_SYMBOL(d_instantiate_unique);
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097struct dentry * d_alloc_root(struct inode * root_inode)
1098{
1099 struct dentry *res = NULL;
1100
1101 if (root_inode) {
1102 static const struct qstr name = { .name = "/", .len = 1 };
1103
1104 res = d_alloc(NULL, &name);
1105 if (res) {
1106 res->d_sb = root_inode->i_sb;
1107 res->d_parent = res;
1108 d_instantiate(res, root_inode);
1109 }
1110 }
1111 return res;
1112}
1113
1114static inline struct hlist_head *d_hash(struct dentry *parent,
1115 unsigned long hash)
1116{
1117 hash += ((unsigned long) parent ^ GOLDEN_RATIO_PRIME) / L1_CACHE_BYTES;
1118 hash = hash ^ ((hash ^ GOLDEN_RATIO_PRIME) >> D_HASHBITS);
1119 return dentry_hashtable + (hash & D_HASHMASK);
1120}
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140struct dentry *d_obtain_alias(struct inode *inode)
1141{
1142 static const struct qstr anonstring = { .name = "" };
1143 struct dentry *tmp;
1144 struct dentry *res;
1145
1146 if (!inode)
1147 return ERR_PTR(-ESTALE);
1148 if (IS_ERR(inode))
1149 return ERR_CAST(inode);
1150
1151 res = d_find_alias(inode);
1152 if (res)
1153 goto out_iput;
1154
1155 tmp = d_alloc(NULL, &anonstring);
1156 if (!tmp) {
1157 res = ERR_PTR(-ENOMEM);
1158 goto out_iput;
1159 }
1160 tmp->d_parent = tmp;
1161
1162 spin_lock(&dcache_lock);
1163 res = __d_find_alias(inode, 0);
1164 if (res) {
1165 spin_unlock(&dcache_lock);
1166 dput(tmp);
1167 goto out_iput;
1168 }
1169
1170
1171 spin_lock(&tmp->d_lock);
1172 tmp->d_sb = inode->i_sb;
1173 tmp->d_inode = inode;
1174 tmp->d_flags |= DCACHE_DISCONNECTED;
1175 tmp->d_flags &= ~DCACHE_UNHASHED;
1176 list_add(&tmp->d_alias, &inode->i_dentry);
1177 hlist_add_head(&tmp->d_hash, &inode->i_sb->s_anon);
1178 spin_unlock(&tmp->d_lock);
1179
1180 spin_unlock(&dcache_lock);
1181 return tmp;
1182
1183 out_iput:
1184 iput(inode);
1185 return res;
1186}
1187EXPORT_SYMBOL_GPL(d_obtain_alias);
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
1206{
1207 struct dentry *new = NULL;
1208
1209 if (inode && S_ISDIR(inode->i_mode)) {
1210 spin_lock(&dcache_lock);
1211 new = __d_find_alias(inode, 1);
1212 if (new) {
1213 BUG_ON(!(new->d_flags & DCACHE_DISCONNECTED));
1214 spin_unlock(&dcache_lock);
1215 security_d_instantiate(new, inode);
1216 d_rehash(dentry);
1217 d_move(new, dentry);
1218 iput(inode);
1219 } else {
1220
1221 __d_instantiate(dentry, inode);
1222 spin_unlock(&dcache_lock);
1223 security_d_instantiate(dentry, inode);
1224 d_rehash(dentry);
1225 }
1226 } else
1227 d_add(dentry, inode);
1228 return new;
1229}
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
1248 struct qstr *name)
1249{
1250 int error;
1251 struct dentry *found;
1252 struct dentry *new;
1253
1254
1255 found = d_hash_and_lookup(dentry->d_parent, name);
1256
1257 if (!found) {
1258 new = d_alloc(dentry->d_parent, name);
1259 if (!new) {
1260 error = -ENOMEM;
1261 goto err_out;
1262 }
1263 found = d_splice_alias(inode, new);
1264 if (found) {
1265 dput(new);
1266 return found;
1267 }
1268 return new;
1269 }
1270
1271 if (found->d_inode) {
1272 if (unlikely(found->d_inode != inode)) {
1273
1274 BUG_ON(!is_bad_inode(inode));
1275 BUG_ON(!is_bad_inode(found->d_inode));
1276 }
1277
1278
1279
1280
1281
1282
1283
1284 iput(inode);
1285 return found;
1286 }
1287
1288
1289
1290
1291
1292 if (!S_ISDIR(inode->i_mode)) {
1293
1294 d_instantiate(found, inode);
1295 return found;
1296 }
1297 spin_lock(&dcache_lock);
1298 if (list_empty(&inode->i_dentry)) {
1299
1300
1301
1302
1303
1304 __d_instantiate(found, inode);
1305 spin_unlock(&dcache_lock);
1306 security_d_instantiate(found, inode);
1307 return found;
1308 }
1309
1310
1311
1312
1313 new = list_entry(inode->i_dentry.next, struct dentry, d_alias);
1314 dget_locked(new);
1315 spin_unlock(&dcache_lock);
1316
1317 security_d_instantiate(found, inode);
1318
1319 d_move(new, found);
1320
1321 iput(inode);
1322
1323 dput(found);
1324
1325 return new;
1326
1327err_out:
1328 iput(inode);
1329 return ERR_PTR(error);
1330}
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361struct dentry * d_lookup(struct dentry * parent, struct qstr * name)
1362{
1363 struct dentry * dentry = NULL;
1364 unsigned long seq;
1365
1366 do {
1367 seq = read_seqbegin(&rename_lock);
1368 dentry = __d_lookup(parent, name);
1369 if (dentry)
1370 break;
1371 } while (read_seqretry(&rename_lock, seq));
1372 return dentry;
1373}
1374
1375struct dentry * __d_lookup(struct dentry * parent, struct qstr * name)
1376{
1377 unsigned int len = name->len;
1378 unsigned int hash = name->hash;
1379 const unsigned char *str = name->name;
1380 struct hlist_head *head = d_hash(parent,hash);
1381 struct dentry *found = NULL;
1382 struct hlist_node *node;
1383 struct dentry *dentry;
1384
1385 rcu_read_lock();
1386
1387 hlist_for_each_entry_rcu(dentry, node, head, d_hash) {
1388 struct qstr *qstr;
1389
1390 if (dentry->d_name.hash != hash)
1391 continue;
1392 if (dentry->d_parent != parent)
1393 continue;
1394
1395 spin_lock(&dentry->d_lock);
1396
1397
1398
1399
1400
1401
1402 if (dentry->d_parent != parent)
1403 goto next;
1404
1405
1406 if (d_unhashed(dentry))
1407 goto next;
1408
1409
1410
1411
1412
1413 qstr = &dentry->d_name;
1414 if (parent->d_op && parent->d_op->d_compare) {
1415 if (parent->d_op->d_compare(parent, qstr, name))
1416 goto next;
1417 } else {
1418 if (qstr->len != len)
1419 goto next;
1420 if (memcmp(qstr->name, str, len))
1421 goto next;
1422 }
1423
1424 atomic_inc(&dentry->d_count);
1425 found = dentry;
1426 spin_unlock(&dentry->d_lock);
1427 break;
1428next:
1429 spin_unlock(&dentry->d_lock);
1430 }
1431 rcu_read_unlock();
1432
1433 return found;
1434}
1435
1436
1437
1438
1439
1440
1441
1442
1443struct dentry *d_hash_and_lookup(struct dentry *dir, struct qstr *name)
1444{
1445 struct dentry *dentry = NULL;
1446
1447
1448
1449
1450
1451
1452 name->hash = full_name_hash(name->name, name->len);
1453 if (dir->d_op && dir->d_op->d_hash) {
1454 if (dir->d_op->d_hash(dir, name) < 0)
1455 goto out;
1456 }
1457 dentry = d_lookup(dir, name);
1458out:
1459 return dentry;
1460}
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472int d_validate(struct dentry *dentry, struct dentry *dparent)
1473{
1474 struct hlist_head *base;
1475 struct hlist_node *lhp;
1476
1477
1478 if (!kmem_ptr_validate(dentry_cache, dentry))
1479 goto out;
1480
1481 if (dentry->d_parent != dparent)
1482 goto out;
1483
1484 spin_lock(&dcache_lock);
1485 base = d_hash(dparent, dentry->d_name.hash);
1486 hlist_for_each(lhp,base) {
1487
1488
1489
1490 if (dentry == hlist_entry(lhp, struct dentry, d_hash)) {
1491 __dget_locked(dentry);
1492 spin_unlock(&dcache_lock);
1493 return 1;
1494 }
1495 }
1496 spin_unlock(&dcache_lock);
1497out:
1498 return 0;
1499}
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522void d_delete(struct dentry * dentry)
1523{
1524 int isdir = 0;
1525
1526
1527
1528 spin_lock(&dcache_lock);
1529 spin_lock(&dentry->d_lock);
1530 isdir = S_ISDIR(dentry->d_inode->i_mode);
1531 if (atomic_read(&dentry->d_count) == 1) {
1532 dentry_iput(dentry);
1533 fsnotify_nameremove(dentry, isdir);
1534 return;
1535 }
1536
1537 if (!d_unhashed(dentry))
1538 __d_drop(dentry);
1539
1540 spin_unlock(&dentry->d_lock);
1541 spin_unlock(&dcache_lock);
1542
1543 fsnotify_nameremove(dentry, isdir);
1544}
1545
1546static void __d_rehash(struct dentry * entry, struct hlist_head *list)
1547{
1548
1549 entry->d_flags &= ~DCACHE_UNHASHED;
1550 hlist_add_head_rcu(&entry->d_hash, list);
1551}
1552
1553static void _d_rehash(struct dentry * entry)
1554{
1555 __d_rehash(entry, d_hash(entry->d_parent, entry->d_name.hash));
1556}
1557
1558
1559
1560
1561
1562
1563
1564
1565void d_rehash(struct dentry * entry)
1566{
1567 spin_lock(&dcache_lock);
1568 spin_lock(&entry->d_lock);
1569 _d_rehash(entry);
1570 spin_unlock(&entry->d_lock);
1571 spin_unlock(&dcache_lock);
1572}
1573
1574#define do_switch(x,y) do { \
1575 __typeof__ (x) __tmp = x; \
1576 x = y; y = __tmp; } while (0)
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589static void switch_names(struct dentry *dentry, struct dentry *target)
1590{
1591 if (dname_external(target)) {
1592 if (dname_external(dentry)) {
1593
1594
1595
1596 do_switch(target->d_name.name, dentry->d_name.name);
1597 } else {
1598
1599
1600
1601
1602 memcpy(target->d_iname, dentry->d_name.name,
1603 dentry->d_name.len + 1);
1604 dentry->d_name.name = target->d_name.name;
1605 target->d_name.name = target->d_iname;
1606 }
1607 } else {
1608 if (dname_external(dentry)) {
1609
1610
1611
1612
1613 memcpy(dentry->d_iname, target->d_name.name,
1614 target->d_name.len + 1);
1615 target->d_name.name = dentry->d_name.name;
1616 dentry->d_name.name = dentry->d_iname;
1617 } else {
1618
1619
1620
1621 memcpy(dentry->d_iname, target->d_name.name,
1622 target->d_name.len + 1);
1623 }
1624 }
1625}
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647static void d_move_locked(struct dentry * dentry, struct dentry * target)
1648{
1649 struct hlist_head *list;
1650
1651 if (!dentry->d_inode)
1652 printk(KERN_WARNING "VFS: moving negative dcache entry\n");
1653
1654 write_seqlock(&rename_lock);
1655
1656
1657
1658 if (target < dentry) {
1659 spin_lock(&target->d_lock);
1660 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
1661 } else {
1662 spin_lock(&dentry->d_lock);
1663 spin_lock_nested(&target->d_lock, DENTRY_D_LOCK_NESTED);
1664 }
1665
1666
1667 if (d_unhashed(dentry))
1668 goto already_unhashed;
1669
1670 hlist_del_rcu(&dentry->d_hash);
1671
1672already_unhashed:
1673 list = d_hash(target->d_parent, target->d_name.hash);
1674 __d_rehash(dentry, list);
1675
1676
1677 __d_drop(target);
1678
1679 list_del(&dentry->d_u.d_child);
1680 list_del(&target->d_u.d_child);
1681
1682
1683 switch_names(dentry, target);
1684 do_switch(dentry->d_name.len, target->d_name.len);
1685 do_switch(dentry->d_name.hash, target->d_name.hash);
1686
1687
1688 if (IS_ROOT(dentry)) {
1689 dentry->d_parent = target->d_parent;
1690 target->d_parent = target;
1691 INIT_LIST_HEAD(&target->d_u.d_child);
1692 } else {
1693 do_switch(dentry->d_parent, target->d_parent);
1694
1695
1696 list_add(&target->d_u.d_child, &target->d_parent->d_subdirs);
1697 }
1698
1699 list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs);
1700 spin_unlock(&target->d_lock);
1701 fsnotify_d_move(dentry);
1702 spin_unlock(&dentry->d_lock);
1703 write_sequnlock(&rename_lock);
1704}
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715void d_move(struct dentry * dentry, struct dentry * target)
1716{
1717 spin_lock(&dcache_lock);
1718 d_move_locked(dentry, target);
1719 spin_unlock(&dcache_lock);
1720}
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730struct dentry *d_ancestor(struct dentry *p1, struct dentry *p2)
1731{
1732 struct dentry *p;
1733
1734 for (p = p2; !IS_ROOT(p); p = p->d_parent) {
1735 if (p->d_parent == p1)
1736 return p;
1737 }
1738 return NULL;
1739}
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750static struct dentry *__d_unalias(struct dentry *dentry, struct dentry *alias)
1751 __releases(dcache_lock)
1752{
1753 struct mutex *m1 = NULL, *m2 = NULL;
1754 struct dentry *ret;
1755
1756
1757 if (alias->d_parent == dentry->d_parent)
1758 goto out_unalias;
1759
1760
1761 ret = ERR_PTR(-ELOOP);
1762 if (d_ancestor(alias, dentry))
1763 goto out_err;
1764
1765
1766 ret = ERR_PTR(-EBUSY);
1767 if (!mutex_trylock(&dentry->d_sb->s_vfs_rename_mutex))
1768 goto out_err;
1769 m1 = &dentry->d_sb->s_vfs_rename_mutex;
1770 if (!mutex_trylock(&alias->d_parent->d_inode->i_mutex))
1771 goto out_err;
1772 m2 = &alias->d_parent->d_inode->i_mutex;
1773out_unalias:
1774 d_move_locked(alias, dentry);
1775 ret = alias;
1776out_err:
1777 spin_unlock(&dcache_lock);
1778 if (m2)
1779 mutex_unlock(m2);
1780 if (m1)
1781 mutex_unlock(m1);
1782 return ret;
1783}
1784
1785
1786
1787
1788
1789static void __d_materialise_dentry(struct dentry *dentry, struct dentry *anon)
1790{
1791 struct dentry *dparent, *aparent;
1792
1793 switch_names(dentry, anon);
1794 do_switch(dentry->d_name.len, anon->d_name.len);
1795 do_switch(dentry->d_name.hash, anon->d_name.hash);
1796
1797 dparent = dentry->d_parent;
1798 aparent = anon->d_parent;
1799
1800 dentry->d_parent = (aparent == anon) ? dentry : aparent;
1801 list_del(&dentry->d_u.d_child);
1802 if (!IS_ROOT(dentry))
1803 list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs);
1804 else
1805 INIT_LIST_HEAD(&dentry->d_u.d_child);
1806
1807 anon->d_parent = (dparent == dentry) ? anon : dparent;
1808 list_del(&anon->d_u.d_child);
1809 if (!IS_ROOT(anon))
1810 list_add(&anon->d_u.d_child, &anon->d_parent->d_subdirs);
1811 else
1812 INIT_LIST_HEAD(&anon->d_u.d_child);
1813
1814 anon->d_flags &= ~DCACHE_DISCONNECTED;
1815}
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825struct dentry *d_materialise_unique(struct dentry *dentry, struct inode *inode)
1826{
1827 struct dentry *actual;
1828
1829 BUG_ON(!d_unhashed(dentry));
1830
1831 spin_lock(&dcache_lock);
1832
1833 if (!inode) {
1834 actual = dentry;
1835 __d_instantiate(dentry, NULL);
1836 goto found_lock;
1837 }
1838
1839 if (S_ISDIR(inode->i_mode)) {
1840 struct dentry *alias;
1841
1842
1843 alias = __d_find_alias(inode, 0);
1844 if (alias) {
1845 actual = alias;
1846
1847
1848 if (IS_ROOT(alias)) {
1849 spin_lock(&alias->d_lock);
1850 __d_materialise_dentry(dentry, alias);
1851 __d_drop(alias);
1852 goto found;
1853 }
1854
1855 actual = __d_unalias(dentry, alias);
1856 if (IS_ERR(actual))
1857 dput(alias);
1858 goto out_nolock;
1859 }
1860 }
1861
1862
1863 actual = __d_instantiate_unique(dentry, inode);
1864 if (!actual)
1865 actual = dentry;
1866 else if (unlikely(!d_unhashed(actual)))
1867 goto shouldnt_be_hashed;
1868
1869found_lock:
1870 spin_lock(&actual->d_lock);
1871found:
1872 _d_rehash(actual);
1873 spin_unlock(&actual->d_lock);
1874 spin_unlock(&dcache_lock);
1875out_nolock:
1876 if (actual == dentry) {
1877 security_d_instantiate(dentry, inode);
1878 return NULL;
1879 }
1880
1881 iput(inode);
1882 return actual;
1883
1884shouldnt_be_hashed:
1885 spin_unlock(&dcache_lock);
1886 BUG();
1887}
1888
1889static int prepend(char **buffer, int *buflen, const char *str, int namelen)
1890{
1891 *buflen -= namelen;
1892 if (*buflen < 0)
1893 return -ENAMETOOLONG;
1894 *buffer -= namelen;
1895 memcpy(*buffer, str, namelen);
1896 return 0;
1897}
1898
1899static int prepend_name(char **buffer, int *buflen, struct qstr *name)
1900{
1901 return prepend(buffer, buflen, name->name, name->len);
1902}
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921char *__d_path(const struct path *path, struct path *root,
1922 char *buffer, int buflen)
1923{
1924 struct dentry *dentry = path->dentry;
1925 struct vfsmount *vfsmnt = path->mnt;
1926 char *end = buffer + buflen;
1927 char *retval;
1928
1929 spin_lock(&vfsmount_lock);
1930 prepend(&end, &buflen, "\0", 1);
1931 if (!IS_ROOT(dentry) && d_unhashed(dentry) &&
1932 (prepend(&end, &buflen, " (deleted)", 10) != 0))
1933 goto Elong;
1934
1935 if (buflen < 1)
1936 goto Elong;
1937
1938 retval = end-1;
1939 *retval = '/';
1940
1941 for (;;) {
1942 struct dentry * parent;
1943
1944 if (dentry == root->dentry && vfsmnt == root->mnt)
1945 break;
1946 if (dentry == vfsmnt->mnt_root || IS_ROOT(dentry)) {
1947
1948 if (vfsmnt->mnt_parent == vfsmnt) {
1949 goto global_root;
1950 }
1951 dentry = vfsmnt->mnt_mountpoint;
1952 vfsmnt = vfsmnt->mnt_parent;
1953 continue;
1954 }
1955 parent = dentry->d_parent;
1956 prefetch(parent);
1957 if ((prepend_name(&end, &buflen, &dentry->d_name) != 0) ||
1958 (prepend(&end, &buflen, "/", 1) != 0))
1959 goto Elong;
1960 retval = end;
1961 dentry = parent;
1962 }
1963
1964out:
1965 spin_unlock(&vfsmount_lock);
1966 return retval;
1967
1968global_root:
1969 retval += 1;
1970 if (prepend_name(&retval, &buflen, &dentry->d_name) != 0)
1971 goto Elong;
1972 root->mnt = vfsmnt;
1973 root->dentry = dentry;
1974 goto out;
1975
1976Elong:
1977 retval = ERR_PTR(-ENAMETOOLONG);
1978 goto out;
1979}
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994char *d_path(const struct path *path, char *buf, int buflen)
1995{
1996 char *res;
1997 struct path root;
1998 struct path tmp;
1999
2000
2001
2002
2003
2004
2005
2006
2007 if (path->dentry->d_op && path->dentry->d_op->d_dname)
2008 return path->dentry->d_op->d_dname(path->dentry, buf, buflen);
2009
2010 read_lock(¤t->fs->lock);
2011 root = current->fs->root;
2012 path_get(&root);
2013 read_unlock(¤t->fs->lock);
2014 spin_lock(&dcache_lock);
2015 tmp = root;
2016 res = __d_path(path, &tmp, buf, buflen);
2017 spin_unlock(&dcache_lock);
2018 path_put(&root);
2019 return res;
2020}
2021
2022
2023
2024
2025char *dynamic_dname(struct dentry *dentry, char *buffer, int buflen,
2026 const char *fmt, ...)
2027{
2028 va_list args;
2029 char temp[64];
2030 int sz;
2031
2032 va_start(args, fmt);
2033 sz = vsnprintf(temp, sizeof(temp), fmt, args) + 1;
2034 va_end(args);
2035
2036 if (sz > sizeof(temp) || sz > buflen)
2037 return ERR_PTR(-ENAMETOOLONG);
2038
2039 buffer += buflen - sz;
2040 return memcpy(buffer, temp, sz);
2041}
2042
2043
2044
2045
2046char *dentry_path(struct dentry *dentry, char *buf, int buflen)
2047{
2048 char *end = buf + buflen;
2049 char *retval;
2050
2051 spin_lock(&dcache_lock);
2052 prepend(&end, &buflen, "\0", 1);
2053 if (!IS_ROOT(dentry) && d_unhashed(dentry) &&
2054 (prepend(&end, &buflen, "//deleted", 9) != 0))
2055 goto Elong;
2056 if (buflen < 1)
2057 goto Elong;
2058
2059 retval = end-1;
2060 *retval = '/';
2061
2062 while (!IS_ROOT(dentry)) {
2063 struct dentry *parent = dentry->d_parent;
2064
2065 prefetch(parent);
2066 if ((prepend_name(&end, &buflen, &dentry->d_name) != 0) ||
2067 (prepend(&end, &buflen, "/", 1) != 0))
2068 goto Elong;
2069
2070 retval = end;
2071 dentry = parent;
2072 }
2073 spin_unlock(&dcache_lock);
2074 return retval;
2075Elong:
2076 spin_unlock(&dcache_lock);
2077 return ERR_PTR(-ENAMETOOLONG);
2078}
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098asmlinkage long sys_getcwd(char __user *buf, unsigned long size)
2099{
2100 int error;
2101 struct path pwd, root;
2102 char *page = (char *) __get_free_page(GFP_USER);
2103
2104 if (!page)
2105 return -ENOMEM;
2106
2107 read_lock(¤t->fs->lock);
2108 pwd = current->fs->pwd;
2109 path_get(&pwd);
2110 root = current->fs->root;
2111 path_get(&root);
2112 read_unlock(¤t->fs->lock);
2113
2114 error = -ENOENT;
2115
2116 spin_lock(&dcache_lock);
2117 if (IS_ROOT(pwd.dentry) || !d_unhashed(pwd.dentry)) {
2118 unsigned long len;
2119 struct path tmp = root;
2120 char * cwd;
2121
2122 cwd = __d_path(&pwd, &tmp, page, PAGE_SIZE);
2123 spin_unlock(&dcache_lock);
2124
2125 error = PTR_ERR(cwd);
2126 if (IS_ERR(cwd))
2127 goto out;
2128
2129 error = -ERANGE;
2130 len = PAGE_SIZE + page - cwd;
2131 if (len <= size) {
2132 error = len;
2133 if (copy_to_user(buf, cwd, len))
2134 error = -EFAULT;
2135 }
2136 } else
2137 spin_unlock(&dcache_lock);
2138
2139out:
2140 path_put(&pwd);
2141 path_put(&root);
2142 free_page((unsigned long) page);
2143 return error;
2144}
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162int is_subdir(struct dentry *new_dentry, struct dentry *old_dentry)
2163{
2164 int result;
2165 unsigned long seq;
2166
2167
2168 if (new_dentry == old_dentry)
2169 return 1;
2170
2171
2172
2173
2174
2175 rcu_read_lock();
2176 do {
2177
2178 seq = read_seqbegin(&rename_lock);
2179 if (d_ancestor(old_dentry, new_dentry))
2180 result = 1;
2181 else
2182 result = 0;
2183 } while (read_seqretry(&rename_lock, seq));
2184 rcu_read_unlock();
2185
2186 return result;
2187}
2188
2189void d_genocide(struct dentry *root)
2190{
2191 struct dentry *this_parent = root;
2192 struct list_head *next;
2193
2194 spin_lock(&dcache_lock);
2195repeat:
2196 next = this_parent->d_subdirs.next;
2197resume:
2198 while (next != &this_parent->d_subdirs) {
2199 struct list_head *tmp = next;
2200 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
2201 next = tmp->next;
2202 if (d_unhashed(dentry)||!dentry->d_inode)
2203 continue;
2204 if (!list_empty(&dentry->d_subdirs)) {
2205 this_parent = dentry;
2206 goto repeat;
2207 }
2208 atomic_dec(&dentry->d_count);
2209 }
2210 if (this_parent != root) {
2211 next = this_parent->d_u.d_child.next;
2212 atomic_dec(&this_parent->d_count);
2213 this_parent = this_parent->d_parent;
2214 goto resume;
2215 }
2216 spin_unlock(&dcache_lock);
2217}
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233ino_t find_inode_number(struct dentry *dir, struct qstr *name)
2234{
2235 struct dentry * dentry;
2236 ino_t ino = 0;
2237
2238 dentry = d_hash_and_lookup(dir, name);
2239 if (dentry) {
2240 if (dentry->d_inode)
2241 ino = dentry->d_inode->i_ino;
2242 dput(dentry);
2243 }
2244 return ino;
2245}
2246
2247static __initdata unsigned long dhash_entries;
2248static int __init set_dhash_entries(char *str)
2249{
2250 if (!str)
2251 return 0;
2252 dhash_entries = simple_strtoul(str, &str, 0);
2253 return 1;
2254}
2255__setup("dhash_entries=", set_dhash_entries);
2256
2257static void __init dcache_init_early(void)
2258{
2259 int loop;
2260
2261
2262
2263
2264 if (hashdist)
2265 return;
2266
2267 dentry_hashtable =
2268 alloc_large_system_hash("Dentry cache",
2269 sizeof(struct hlist_head),
2270 dhash_entries,
2271 13,
2272 HASH_EARLY,
2273 &d_hash_shift,
2274 &d_hash_mask,
2275 0);
2276
2277 for (loop = 0; loop < (1 << d_hash_shift); loop++)
2278 INIT_HLIST_HEAD(&dentry_hashtable[loop]);
2279}
2280
2281static void __init dcache_init(void)
2282{
2283 int loop;
2284
2285
2286
2287
2288
2289
2290 dentry_cache = KMEM_CACHE(dentry,
2291 SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD);
2292
2293 register_shrinker(&dcache_shrinker);
2294
2295
2296 if (!hashdist)
2297 return;
2298
2299 dentry_hashtable =
2300 alloc_large_system_hash("Dentry cache",
2301 sizeof(struct hlist_head),
2302 dhash_entries,
2303 13,
2304 0,
2305 &d_hash_shift,
2306 &d_hash_mask,
2307 0);
2308
2309 for (loop = 0; loop < (1 << d_hash_shift); loop++)
2310 INIT_HLIST_HEAD(&dentry_hashtable[loop]);
2311}
2312
2313
2314struct kmem_cache *names_cachep __read_mostly;
2315
2316
2317struct kmem_cache *filp_cachep __read_mostly;
2318
2319EXPORT_SYMBOL(d_genocide);
2320
2321void __init vfs_caches_init_early(void)
2322{
2323 dcache_init_early();
2324 inode_init_early();
2325}
2326
2327void __init vfs_caches_init(unsigned long mempages)
2328{
2329 unsigned long reserve;
2330
2331
2332
2333
2334 reserve = min((mempages - nr_free_pages()) * 3/2, mempages - 1);
2335 mempages -= reserve;
2336
2337 names_cachep = kmem_cache_create("names_cache", PATH_MAX, 0,
2338 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2339
2340 filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
2341 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2342
2343 dcache_init();
2344 inode_init();
2345 files_init(mempages);
2346 mnt_init();
2347 bdev_cache_init();
2348 chrdev_init();
2349}
2350
2351EXPORT_SYMBOL(d_alloc);
2352EXPORT_SYMBOL(d_alloc_root);
2353EXPORT_SYMBOL(d_delete);
2354EXPORT_SYMBOL(d_find_alias);
2355EXPORT_SYMBOL(d_instantiate);
2356EXPORT_SYMBOL(d_invalidate);
2357EXPORT_SYMBOL(d_lookup);
2358EXPORT_SYMBOL(d_move);
2359EXPORT_SYMBOL_GPL(d_materialise_unique);
2360EXPORT_SYMBOL(d_path);
2361EXPORT_SYMBOL(d_prune_aliases);
2362EXPORT_SYMBOL(d_rehash);
2363EXPORT_SYMBOL(d_splice_alias);
2364EXPORT_SYMBOL(d_add_ci);
2365EXPORT_SYMBOL(d_validate);
2366EXPORT_SYMBOL(dget_locked);
2367EXPORT_SYMBOL(dput);
2368EXPORT_SYMBOL(find_inode_number);
2369EXPORT_SYMBOL(have_submounts);
2370EXPORT_SYMBOL(names_cachep);
2371EXPORT_SYMBOL(shrink_dcache_parent);
2372EXPORT_SYMBOL(shrink_dcache_sb);