[net-next-2.6.git] / fs / gfs2 / dentry.c

/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU General Public License version 2.
 */

#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/gfs2_ondisk.h>
#include <linux/crc32.h>

#include "gfs2.h"
#include "incore.h"
#include "dir.h"
#include "glock.h"
#include "super.h"
#include "util.h"
#include "inode.h"

/**
 * gfs2_drevalidate - Check directory lookup consistency
 * @dentry: the mapping to check
 * @nd:
 *
 * Check to make sure the lookup necessary to arrive at this inode from its
 * parent is still good.
 *
 * Returns: 1 if the dentry is ok, 0 if it isn't
 */

static int gfs2_drevalidate(struct dentry *dentry, struct nameidata *nd)
{
	struct dentry *parent = dget_parent(dentry);
	struct gfs2_sbd *sdp = GFS2_SB(parent->d_inode);
	struct gfs2_inode *dip = GFS2_I(parent->d_inode);
	struct inode *inode = dentry->d_inode;
	struct gfs2_holder d_gh;
	struct gfs2_inode *ip = NULL;
	int error;
	int had_lock = 0;

	if (inode) {
		if (is_bad_inode(inode))
			goto invalid;
		ip = GFS2_I(inode);
	}

	if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
		goto valid;

	had_lock = (gfs2_glock_is_locked_by_me(dip->i_gl) != NULL);
	if (!had_lock) {
		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
		if (error)
			goto fail;
	} 

	error = gfs2_dir_check(parent->d_inode, &dentry->d_name, ip);
	switch (error) {
	case 0:
		if (!inode)
			goto invalid_gunlock;
		break;
	case -ENOENT:
		if (!inode)
			goto valid_gunlock;
		goto invalid_gunlock;
	default:
		goto fail_gunlock;
	}

valid_gunlock:
	if (!had_lock)
		gfs2_glock_dq_uninit(&d_gh);
valid:
	dput(parent);
	return 1;

invalid_gunlock:
	if (!had_lock)
		gfs2_glock_dq_uninit(&d_gh);
invalid:
	if (inode && S_ISDIR(inode->i_mode)) {
		if (have_submounts(dentry))
			goto valid;
		shrink_dcache_parent(dentry);
	}
	d_drop(dentry);
	dput(parent);
	return 0;

fail_gunlock:
	gfs2_glock_dq_uninit(&d_gh);
fail:
	dput(parent);
	return 0;
}

static int gfs2_dhash(struct dentry *dentry, struct qstr *str)
{
	str->hash = gfs2_disk_hash(str->name, str->len);
	return 0;
}

static int gfs2_dentry_delete(struct dentry *dentry)
{
	struct gfs2_inode *ginode;

	if (!dentry->d_inode)
		return 0;

	ginode = GFS2_I(dentry->d_inode);
	if (!ginode->i_iopen_gh.gh_gl)
		return 0;

	if (test_bit(GLF_DEMOTE, &ginode->i_iopen_gh.gh_gl->gl_flags))
		return 1;

	return 0;
}

const struct dentry_operations gfs2_dops = {
	.d_revalidate = gfs2_drevalidate,
	.d_hash = gfs2_dhash,
	.d_delete = gfs2_dentry_delete,
};
Commit	Line	Data
b3b94faa DT	1	/*
b3b94faa DT	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3a8a9a10	3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
b3b94faa DT	4	*
	5	* This copyrighted material is made available to anyone wishing to use,
	6	* modify, copy, or redistribute it subject to the terms and conditions
e9fc2aa0	7	* of the GNU General Public License version 2.
b3b94faa DT	8	*/
b3b94faa DT	9
b3b94faa DT	10	#include <linux/spinlock.h>
	11	#include <linux/completion.h>
	12	#include <linux/buffer_head.h>
