[deliverable/linux.git] / fs / fat / nfs.c

/* fs/fat/nfs.c
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <linux/exportfs.h>
#include "fat.h"

struct fat_fid {
	u32 i_gen;
	u32 i_pos_low;
	u16 i_pos_hi;
	u16 parent_i_pos_hi;
	u32 parent_i_pos_low;
	u32 parent_i_gen;
};

#define FAT_FID_SIZE_WITHOUT_PARENT 3
#define FAT_FID_SIZE_WITH_PARENT (sizeof(struct fat_fid)/sizeof(u32))

/**
 * Look up a directory inode given its starting cluster.
 */
static struct inode *fat_dget(struct super_block *sb, int i_logstart)
{
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
	struct hlist_head *head;
	struct msdos_inode_info *i;
	struct inode *inode = NULL;

	head = sbi->dir_hashtable + fat_dir_hash(i_logstart);
	spin_lock(&sbi->dir_hash_lock);
	hlist_for_each_entry(i, head, i_dir_hash) {
		BUG_ON(i->vfs_inode.i_sb != sb);
		if (i->i_logstart != i_logstart)
			continue;
		inode = igrab(&i->vfs_inode);
		if (inode)
			break;
	}
	spin_unlock(&sbi->dir_hash_lock);
	return inode;
}

static struct inode *fat_ilookup(struct super_block *sb, u64 ino, loff_t i_pos)
{
	if (MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO)
		return fat_iget(sb, i_pos);

	else {
		if ((ino < MSDOS_ROOT_INO) || (ino == MSDOS_FSINFO_INO))
			return NULL;
		return ilookup(sb, ino);
	}
}

static struct inode *__fat_nfs_get_inode(struct super_block *sb,
				       u64 ino, u32 generation, loff_t i_pos)
{
	struct inode *inode = fat_ilookup(sb, ino, i_pos);

	if (inode && generation && (inode->i_generation != generation)) {
		iput(inode);
		inode = NULL;
	}
	if (inode == NULL && MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO) {
		struct buffer_head *bh = NULL;
		struct msdos_dir_entry *de ;
		sector_t blocknr;
		int offset;
		fat_get_blknr_offset(MSDOS_SB(sb), i_pos, &blocknr, &offset);
		bh = sb_bread(sb, blocknr);
		if (!bh) {
			fat_msg(sb, KERN_ERR,
				"unable to read block(%llu) for building NFS inode",
				(llu)blocknr);
			return inode;
		}
		de = (struct msdos_dir_entry *)bh->b_data;
		/* If a file is deleted on server and client is not updated
		 * yet, we must not build the inode upon a lookup call.
		 */
		if (IS_FREE(de[offset].name))
			inode = NULL;
		else
			inode = fat_build_inode(sb, &de[offset], i_pos);
		brelse(bh);
	}

	return inode;
}

static struct inode *fat_nfs_get_inode(struct super_block *sb,
				       u64 ino, u32 generation)
{

	return __fat_nfs_get_inode(sb, ino, generation, 0);
}

static int
fat_encode_fh_nostale(struct inode *inode, __u32 *fh, int *lenp,
		      struct inode *parent)
{
	int len = *lenp;
	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
	struct fat_fid *fid = (struct fat_fid *) fh;
	loff_t i_pos;
	int type = FILEID_FAT_WITHOUT_PARENT;

	if (parent) {
		if (len < FAT_FID_SIZE_WITH_PARENT) {
			*lenp = FAT_FID_SIZE_WITH_PARENT;
			return FILEID_INVALID;
		}
	} else {
		if (len < FAT_FID_SIZE_WITHOUT_PARENT) {
			*lenp = FAT_FID_SIZE_WITHOUT_PARENT;
			return FILEID_INVALID;
		}
	}

	i_pos = fat_i_pos_read(sbi, inode);
	*lenp = FAT_FID_SIZE_WITHOUT_PARENT;
	fid->i_gen = inode->i_generation;
	fid->i_pos_low = i_pos & 0xFFFFFFFF;
	fid->i_pos_hi = (i_pos >> 32) & 0xFFFF;
	if (parent) {
		i_pos = fat_i_pos_read(sbi, parent);
		fid->parent_i_pos_hi = (i_pos >> 32) & 0xFFFF;
		fid->parent_i_pos_low = i_pos & 0xFFFFFFFF;
		fid->parent_i_gen = parent->i_generation;
		type = FILEID_FAT_WITH_PARENT;
		*lenp = FAT_FID_SIZE_WITH_PARENT;
	}

	return type;
}

/**
 * Map a NFS file handle to a corresponding dentry.
 * The dentry may or may not be connected to the filesystem root.
 */
