[linux-2.6-block.git] / fs / autofs / dirhash.c

/* -*- linux-c -*- --------------------------------------------------------- *
 *
 * linux/fs/autofs/dirhash.c
 *
 *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
 *
 * This file is part of the Linux kernel and is made available under
 * the terms of the GNU General Public License, version 2, or at your
 * option, any later version, incorporated herein by reference.
 *
 * ------------------------------------------------------------------------- */

#include "autofs_i.h"

/* Functions for maintenance of expiry queue */

static void autofs_init_usage(struct autofs_dirhash *dh,
			      struct autofs_dir_ent *ent)
{
	list_add_tail(&ent->exp, &dh->expiry_head);
	ent->last_usage = jiffies;
}

static void autofs_delete_usage(struct autofs_dir_ent *ent)
{
	list_del(&ent->exp);
}

void autofs_update_usage(struct autofs_dirhash *dh,
			 struct autofs_dir_ent *ent)
{
	autofs_delete_usage(ent);   /* Unlink from current position */
	autofs_init_usage(dh,ent);  /* Relink at queue tail */
}

struct autofs_dir_ent *autofs_expire(struct super_block *sb,
				     struct autofs_sb_info *sbi,
				     struct vfsmount *mnt)
{
	struct autofs_dirhash *dh = &sbi->dirhash;
	struct autofs_dir_ent *ent;
	struct dentry *dentry;
	unsigned long timeout = sbi->exp_timeout;

	while (1) {
		if ( list_empty(&dh->expiry_head) || sbi->catatonic )
			return NULL;	/* No entries */
		/* We keep the list sorted by last_usage and want old stuff */
		ent = list_entry(dh->expiry_head.next, struct autofs_dir_ent, exp);
		if (jiffies - ent->last_usage < timeout)
			break;
		/* Move to end of list in case expiry isn't desirable */
		autofs_update_usage(dh, ent);

		/* Check to see that entry is expirable */
		if ( ent->ino < AUTOFS_FIRST_DIR_INO )
			return ent; /* Symlinks are always expirable */

		/* Get the dentry for the autofs subdirectory */
		dentry = ent->dentry;

		if ( !dentry ) {
			/* Should only happen in catatonic mode */
			printk("autofs: dentry == NULL but inode range is directory, entry %s\n", ent->name);
			autofs_delete_usage(ent);
			continue;
		}

		if ( !dentry->d_inode ) {
			dput(dentry);
			printk("autofs: negative dentry on expiry queue: %s\n",
			       ent->name);
			autofs_delete_usage(ent);
			continue;
		}

		/* Make sure entry is mounted and unused; note that dentry will
		   point to the mounted-on-top root. */
		if (!S_ISDIR(dentry->d_inode->i_mode)||!d_mountpoint(dentry)) {
			DPRINTK(("autofs: not expirable (not a mounted directory): %s\n", ent->name));
			continue;
		}
		mntget(mnt);
		dget(dentry);
		if (!follow_down(&mnt, &dentry)) {
			dput(dentry);
			mntput(mnt);
			DPRINTK(("autofs: not expirable (not a mounted directory): %s\n", ent->name));
			continue;
		}
		while (d_mountpoint(dentry) && follow_down(&mnt, &dentry))
			;
		dput(dentry);

		if ( may_umount(mnt) ) {
			mntput(mnt);
			DPRINTK(("autofs: signaling expire on %s\n", ent->name));
			return ent; /* Expirable! */
		}
		DPRINTK(("autofs: didn't expire due to may_umount: %s\n", ent->name));
		mntput(mnt);
	}
	return NULL;		/* No expirable entries */
}

void autofs_initialize_hash(struct autofs_dirhash *dh) {
	memset(&dh->h, 0, AUTOFS_HASH_SIZE*sizeof(struct autofs_dir_ent *));
	INIT_LIST_HEAD(&dh->expiry_head);
}

struct autofs_dir_ent *autofs_hash_lookup(const struct autofs_dirhash *dh, struct qstr *name)
{
	struct autofs_dir_ent *dhn;

	DPRINTK(("autofs_hash_lookup: hash = 0x%08x, name = ", name->hash));
	autofs_say(name->name,name->len);

	for ( dhn = dh->h[(unsigned) name->hash % AUTOFS_HASH_SIZE] ; dhn ; dhn = dhn->next ) {
		if ( name->hash == dhn->hash &&
		     name->len == dhn->len &&
		     !memcmp(name->name, dhn->name, name->len) )
			break;
	}

	return dhn;
}