5c676f6d	13	#include <linux/gfs2_ondisk.h>
71b86f56	14	#include <linux/crc32.h>
b3b94faa DT	15
b3b94faa DT	16	#include "gfs2.h"
5c676f6d	17	#include "incore.h"
b3b94faa DT	18	#include "dir.h"
b3b94faa DT	19	#include "glock.h"
b2760583	20	#include "super.h"
5c676f6d	21	#include "util.h"
dbb7cae2	22	#include "inode.h"
b3b94faa DT	23
	24	/**
	25	* gfs2_drevalidate - Check directory lookup consistency
	26	* @dentry: the mapping to check
	27	* @nd:
	28	*
	29	* Check to make sure the lookup necessary to arrive at this inode from its
	30	* parent is still good.
	31	*
	32	* Returns: 1 if the dentry is ok, 0 if it isn't
	33	*/
	34
	35	static int gfs2_drevalidate(struct dentry dentry, struct nameidata nd)
	36	{
	37	struct dentry *parent = dget_parent(dentry);
feaa7bba SW	38	struct gfs2_sbd *sdp = GFS2_SB(parent->d_inode);
feaa7bba SW	39	struct gfs2_inode *dip = GFS2_I(parent->d_inode);
c752666c	40	struct inode *inode = dentry->d_inode;
b3b94faa	41	struct gfs2_holder d_gh;
dbb7cae2	42	struct gfs2_inode *ip = NULL;
b3b94faa	43	int error;
7afd88d9	44	int had_lock = 0;
b3b94faa	45
dbb7cae2 SW	46	if (inode) {
	47	if (is_bad_inode(inode))
	48	goto invalid;
	49	ip = GFS2_I(inode);
	50	}
b3b94faa	51
c2048b00	52	if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
c752666c SW	53	goto valid;
c752666c SW	54
7afd88d9	55	had_lock = (gfs2_glock_is_locked_by_me(dip->i_gl) != NULL);
549ae0ac WC	56	if (!had_lock) {
	57	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
	58	if (error)
	59	goto fail;
	60	}
b3b94faa	61
dbb7cae2	62	error = gfs2_dir_check(parent->d_inode, &dentry->d_name, ip);
b3b94faa DT	63	switch (error) {
	64	case 0:
	65	if (!inode)
	66	goto invalid_gunlock;
	67	break;
	68	case -ENOENT:
	69	if (!inode)
	70	goto valid_gunlock;
	71	goto invalid_gunlock;
	72	default:
	73	goto fail_gunlock;
	74	}
	75
a91ea69f	76	valid_gunlock:
549ae0ac WC	77	if (!had_lock)
549ae0ac WC	78	gfs2_glock_dq_uninit(&d_gh);
a91ea69f	79	valid:
b3b94faa DT	80	dput(parent);
	81	return 1;
	82
a91ea69f	83	invalid_gunlock:
549ae0ac WC	84	if (!had_lock)
549ae0ac WC	85	gfs2_glock_dq_uninit(&d_gh);
a91ea69f	86	invalid:
b3b94faa DT	87	if (inode && S_ISDIR(inode->i_mode)) {
	88	if (have_submounts(dentry))
	89	goto valid;
	90	shrink_dcache_parent(dentry);
	91	}
	92	d_drop(dentry);
b3b94faa DT	93	dput(parent);
	94	return 0;
	95
a91ea69f	96	fail_gunlock:
b3b94faa	97	gfs2_glock_dq_uninit(&d_gh);
a91ea69f	98	fail:
b3b94faa DT	99	dput(parent);
	100	return 0;
	101	}
	102
c752666c SW	103	static int gfs2_dhash(struct dentry dentry, struct qstr str)
	104	{
	105	str->hash = gfs2_disk_hash(str->name, str->len);
	106	return 0;
	107	}
	108
970343cd WW	109	static int gfs2_dentry_delete(struct dentry *dentry)
	110	{
	111	struct gfs2_inode *ginode;
	112
	113	if (!dentry->d_inode)
	114	return 0;
	115
	116	ginode = GFS2_I(dentry->d_inode);
	117	if (!ginode->i_iopen_gh.gh_gl)
	118	return 0;
	119
	120	if (test_bit(GLF_DEMOTE, &ginode->i_iopen_gh.gh_gl->gl_flags))
	121	return 1;
	122
	123	return 0;
	124	}
	125
92cecbbf	126	const struct dentry_operations gfs2_dops = {
b3b94faa	127	.d_revalidate = gfs2_drevalidate,
c752666c	128	.d_hash = gfs2_dhash,
970343cd	129	.d_delete = gfs2_dentry_delete,
b3b94faa DT	130	};
b3b94faa DT	131