[net-next-2.6.git] / fs / isofs / export.c

/*
 * fs/isofs/export.c
 *
 *  (C) 2004  Paul Serice - The new inode scheme requires switching
 *                          from iget() to iget5_locked() which means
 *                          the NFS export operations have to be hand
 *                          coded because the default routines rely on
 *                          iget().
 *
 * The following files are helpful:
 *
 *     Documentation/filesystems/nfs/Exporting
 *     fs/exportfs/expfs.c.
 */

#include "isofs.h"

static struct dentry *
isofs_export_iget(struct super_block *sb,
		  unsigned long block,
		  unsigned long offset,
		  __u32 generation)
{
	struct inode *inode;

	if (block == 0)
		return ERR_PTR(-ESTALE);
	inode = isofs_iget(sb, block, offset);
	if (IS_ERR(inode))
		return ERR_CAST(inode);
	if (generation && inode->i_generation != generation) {
		iput(inode);
		return ERR_PTR(-ESTALE);
	}
	return d_obtain_alias(inode);
}

/* This function is surprisingly simple.  The trick is understanding
 * that "child" is always a directory. So, to find its parent, you
 * simply need to find its ".." entry, normalize its block and offset,
 * and return the underlying inode.  See the comments for
 * isofs_normalize_block_and_offset(). */
static struct dentry *isofs_export_get_parent(struct dentry *child)
{
	unsigned long parent_block = 0;
	unsigned long parent_offset = 0;
	struct inode *child_inode = child->d_inode;
	struct iso_inode_info *e_child_inode = ISOFS_I(child_inode);
	struct iso_directory_record *de = NULL;
	struct buffer_head * bh = NULL;
	struct dentry *rv = NULL;

	/* "child" must always be a directory. */
	if (!S_ISDIR(child_inode->i_mode)) {
		printk(KERN_ERR "isofs: isofs_export_get_parent(): "
		       "child is not a directory!\n");
		rv = ERR_PTR(-EACCES);
		goto out;
	}

	/* It is an invariant that the directory offset is zero.  If
	 * it is not zero, it means the directory failed to be
	 * normalized for some reason. */
	if (e_child_inode->i_iget5_offset != 0) {
		printk(KERN_ERR "isofs: isofs_export_get_parent(): "
		       "child directory not normalized!\n");
		rv = ERR_PTR(-EACCES);
		goto out;
	}

	/* The child inode has been normalized such that its
	 * i_iget5_block value points to the "." entry.  Fortunately,
	 * the ".." entry is located in the same block. */
	parent_block = e_child_inode->i_iget5_block;

	/* Get the block in question. */
	bh = sb_bread(child_inode->i_sb, parent_block);
	if (bh == NULL) {
		rv = ERR_PTR(-EACCES);
		goto out;
	}

	/* This is the "." entry. */
	de = (struct iso_directory_record*)bh->b_data;

	/* The ".." entry is always the second entry. */
	parent_offset = (unsigned long)isonum_711(de->length);
	de = (struct iso_directory_record*)(bh->b_data + parent_offset);

	/* Verify it is in fact the ".." entry. */
	if ((isonum_711(de->name_len) != 1) || (de->name[0] != 1)) {
		printk(KERN_ERR "isofs: Unable to find the \"..\" "
		       "directory for NFS.\n");
		rv = ERR_PTR(-EACCES);
		goto out;
	}

	/* Normalize */
	isofs_normalize_block_and_offset(de, &parent_block, &parent_offset);

	rv = d_obtain_alias(isofs_iget(child_inode->i_sb, parent_block,
				     parent_offset));
 out:
	if (bh)
		brelse(bh);
	return rv;
}

static int
isofs_export_encode_fh(struct dentry *dentry,
		       __u32 *fh32,
		       int *max_len,
		       int connectable)
{
	struct inode * inode = dentry->d_inode;
	struct iso_inode_info * ei = ISOFS_I(inode);
	int len = *max_len;
	int type = 1;
	__u16 *fh16 = (__u16*)fh32;

	/*
	 * WARNING: max_len is 5 for NFSv2.  Because of this
	 * limitation, we use the lower 16 bits of fh32[1] to hold the
	 * offset of the inode and the upper 16 bits of fh32[1] to
	 * hold the offset of the parent.
	 */

	if (len < 3 || (connectable && len < 5))
		return 255;

	len = 3;
	fh32[0] = ei->i_iget5_block;
 	fh16[2] = (__u16)ei->i_iget5_offset;  /* fh16 [sic] */
	fh32[2] = inode->i_generation;
	if (connectable && !S_ISDIR(inode->i_mode)) {
		struct inode *parent;
		struct iso_inode_info *eparent;
		spin_lock(&dentry->d_lock);
		parent = dentry->d_parent->d_inode;
		eparent = ISOFS_I(parent);
		fh32[3] = eparent->i_iget5_block;
		fh16[3] = (__u16)eparent->i_iget5_offset;  /* fh16 [sic] */
		fh32[4] = parent->i_generation;
		spin_unlock(&dentry->d_lock);
		len = 5;
		type = 2;
	}
	*max_len = len;
	return type;
}

