[deliverable/linux.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/namei.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
 * @flags: lookup flags
 *
 * 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, unsigned int flags)
{
	struct dentry *parent;
	struct gfs2_sbd *sdp;
	struct gfs2_inode *dip;
	struct inode *inode;
	struct gfs2_holder d_gh;
	struct gfs2_inode *ip = NULL;
	int error;
	int had_lock = 0;

	if (flags & LOOKUP_RCU)
		return -ECHILD;

	parent = dget_parent(dentry);
	sdp = GFS2_SB(parent->d_inode);
	dip = GFS2_I(parent->d_inode);
	inode = dentry->d_inode;

	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:
	dput(parent);
	return 0;

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

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

static int gfs2_dentry_delete(const 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>
34286d66	14	#include <linux/namei.h>
71b86f56	15	#include <linux/crc32.h>
b3b94faa DT	16
b3b94faa DT	17	#include "gfs2.h"
5c676f6d	18	#include "incore.h"
b3b94faa DT	19	#include "dir.h"
b3b94faa DT	20	#include "glock.h"
b2760583	21	#include "super.h"
5c676f6d	22	#include "util.h"
dbb7cae2	23	#include "inode.h"
b3b94faa DT	24
	25	/**
	26	* gfs2_drevalidate - Check directory lookup consistency
	27	* @dentry: the mapping to check
0b728e19	28	* @flags: lookup flags
b3b94faa DT	29	*
	30	* Check to make sure the lookup necessary to arrive at this inode from its
	31	* parent is still good.
	32	*
	33	* Returns: 1 if the dentry is ok, 0 if it isn't
	34	*/
	35
0b728e19	36	static int gfs2_drevalidate(struct dentry *dentry, unsigned int flags)
b3b94faa	37	{
34286d66 NP	38	struct dentry *parent;
	39	struct gfs2_sbd *sdp;
	40	struct gfs2_inode *dip;
	41	struct inode *inode;
b3b94faa	42	struct gfs2_holder d_gh;
dbb7cae2	43	struct gfs2_inode *ip = NULL;
b3b94faa	44	int error;
7afd88d9	45	int had_lock = 0;
b3b94faa	46
0b728e19	47	if (flags & LOOKUP_RCU)
34286d66 NP	48	return -ECHILD;
	49
	50	parent = dget_parent(dentry);
	51	sdp = GFS2_SB(parent->d_inode);
	52	dip = GFS2_I(parent->d_inode);
	53	inode = dentry->d_inode;
	54
dbb7cae2 SW	55	if (inode) {
	56	if (is_bad_inode(inode))
	57	goto invalid;
	58	ip = GFS2_I(inode);
	59	}
b3b94faa	60
c2048b00	61	if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
c752666c SW	62	goto valid;
c752666c SW	63
7afd88d9	64	had_lock = (gfs2_glock_is_locked_by_me(dip->i_gl) != NULL);
549ae0ac WC	65	if (!had_lock) {
	66	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
	67	if (error)
	68	goto fail;
	69	}
b3b94faa	70
dbb7cae2	71	error = gfs2_dir_check(parent->d_inode, &dentry->d_name, ip);
b3b94faa DT	72	switch (error) {
	73	case 0:
	74	if (!inode)
	75	goto invalid_gunlock;
	76	break;
	77	case -ENOENT:
	78	if (!inode)
	79	goto valid_gunlock;
	80	goto invalid_gunlock;
	81	default:
	82	goto fail_gunlock;
	83	}
	84
a91ea69f	85	valid_gunlock:
549ae0ac WC	86	if (!had_lock)
549ae0ac WC	87	gfs2_glock_dq_uninit(&d_gh);
a91ea69f	88	valid:
b3b94faa DT	89	dput(parent);
	90	return 1;
	91
a91ea69f	92	invalid_gunlock:
549ae0ac WC	93	if (!had_lock)
549ae0ac WC	94	gfs2_glock_dq_uninit(&d_gh);
a91ea69f	95	invalid:
b3b94faa DT	96	dput(parent);
	97	return 0;
	98
a91ea69f	99	fail_gunlock:
b3b94faa	100	gfs2_glock_dq_uninit(&d_gh);
a91ea69f	101	fail:
b3b94faa DT	102	dput(parent);
	103	return 0;
	104	}
	105
da53be12	106	static int gfs2_dhash(const struct dentry dentry, struct qstr str)
c752666c SW	107	{
	108	str->hash = gfs2_disk_hash(str->name, str->len);
	109	return 0;
	110	}
	111
fe15ce44	112	static int gfs2_dentry_delete(const struct dentry *dentry)
970343cd WW	113	{
	114	struct gfs2_inode *ginode;
	115
	116	if (!dentry->d_inode)
	117	return 0;
	118
	119	ginode = GFS2_I(dentry->d_inode);
	120	if (!ginode->i_iopen_gh.gh_gl)
	121	return 0;
	122
	123	if (test_bit(GLF_DEMOTE, &ginode->i_iopen_gh.gh_gl->gl_flags))
	124	return 1;
	125
	126	return 0;
	127	}
	128
92cecbbf	129	const struct dentry_operations gfs2_dops = {
b3b94faa	130	.d_revalidate = gfs2_drevalidate,
c752666c	131	.d_hash = gfs2_dhash,
970343cd	132	.d_delete = gfs2_dentry_delete,
b3b94faa DT	133	};
b3b94faa DT	134