static struct dentry *fat_fh_to_dentry(struct super_block *sb, struct fid *fid,
				int fh_len, int fh_type)
{
	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
				    fat_nfs_get_inode);
}

static struct dentry *fat_fh_to_dentry_nostale(struct super_block *sb,
					       struct fid *fh, int fh_len,
					       int fh_type)
{
	struct inode *inode = NULL;
	struct fat_fid *fid = (struct fat_fid *)fh;
	loff_t i_pos;

	switch (fh_type) {
	case FILEID_FAT_WITHOUT_PARENT:
		if (fh_len < FAT_FID_SIZE_WITHOUT_PARENT)
			return NULL;
		break;
	case FILEID_FAT_WITH_PARENT:
		if (fh_len < FAT_FID_SIZE_WITH_PARENT)
			return NULL;
		break;
	default:
		return NULL;
	}
	i_pos = fid->i_pos_hi;
	i_pos = (i_pos << 32) | (fid->i_pos_low);
	inode = __fat_nfs_get_inode(sb, 0, fid->i_gen, i_pos);

	return d_obtain_alias(inode);
}

/*
 * Find the parent for a file specified by NFS handle.
 * This requires that the handle contain the i_ino of the parent.
 */
static struct dentry *fat_fh_to_parent(struct super_block *sb, struct fid *fid,
				int fh_len, int fh_type)
{
	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
				    fat_nfs_get_inode);
}

static struct dentry *fat_fh_to_parent_nostale(struct super_block *sb,
					       struct fid *fh, int fh_len,
					       int fh_type)
{
	struct inode *inode = NULL;
	struct fat_fid *fid = (struct fat_fid *)fh;
	loff_t i_pos;

	if (fh_len < FAT_FID_SIZE_WITH_PARENT)
		return NULL;

	switch (fh_type) {
	case FILEID_FAT_WITH_PARENT:
		i_pos = fid->parent_i_pos_hi;
		i_pos = (i_pos << 32) | (fid->parent_i_pos_low);
		inode = __fat_nfs_get_inode(sb, 0, fid->parent_i_gen, i_pos);
		break;
	}

	return d_obtain_alias(inode);
}

/*
 * Find the parent for a directory that is not currently connected to
 * the filesystem root.
 *
 * On entry, the caller holds child_dir->d_inode->i_mutex.
 */
static struct dentry *fat_get_parent(struct dentry *child_dir)
{
	struct super_block *sb = child_dir->d_sb;
	struct buffer_head *bh = NULL;
	struct msdos_dir_entry *de;
	struct inode *parent_inode = NULL;

	if (!fat_get_dotdot_entry(child_dir->d_inode, &bh, &de)) {
		int parent_logstart = fat_get_start(MSDOS_SB(sb), de);
		parent_inode = fat_dget(sb, parent_logstart);
	}
	brelse(bh);

	return d_obtain_alias(parent_inode);
}

const struct export_operations fat_export_ops = {
	.fh_to_dentry   = fat_fh_to_dentry,
	.fh_to_parent   = fat_fh_to_parent,
	.get_parent     = fat_get_parent,
};

const struct export_operations fat_export_ops_nostale = {
	.encode_fh      = fat_encode_fh_nostale,
	.fh_to_dentry   = fat_fh_to_dentry_nostale,
	.fh_to_parent   = fat_fh_to_parent_nostale,
	.get_parent     = fat_get_parent,
};
Commit	Line	Data
21b6633d SM	1	/* fs/fat/nfs.c
	2	*
	3	* This software is licensed under the terms of the GNU General Public
	4	* License version 2, as published by the Free Software Foundation, and
	5	* may be copied, distributed, and modified under those terms.
	6	*
	7	* This program is distributed in the hope that it will be useful,
	8	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	9	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	10	* GNU General Public License for more details.
	11	*
	12	*/
	13
	14	#include <linux/exportfs.h>
	15	#include "fat.h"
	16
ea3983ac NJ	17	struct fat_fid {
	18	u32 i_gen;
	19	u32 i_pos_low;
	20	u16 i_pos_hi;
	21	u16 parent_i_pos_hi;
	22	u32 parent_i_pos_low;
	23	u32 parent_i_gen;
	24	};
	25
	26	#define FAT_FID_SIZE_WITHOUT_PARENT 3
	27	#define FAT_FID_SIZE_WITH_PARENT (sizeof(struct fat_fid)/sizeof(u32))
	28