struct isofs_fid {
	u32 block;
	u16 offset;
	u16 parent_offset;
	u32 generation;
	u32 parent_block;
	u32 parent_generation;
};

static struct dentry *isofs_fh_to_dentry(struct super_block *sb,
	struct fid *fid, int fh_len, int fh_type)
{
	struct isofs_fid *ifid = (struct isofs_fid *)fid;

	if (fh_len < 3 || fh_type > 2)
		return NULL;

	return isofs_export_iget(sb, ifid->block, ifid->offset,
			ifid->generation);
}

static struct dentry *isofs_fh_to_parent(struct super_block *sb,
		struct fid *fid, int fh_len, int fh_type)
{
	struct isofs_fid *ifid = (struct isofs_fid *)fid;

	if (fh_type != 2)
		return NULL;

	return isofs_export_iget(sb,
			fh_len > 2 ? ifid->parent_block : 0,
			ifid->parent_offset,
			fh_len > 4 ? ifid->parent_generation : 0);
}

const struct export_operations isofs_export_ops = {
	.encode_fh	= isofs_export_encode_fh,
	.fh_to_dentry	= isofs_fh_to_dentry,
	.fh_to_parent	= isofs_fh_to_parent,
	.get_parent     = isofs_export_get_parent,
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* fs/isofs/export.c
	3	*
	4	* (C) 2004 Paul Serice - The new inode scheme requires switching
	5	* from iget() to iget5_locked() which means
	6	* the NFS export operations have to be hand
	7	* coded because the default routines rely on
	8	* iget().
	9	*
	10	* The following files are helpful:
	11	*
dc7a0816	12	* Documentation/filesystems/nfs/Exporting
1da177e4 LT	13	* fs/exportfs/expfs.c.
	14	*/
	15
94f2f715	16	#include "isofs.h"
1da177e4 LT	17
	18	static struct dentry *
	19	isofs_export_iget(struct super_block *sb,
	20	unsigned long block,
	21	unsigned long offset,
	22	__u32 generation)
	23	{
	24	struct inode *inode;
44003728	25
1da177e4 LT	26	if (block == 0)
	27	return ERR_PTR(-ESTALE);
	28	inode = isofs_iget(sb, block, offset);
c4386c83 DH	29	if (IS_ERR(inode))
	30	return ERR_CAST(inode);
	31	if (generation && inode->i_generation != generation) {
1da177e4 LT	32	iput(inode);
	33	return ERR_PTR(-ESTALE);
	34	}
44003728	35	return d_obtain_alias(inode);
1da177e4 LT	36	}
1da177e4 LT	37
1da177e4 LT	38	/* This function is surprisingly simple. The trick is understanding
	39	* that "child" is always a directory. So, to find its parent, you
	40	* simply need to find its ".." entry, normalize its block and offset,
	41	* and return the underlying inode. See the comments for
	42	* isofs_normalize_block_and_offset(). */
	43	static struct dentry isofs_export_get_parent(struct dentry child)
	44	{
	45	unsigned long parent_block = 0;
	46	unsigned long parent_offset = 0;
	47	struct inode *child_inode = child->d_inode;
	48	struct iso_inode_info *e_child_inode = ISOFS_I(child_inode);
1da177e4 LT	49	struct iso_directory_record *de = NULL;
	50	struct buffer_head * bh = NULL;
	51	struct dentry *rv = NULL;
	52
	53	/* "child" must always be a directory. */
	54	if (!S_ISDIR(child_inode->i_mode)) {
	55	printk(KERN_ERR "isofs: isofs_export_get_parent(): "
	56	"child is not a directory!\n");
	57	rv = ERR_PTR(-EACCES);
	58	goto out;
	59	}
	60
	61	/* It is an invariant that the directory offset is zero. If
	62	* it is not zero, it means the directory failed to be
	63	* normalized for some reason. */
	64	if (e_child_inode->i_iget5_offset != 0) {
	65	printk(KERN_ERR "isofs: isofs_export_get_parent(): "
	66	"child directory not normalized!\n");
	67	rv = ERR_PTR(-EACCES);
	68	goto out;
	69	}
	70
	71	/* The child inode has been normalized such that its
	72	* i_iget5_block value points to the "." entry. Fortunately,
	73	* the ".." entry is located in the same block. */
	74	parent_block = e_child_inode->i_iget5_block;
	75
	76	/* Get the block in question. */
	77	bh = sb_bread(child_inode->i_sb, parent_block);
	78	if (bh == NULL) {
	79	rv = ERR_PTR(-EACCES);
	80	goto out;
	81	}
	82
	83	/* This is the "." entry. */
	84	de = (struct iso_directory_record*)bh->b_data;
	85
	86	/* The ".." entry is always the second entry. */
	87	parent_offset = (unsigned long)isonum_711(de->length);
	88	de = (struct iso_directory_record*)(bh->b_data + parent_offset);
	89
	90	/* Verify it is in fact the ".." entry. */
	91	if ((isonum_711(de->name_len) != 1) \|\| (de->name[0] != 1)) {
	92	printk(KERN_ERR "isofs: Unable to find the \"..\" "
	93	"directory for NFS.\n");
	94	rv = ERR_PTR(-EACCES);
	95	goto out;
	96	}
	97
	98	/* Normalize */
	99	isofs_normalize_block_and_offset(de, &parent_block, &parent_offset);
	100
44003728 CH	101	rv = d_obtain_alias(isofs_iget(child_inode->i_sb, parent_block,
44003728 CH	102	parent_offset));
1da177e4	103	out:
44003728	104	if (bh)
1da177e4	105	brelse(bh);
1da177e4 LT	106	return rv;
	107	}
	108
	109	static int
	110	isofs_export_encode_fh(struct dentry *dentry,
	111	__u32 *fh32,
	112	int *max_len,
	113	int connectable)
	114	{
	115	struct inode * inode = dentry->d_inode;
	116	struct iso_inode_info * ei = ISOFS_I(inode);
	117	int len = *max_len;
	118	int type = 1;
	119	__u16 fh16 = (__u16)fh32;
	120
	121	/*
	122	* WARNING: max_len is 5 for NFSv2. Because of this
	123	* limitation, we use the lower 16 bits of fh32[1] to hold the
	124	* offset of the inode and the upper 16 bits of fh32[1] to
	125	* hold the offset of the parent.
	126	*/
	127
	128	if (len < 3 \|\| (connectable && len < 5))
	129	return 255;
	130
	131	len = 3;
	132	fh32[0] = ei->i_iget5_block;
	133	fh16[2] = (__u16)ei->i_iget5_offset; /* fh16 [sic] */
	134	fh32[2] = inode->i_generation;
	135	if (connectable && !S_ISDIR(inode->i_mode)) {
	136	struct inode *parent;
	137	struct iso_inode_info *eparent;
	138	spin_lock(&dentry->d_lock);
	139	parent = dentry->d_parent->d_inode;
	140	eparent = ISOFS_I(parent);
	141	fh32[3] = eparent->i_iget5_block;
	142	fh16[3] = (__u16)eparent->i_iget5_offset; /* fh16 [sic] */
	143	fh32[4] = parent->i_generation;
	144	spin_unlock(&dentry->d_lock);
	145	len = 5;
	146	type = 2;
	147	}
	148	*max_len = len;
	149	return type;
	150	}
	151
905251a0 CH	152	struct isofs_fid {
	153	u32 block;
	154	u16 offset;
	155	u16 parent_offset;
	156	u32 generation;
	157	u32 parent_block;
	158	u32 parent_generation;
	159	};
1da177e4	160
905251a0 CH	161	static struct dentry isofs_fh_to_dentry(struct super_block sb,
905251a0 CH	162	struct fid *fid, int fh_len, int fh_type)
1da177e4	163	{
905251a0	164	struct isofs_fid ifid = (struct isofs_fid )fid;
1da177e4	165
905251a0	166	if (fh_len < 3 \|\| fh_type > 2)
1da177e4 LT	167	return NULL;
1da177e4 LT	168
905251a0 CH	169	return isofs_export_iget(sb, ifid->block, ifid->offset,
905251a0 CH	170	ifid->generation);
1da177e4 LT	171	}
1da177e4 LT	172
905251a0 CH	173	static struct dentry isofs_fh_to_parent(struct super_block sb,
	174	struct fid *fid, int fh_len, int fh_type)
	175	{
	176	struct isofs_fid ifid = (struct isofs_fid )fid;
	177
	178	if (fh_type != 2)
	179	return NULL;
	180
	181	return isofs_export_iget(sb,
	182	fh_len > 2 ? ifid->parent_block : 0,
	183	ifid->parent_offset,
	184	fh_len > 4 ? ifid->parent_generation : 0);
	185	}
1da177e4	186
39655164	187	const struct export_operations isofs_export_ops = {
1da177e4	188	.encode_fh = isofs_export_encode_fh,
905251a0 CH	189	.fh_to_dentry = isofs_fh_to_dentry,
905251a0 CH	190	.fh_to_parent = isofs_fh_to_parent,
1da177e4 LT	191	.get_parent = isofs_export_get_parent,
1da177e4 LT	192	};