1/* -*- linux-c -*- --------------------------------------------------------- *
2 *
3 * linux/fs/autofs/dirhash.c
4 *
5 *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
6 *
7 * This file is part of the Linux kernel and is made available under
8 * the terms of the GNU General Public License, version 2, or at your
9 * option, any later version, incorporated herein by reference.
10 *
11 * ------------------------------------------------------------------------- */
12
13#include "autofs_i.h"
14
15/* Functions for maintenance of expiry queue */
16
17static void autofs_init_usage(struct autofs_dirhash *dh,
18			      struct autofs_dir_ent *ent)
19{
20	list_add_tail(&ent->exp, &dh->expiry_head);
21	ent->last_usage = jiffies;
22}
23
24static void autofs_delete_usage(struct autofs_dir_ent *ent)
25{
26	list_del(&ent->exp);
27}
28
29void autofs_update_usage(struct autofs_dirhash *dh,
30			 struct autofs_dir_ent *ent)
31{
32	autofs_delete_usage(ent);   /* Unlink from current position */
33	autofs_init_usage(dh,ent);  /* Relink at queue tail */
34}
35
36struct autofs_dir_ent *autofs_expire(struct super_block *sb,
37				     struct autofs_sb_info *sbi,
38				     struct vfsmount *mnt)
39{
40	struct autofs_dirhash *dh = &sbi->dirhash;
41	struct autofs_dir_ent *ent;
42	struct dentry *dentry;
43	unsigned long timeout = sbi->exp_timeout;
44
45	while (1) {
46		if ( list_empty(&dh->expiry_head) || sbi->catatonic )
47			return NULL;	/* No entries */
48		/* We keep the list sorted by last_usage and want old stuff */
49		ent = list_entry(dh->expiry_head.next, struct autofs_dir_ent, exp);
50		if (jiffies - ent->last_usage < timeout)
51			break;
52		/* Move to end of list in case expiry isn't desirable */
53		autofs_update_usage(dh, ent);
54
55		/* Check to see that entry is expirable */
56		if ( ent->ino < AUTOFS_FIRST_DIR_INO )
57			return ent; /* Symlinks are always expirable */
58
59		/* Get the dentry for the autofs subdirectory */
60		dentry = ent->dentry;
61
62		if ( !dentry ) {
63			/* Should only happen in catatonic mode */
64			printk("autofs: dentry == NULL but inode range is directory, entry %s\n", ent->name);
65			autofs_delete_usage(ent);
66			continue;
67		}
68
69		if ( !dentry->d_inode ) {
70			dput(dentry);
71			printk("autofs: negative dentry on expiry queue: %s\n",
72			       ent->name);
73			autofs_delete_usage(ent);
74			continue;
75		}
76
77		/* Make sure entry is mounted and unused; note that dentry will
78		   point to the mounted-on-top root. */
79		if (!S_ISDIR(dentry->d_inode->i_mode)||!d_mountpoint(dentry)) {
80			DPRINTK(("autofs: not expirable (not a mounted directory): %s\n", ent->name));
81			continue;
82		}
83		mntget(mnt);
84		dget(dentry);
85		if (!follow_down(&mnt, &dentry)) {
86			dput(dentry);
87			mntput(mnt);
88			DPRINTK(("autofs: not expirable (not a mounted directory): %s\n", ent->name));
89			continue;
90		}
91		while (d_mountpoint(dentry) && follow_down(&mnt, &dentry))
92			;
93		dput(dentry);
94
95		if ( may_umount(mnt) ) {
96			mntput(mnt);
97			DPRINTK(("autofs: signaling expire on %s\n", ent->name));
98			return ent; /* Expirable! */
99		}
100		DPRINTK(("autofs: didn't expire due to may_umount: %s\n", ent->name));
101		mntput(mnt);
102	}
103	return NULL;		/* No expirable entries */
104}
105
106void autofs_initialize_hash(struct autofs_dirhash *dh) {
107	memset(&dh->h, 0, AUTOFS_HASH_SIZE*sizeof(struct autofs_dir_ent *));
108	INIT_LIST_HEAD(&dh->expiry_head);
109}
110
111struct autofs_dir_ent *autofs_hash_lookup(const struct autofs_dirhash *dh, struct qstr *name)
112{
113	struct autofs_dir_ent *dhn;
114
115	DPRINTK(("autofs_hash_lookup: hash = 0x%08x, name = ", name->hash));
116	autofs_say(name->name,name->len);
117
118	for ( dhn = dh->h[(unsigned) name->hash % AUTOFS_HASH_SIZE] ; dhn ; dhn = dhn->next ) {
119		if ( name->hash == dhn->hash &&
120		     name->len == dhn->len &&
121		     !memcmp(name->name, dhn->name, name->len) )
122			break;
123	}
124
125	return dhn;
126}
127
128void autofs_hash_insert(struct autofs_dirhash *dh, struct autofs_dir_ent *ent)
129{
130	struct autofs_dir_ent **dhnp;
131
132	DPRINTK(("autofs_hash_insert: hash = 0x%08x, name = ", ent->hash));
133	autofs_say(ent->name,ent->len);
134
135	autofs_init_usage(dh,ent);
136	if (ent->dentry)
137		dget(ent->dentry);
138
139	dhnp = &dh->h[(unsigned) ent->hash % AUTOFS_HASH_SIZE];
140	ent->next = *dhnp;
141	ent->back = dhnp;
142	*dhnp = ent;
143	if ( ent->next )
144		ent->next->back = &(ent->next);
145}
146
147void autofs_hash_delete(struct autofs_dir_ent *ent)
148{
149	*(ent->back) = ent->next;
150	if ( ent->next )
151		ent->next->back = ent->back;
152
153	autofs_delete_usage(ent);
154
155	if ( ent->dentry )
156		dput(ent->dentry);
157	kfree(ent->name);
158	kfree(ent);
159}
160
161/*
162 * Used by readdir().  We must validate "ptr", so we can't simply make it
163 * a pointer.  Values below 0xffff are reserved; calling with any value
164 * <= 0x10000 will return the first entry found.
165 *
166 * "last" can be NULL or the value returned by the last search *if* we
167 * want the next sequential entry.
168 */
169struct autofs_dir_ent *autofs_hash_enum(const struct autofs_dirhash *dh,
170					off_t *ptr, struct autofs_dir_ent *last)
171{
172	int bucket, ecount, i;
173	struct autofs_dir_ent *ent;
174
175	bucket = (*ptr >> 16) - 1;
176	ecount = *ptr & 0xffff;
177
178	if ( bucket < 0 ) {
179		bucket = ecount = 0;
180	}
181
182	DPRINTK(("autofs_hash_enum: bucket %d, entry %d\n", bucket, ecount));
183
184	ent = last ? last->next : NULL;
185
186	if ( ent ) {
187		ecount++;
188	} else {
189		while  ( bucket < AUTOFS_HASH_SIZE ) {
190			ent = dh->h[bucket];
191			for ( i = ecount ; ent && i ; i-- )
192				ent = ent->next;
193
194			if (ent) {
195				ecount++; /* Point to *next* entry */
196				break;
197			}
198
199			bucket++; ecount = 0;
200		}
201	}
202
203#ifdef DEBUG
204	if ( !ent )
205		printk("autofs_hash_enum: nothing found\n");
206	else {
207		printk("autofs_hash_enum: found hash %08x, name", ent->hash);
208		autofs_say(ent->name,ent->len);
209	}
210#endif
211
212	*ptr = ((bucket+1) << 16) + ecount;
213	return ent;
214}
215
216/* Iterate over all the ents, and remove all dentry pointers.  Used on
217   entering catatonic mode, in order to make the filesystem unmountable. */
218void autofs_hash_dputall(struct autofs_dirhash *dh)
219{
220	int i;
221	struct autofs_dir_ent *ent;
222
223	for ( i = 0 ; i < AUTOFS_HASH_SIZE ; i++ ) {
224		for ( ent = dh->h[i] ; ent ; ent = ent->next ) {
225			if ( ent->dentry ) {
226				dput(ent->dentry);
227				ent->dentry = NULL;
228			}
229		}
230	}
231}
232
233/* Delete everything.  This is used on filesystem destruction, so we
234   make no attempt to keep the pointers valid */
235void autofs_hash_nuke(struct autofs_sb_info *sbi)
236{
237	int i;
238	struct autofs_dir_ent *ent, *nent;
239
240	for ( i = 0 ; i < AUTOFS_HASH_SIZE ; i++ ) {
241		for ( ent = sbi->dirhash.h[i] ; ent ; ent = nent ) {
242			nent = ent->next;
243			if ( ent->dentry )
244				dput(ent->dentry);
245			kfree(ent->name);
246			kfree(ent);
247		}
248	}
249}
250