7669e8fb SM	29	/**
7669e8fb SM	30	* Look up a directory inode given its starting cluster.
21b6633d	31	*/
7669e8fb	32	static struct inode fat_dget(struct super_block sb, int i_logstart)
21b6633d	33	{
7669e8fb SM	34	struct msdos_sb_info *sbi = MSDOS_SB(sb);
7669e8fb SM	35	struct hlist_head *head;
7669e8fb SM	36	struct msdos_inode_info *i;
7669e8fb SM	37	struct inode *inode = NULL;
21b6633d	38
7669e8fb SM	39	head = sbi->dir_hashtable + fat_dir_hash(i_logstart);
7669e8fb SM	40	spin_lock(&sbi->dir_hash_lock);
b67bfe0d	41	hlist_for_each_entry(i, head, i_dir_hash) {
7669e8fb SM	42	BUG_ON(i->vfs_inode.i_sb != sb);
	43	if (i->i_logstart != i_logstart)
	44	continue;
	45	inode = igrab(&i->vfs_inode);
	46	if (inode)
	47	break;
21b6633d	48	}
7669e8fb SM	49	spin_unlock(&sbi->dir_hash_lock);
7669e8fb SM	50	return inode;
21b6633d SM	51	}
21b6633d SM	52
8fceb4e0 NJ	53	static struct inode fat_ilookup(struct super_block sb, u64 ino, loff_t i_pos)
	54	{
	55	if (MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO)
	56	return fat_iget(sb, i_pos);
	57
	58	else {
	59	if ((ino < MSDOS_ROOT_INO) \|\| (ino == MSDOS_FSINFO_INO))
	60	return NULL;
	61	return ilookup(sb, ino);
	62	}
	63	}
	64
ea3983ac NJ	65	static struct inode __fat_nfs_get_inode(struct super_block sb,
ea3983ac NJ	66	u64 ino, u32 generation, loff_t i_pos)
21b6633d	67	{
8fceb4e0	68	struct inode *inode = fat_ilookup(sb, ino, i_pos);
7669e8fb	69
7669e8fb SM	70	if (inode && generation && (inode->i_generation != generation)) {
	71	iput(inode);
	72	inode = NULL;
	73	}
8fceb4e0 NJ	74	if (inode == NULL && MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO) {
	75	struct buffer_head *bh = NULL;
	76	struct msdos_dir_entry *de ;
	77	sector_t blocknr;
	78	int offset;
	79	fat_get_blknr_offset(MSDOS_SB(sb), i_pos, &blocknr, &offset);
	80	bh = sb_bread(sb, blocknr);
	81	if (!bh) {
	82	fat_msg(sb, KERN_ERR,
	83	"unable to read block(%llu) for building NFS inode",
	84	(llu)blocknr);
	85	return inode;
	86	}
	87	de = (struct msdos_dir_entry *)bh->b_data;
	88	/* If a file is deleted on server and client is not updated
	89	* yet, we must not build the inode upon a lookup call.
	90	*/
	91	if (IS_FREE(de[offset].name))
	92	inode = NULL;
	93	else
	94	inode = fat_build_inode(sb, &de[offset], i_pos);
	95	brelse(bh);
	96	}
7669e8fb SM	97
7669e8fb SM	98	return inode;
21b6633d SM	99	}
21b6633d SM	100
ea3983ac NJ	101	static struct inode fat_nfs_get_inode(struct super_block sb,
	102	u64 ino, u32 generation)
	103	{
	104
	105	return __fat_nfs_get_inode(sb, ino, generation, 0);
	106	}
	107
	108	static int
	109	fat_encode_fh_nostale(struct inode inode, __u32 fh, int *lenp,
	110	struct inode *parent)
	111	{
	112	int len = *lenp;
	113	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
	114	struct fat_fid fid = (struct fat_fid ) fh;
	115	loff_t i_pos;
	116	int type = FILEID_FAT_WITHOUT_PARENT;
	117
	118	if (parent) {
	119	if (len < FAT_FID_SIZE_WITH_PARENT) {
	120	*lenp = FAT_FID_SIZE_WITH_PARENT;
	121	return FILEID_INVALID;
	122	}
	123	} else {
	124	if (len < FAT_FID_SIZE_WITHOUT_PARENT) {
	125	*lenp = FAT_FID_SIZE_WITHOUT_PARENT;
	126	return FILEID_INVALID;
	127	}
	128	}
	129
	130	i_pos = fat_i_pos_read(sbi, inode);
	131	*lenp = FAT_FID_SIZE_WITHOUT_PARENT;
	132	fid->i_gen = inode->i_generation;
	133	fid->i_pos_low = i_pos & 0xFFFFFFFF;
	134	fid->i_pos_hi = (i_pos >> 32) & 0xFFFF;
	135	if (parent) {
	136	i_pos = fat_i_pos_read(sbi, parent);
	137	fid->parent_i_pos_hi = (i_pos >> 32) & 0xFFFF;
	138	fid->parent_i_pos_low = i_pos & 0xFFFFFFFF;
	139	fid->parent_i_gen = parent->i_generation;
	140	type = FILEID_FAT_WITH_PARENT;
	141	*lenp = FAT_FID_SIZE_WITH_PARENT;
	142	}
	143
	144	return type;
	145	}
	146