void autofs_hash_insert(struct autofs_dirhash *dh, struct autofs_dir_ent *ent)
{
	struct autofs_dir_ent **dhnp;

	DPRINTK(("autofs_hash_insert: hash = 0x%08x, name = ", ent->hash));
	autofs_say(ent->name,ent->len);

	autofs_init_usage(dh,ent);
	if (ent->dentry)
		dget(ent->dentry);

	dhnp = &dh->h[(unsigned) ent->hash % AUTOFS_HASH_SIZE];
	ent->next = *dhnp;
	ent->back = dhnp;
	*dhnp = ent;
	if ( ent->next )
		ent->next->back = &(ent->next);
}

void autofs_hash_delete(struct autofs_dir_ent *ent)
{
	*(ent->back) = ent->next;
	if ( ent->next )
		ent->next->back = ent->back;

	autofs_delete_usage(ent);

	if ( ent->dentry )
		dput(ent->dentry);
	kfree(ent->name);
	kfree(ent);
}

/*
 * Used by readdir().  We must validate "ptr", so we can't simply make it
 * a pointer.  Values below 0xffff are reserved; calling with any value
 * <= 0x10000 will return the first entry found.
 *
 * "last" can be NULL or the value returned by the last search *if* we
 * want the next sequential entry.
 */
struct autofs_dir_ent *autofs_hash_enum(const struct autofs_dirhash *dh,
					off_t *ptr, struct autofs_dir_ent *last)
{
	int bucket, ecount, i;
	struct autofs_dir_ent *ent;

	bucket = (*ptr >> 16) - 1;
	ecount = *ptr & 0xffff;

	if ( bucket < 0 ) {
		bucket = ecount = 0;
	} 

	DPRINTK(("autofs_hash_enum: bucket %d, entry %d\n", bucket, ecount));

	ent = last ? last->next : NULL;

	if ( ent ) {
		ecount++;
	} else {
		while  ( bucket < AUTOFS_HASH_SIZE ) {
			ent = dh->h[bucket];
			for ( i = ecount ; ent && i ; i-- )
				ent = ent->next;
			
			if (ent) {
				ecount++; /* Point to *next* entry */
				break;
			}
			
			bucket++; ecount = 0;
		}
	}

#ifdef DEBUG
	if ( !ent )
		printk("autofs_hash_enum: nothing found\n");
	else {
		printk("autofs_hash_enum: found hash %08x, name", ent->hash);
		autofs_say(ent->name,ent->len);
	}
#endif

	*ptr = ((bucket+1) << 16) + ecount;
	return ent;
}

/* Iterate over all the ents, and remove all dentry pointers.  Used on
   entering catatonic mode, in order to make the filesystem unmountable. */
void autofs_hash_dputall(struct autofs_dirhash *dh)
{
	int i;
	struct autofs_dir_ent *ent;

	for ( i = 0 ; i < AUTOFS_HASH_SIZE ; i++ ) {
		for ( ent = dh->h[i] ; ent ; ent = ent->next ) {
			if ( ent->dentry ) {
				dput(ent->dentry);
				ent->dentry = NULL;
			}
		}
	}
}

/* Delete everything.  This is used on filesystem destruction, so we
   make no attempt to keep the pointers valid */
void autofs_hash_nuke(struct autofs_sb_info *sbi)
{
	int i;
	struct autofs_dir_ent *ent, *nent;

	for ( i = 0 ; i < AUTOFS_HASH_SIZE ; i++ ) {
		for ( ent = sbi->dirhash.h[i] ; ent ; ent = nent ) {
			nent = ent->next;
			if ( ent->dentry )
				dput(ent->dentry);
			kfree(ent->name);
			kfree(ent);
		}
	}
}
Commit	Line	Data
1da177e4 LT	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
	17	static 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
	24	static void autofs_delete_usage(struct autofs_dir_ent *ent)
	25	{
	26	list_del(&ent->exp);
	27	}
	28
	29	void 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
	36	struct 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
e3474a8e	95	if ( may_umount(mnt) ) {
1da177e4 LT	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
	106	void autofs_initialize_hash(struct autofs_dirhash *dh) {
	107	memset(&dh->h, 0, AUTOFS_HASH_SIZEsizeof(struct autofs_dir_ent ));
	108	INIT_LIST_HEAD(&dh->expiry_head);
	109	}
	110
	111	struct 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
	128	void 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
	147	void 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	*/
169	struct 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. */
218	void 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 */
f76baf93	235	void autofs_hash_nuke(struct autofs_sb_info *sbi)
1da177e4 LT	236	{
	237	int i;
	238	struct autofs_dir_ent ent, nent;
	239
	240	for ( i = 0 ; i < AUTOFS_HASH_SIZE ; i++ ) {
f76baf93	241	for ( ent = sbi->dirhash.h[i] ; ent ; ent = nent ) {
1da177e4 LT	242	nent = ent->next;
	243	if ( ent->dentry )
	244	dput(ent->dentry);
	245	kfree(ent->name);
	246	kfree(ent);
	247	}
	248	}
	249	}