21b6633d SM	147	/**
	148	* Map a NFS file handle to a corresponding dentry.
	149	* The dentry may or may not be connected to the filesystem root.
	150	*/
ea3983ac	151	static struct dentry fat_fh_to_dentry(struct super_block sb, struct fid *fid,
21b6633d SM	152	int fh_len, int fh_type)
21b6633d SM	153	{
7669e8fb SM	154	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
	155	fat_nfs_get_inode);
	156	}
21b6633d	157
ea3983ac NJ	158	static struct dentry fat_fh_to_dentry_nostale(struct super_block sb,
	159	struct fid *fh, int fh_len,
	160	int fh_type)
	161	{
	162	struct inode *inode = NULL;
	163	struct fat_fid fid = (struct fat_fid )fh;
	164	loff_t i_pos;
	165
	166	switch (fh_type) {
	167	case FILEID_FAT_WITHOUT_PARENT:
	168	if (fh_len < FAT_FID_SIZE_WITHOUT_PARENT)
	169	return NULL;
	170	break;
	171	case FILEID_FAT_WITH_PARENT:
	172	if (fh_len < FAT_FID_SIZE_WITH_PARENT)
	173	return NULL;
	174	break;
	175	default:
	176	return NULL;
	177	}
	178	i_pos = fid->i_pos_hi;
	179	i_pos = (i_pos << 32) \| (fid->i_pos_low);
	180	inode = __fat_nfs_get_inode(sb, 0, fid->i_gen, i_pos);
	181
	182	return d_obtain_alias(inode);
	183	}
	184
7669e8fb SM	185	/*
	186	* Find the parent for a file specified by NFS handle.
	187	* This requires that the handle contain the i_ino of the parent.
	188	*/
ea3983ac	189	static struct dentry fat_fh_to_parent(struct super_block sb, struct fid *fid,
7669e8fb SM	190	int fh_len, int fh_type)
	191	{
	192	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
	193	fat_nfs_get_inode);
21b6633d SM	194	}
21b6633d SM	195
ea3983ac NJ	196	static struct dentry fat_fh_to_parent_nostale(struct super_block sb,
	197	struct fid *fh, int fh_len,
	198	int fh_type)
	199	{
	200	struct inode *inode = NULL;
	201	struct fat_fid fid = (struct fat_fid )fh;
	202	loff_t i_pos;
	203
	204	if (fh_len < FAT_FID_SIZE_WITH_PARENT)
	205	return NULL;
	206
	207	switch (fh_type) {
	208	case FILEID_FAT_WITH_PARENT:
	209	i_pos = fid->parent_i_pos_hi;
	210	i_pos = (i_pos << 32) \| (fid->parent_i_pos_low);
	211	inode = __fat_nfs_get_inode(sb, 0, fid->parent_i_gen, i_pos);
	212	break;
	213	}
	214
	215	return d_obtain_alias(inode);
	216	}
	217
21b6633d SM	218	/*
	219	* Find the parent for a directory that is not currently connected to
	220	* the filesystem root.
	221	*
	222	* On entry, the caller holds child_dir->d_inode->i_mutex.
	223	*/
ea3983ac	224	static struct dentry fat_get_parent(struct dentry child_dir)
21b6633d SM	225	{
	226	struct super_block *sb = child_dir->d_sb;
	227	struct buffer_head *bh = NULL;
	228	struct msdos_dir_entry *de;
7669e8fb	229	struct inode *parent_inode = NULL;
21b6633d	230
7669e8fb SM	231	if (!fat_get_dotdot_entry(child_dir->d_inode, &bh, &de)) {
	232	int parent_logstart = fat_get_start(MSDOS_SB(sb), de);
	233	parent_inode = fat_dget(sb, parent_logstart);
21b6633d	234	}
21b6633d	235	brelse(bh);
21b6633d	236
7669e8fb	237	return d_obtain_alias(parent_inode);
21b6633d	238	}
ea3983ac NJ	239
	240	const struct export_operations fat_export_ops = {
	241	.fh_to_dentry = fat_fh_to_dentry,
	242	.fh_to_parent = fat_fh_to_parent,
	243	.get_parent = fat_get_parent,
	244	};
	245
	246	const struct export_operations fat_export_ops_nostale = {
	247	.encode_fh = fat_encode_fh_nostale,
	248	.fh_to_dentry = fat_fh_to_dentry_nostale,
	249	.fh_to_parent = fat_fh_to_parent_nostale,
	250	.get_parent = fat_get_parent,
	251	};