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

// SPDX-License-Identifier: GPL-2.0-only
/* fs/fat/nfs.c
 */

#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;
	} else {
		/*
		 * We need to initialize this field because the fh is actually
		 * 12 bytes long
		 */
		fid->parent_i_pos_hi = 0;
	}

	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);
}

/*
 * Rebuild the parent for a directory that is not connected
 *  to the filesystem root
 */
static
struct inode *fat_rebuild_parent(struct super_block *sb, int parent_logstart)
{
	int search_clus, clus_to_match;
	struct msdos_dir_entry *de;
	struct inode *parent = NULL;
	struct inode *dummy_grand_parent = NULL;
	struct fat_slot_info sinfo;
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
	sector_t blknr = fat_clus_to_blknr(sbi, parent_logstart);
	struct buffer_head *parent_bh = sb_bread(sb, blknr);
	if (!parent_bh) {
		fat_msg(sb, KERN_ERR,
			"unable to read cluster of parent directory");
		return NULL;
	}

	de = (struct msdos_dir_entry *) parent_bh->b_data;
	clus_to_match = fat_get_start(sbi, &de[0]);
	search_clus = fat_get_start(sbi, &de[1]);

	dummy_grand_parent = fat_dget(sb, search_clus);
	if (!dummy_grand_parent) {
		dummy_grand_parent = new_inode(sb);
		if (!dummy_grand_parent) {
			brelse(parent_bh);
			return parent;
		}

		dummy_grand_parent->i_ino = iunique(sb, MSDOS_ROOT_INO);
		fat_fill_inode(dummy_grand_parent, &de[1]);
		MSDOS_I(dummy_grand_parent)->i_pos = -1;
	}

	if (!fat_scan_logstart(dummy_grand_parent, clus_to_match, &sinfo))
		parent = fat_build_inode(sb, sinfo.de, sinfo.i_pos);

	brelse(parent_bh);
	iput(dummy_grand_parent);

	return parent;
}

/*
 * Find the parent for a directory that is not currently connected to
 * the filesystem root.
 *
 * On entry, the caller holds d_inode(child_dir)->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;
	struct msdos_sb_info *sbi = MSDOS_SB(sb);

	if (!fat_get_dotdot_entry(d_inode(child_dir), &bh, &de)) {
		int parent_logstart = fat_get_start(sbi, de);
		parent_inode = fat_dget(sb, parent_logstart);
		if (!parent_inode && sbi->options.nfs == FAT_NFS_NOSTALE_RO)
			parent_inode = fat_rebuild_parent(sb, parent_logstart);
	}
	brelse(bh);

	return d_obtain_alias(parent_inode);
}

const struct export_operations fat_export_ops = {
	.encode_fh	= generic_encode_ino32_fh,
	.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
9c92ab61	1	// SPDX-License-Identifier: GPL-2.0-only
21b6633d	2	/* fs/fat/nfs.c
21b6633d SM	3	*/
	4
	5	#include <linux/exportfs.h>
	6	#include "fat.h"
	7
ea3983ac NJ	8	struct fat_fid {
	9	u32 i_gen;
	10	u32 i_pos_low;
	11	u16 i_pos_hi;
	12	u16 parent_i_pos_hi;
	13	u32 parent_i_pos_low;
	14	u32 parent_i_gen;
	15	};
	16
	17	#define FAT_FID_SIZE_WITHOUT_PARENT 3
	18	#define FAT_FID_SIZE_WITH_PARENT (sizeof(struct fat_fid)/sizeof(u32))
	19
811b99fd	20	/*
7669e8fb	21	* Look up a directory inode given its starting cluster.
21b6633d	22	*/
7669e8fb	23	static struct inode fat_dget(struct super_block sb, int i_logstart)
21b6633d	24	{
7669e8fb SM	25	struct msdos_sb_info *sbi = MSDOS_SB(sb);
7669e8fb SM	26	struct hlist_head *head;
7669e8fb SM	27	struct msdos_inode_info *i;
7669e8fb SM	28	struct inode *inode = NULL;
21b6633d	29
7669e8fb SM	30	head = sbi->dir_hashtable + fat_dir_hash(i_logstart);
7669e8fb SM	31	spin_lock(&sbi->dir_hash_lock);
b67bfe0d	32	hlist_for_each_entry(i, head, i_dir_hash) {
7669e8fb SM	33	BUG_ON(i->vfs_inode.i_sb != sb);
	34	if (i->i_logstart != i_logstart)
	35	continue;
	36	inode = igrab(&i->vfs_inode);
	37	if (inode)
	38	break;
21b6633d	39	}
7669e8fb SM	40	spin_unlock(&sbi->dir_hash_lock);
7669e8fb SM	41	return inode;
21b6633d SM	42	}
21b6633d SM	43
8fceb4e0 NJ	44	static struct inode fat_ilookup(struct super_block sb, u64 ino, loff_t i_pos)
	45	{
	46	if (MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO)
	47	return fat_iget(sb, i_pos);
	48
	49	else {
	50	if ((ino < MSDOS_ROOT_INO) \|\| (ino == MSDOS_FSINFO_INO))
	51	return NULL;
	52	return ilookup(sb, ino);
	53	}
	54	}
	55
ea3983ac NJ	56	static struct inode __fat_nfs_get_inode(struct super_block sb,
ea3983ac NJ	57	u64 ino, u32 generation, loff_t i_pos)
21b6633d	58	{
8fceb4e0	59	struct inode *inode = fat_ilookup(sb, ino, i_pos);
7669e8fb	60
7669e8fb SM	61	if (inode && generation && (inode->i_generation != generation)) {
	62	iput(inode);
	63	inode = NULL;
	64	}
8fceb4e0 NJ	65	if (inode == NULL && MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO) {
	66	struct buffer_head *bh = NULL;
	67	struct msdos_dir_entry *de ;
	68	sector_t blocknr;
	69	int offset;
	70	fat_get_blknr_offset(MSDOS_SB(sb), i_pos, &blocknr, &offset);
	71	bh = sb_bread(sb, blocknr);
	72	if (!bh) {
	73	fat_msg(sb, KERN_ERR,
	74	"unable to read block(%llu) for building NFS inode",
	75	(llu)blocknr);
	76	return inode;
	77	}
	78	de = (struct msdos_dir_entry *)bh->b_data;
	79	/* If a file is deleted on server and client is not updated
	80	* yet, we must not build the inode upon a lookup call.
	81	*/
	82	if (IS_FREE(de[offset].name))
	83	inode = NULL;
	84	else
	85	inode = fat_build_inode(sb, &de[offset], i_pos);
	86	brelse(bh);
	87	}
7669e8fb SM	88
7669e8fb SM	89	return inode;
21b6633d SM	90	}
21b6633d SM	91
ea3983ac NJ	92	static struct inode fat_nfs_get_inode(struct super_block sb,
	93	u64 ino, u32 generation)
	94	{
	95
	96	return __fat_nfs_get_inode(sb, ino, generation, 0);
	97	}
	98
	99	static int
	100	fat_encode_fh_nostale(struct inode inode, __u32 fh, int *lenp,
	101	struct inode *parent)
	102	{
	103	int len = *lenp;
	104	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
	105	struct fat_fid fid = (struct fat_fid ) fh;
	106	loff_t i_pos;
	107	int type = FILEID_FAT_WITHOUT_PARENT;
	108
	109	if (parent) {
	110	if (len < FAT_FID_SIZE_WITH_PARENT) {
	111	*lenp = FAT_FID_SIZE_WITH_PARENT;
	112	return FILEID_INVALID;
	113	}
	114	} else {
	115	if (len < FAT_FID_SIZE_WITHOUT_PARENT) {
	116	*lenp = FAT_FID_SIZE_WITHOUT_PARENT;
	117	return FILEID_INVALID;
	118	}
	119	}
	120
	121	i_pos = fat_i_pos_read(sbi, inode);
	122	*lenp = FAT_FID_SIZE_WITHOUT_PARENT;
	123	fid->i_gen = inode->i_generation;
	124	fid->i_pos_low = i_pos & 0xFFFFFFFF;
	125	fid->i_pos_hi = (i_pos >> 32) & 0xFFFF;
	126	if (parent) {
	127	i_pos = fat_i_pos_read(sbi, parent);
	128	fid->parent_i_pos_hi = (i_pos >> 32) & 0xFFFF;
	129	fid->parent_i_pos_low = i_pos & 0xFFFFFFFF;
	130	fid->parent_i_gen = parent->i_generation;
	131	type = FILEID_FAT_WITH_PARENT;
	132	*lenp = FAT_FID_SIZE_WITH_PARENT;
fde2497d JK	133	} else {
	134	/*
	135	* We need to initialize this field because the fh is actually
	136	* 12 bytes long
	137	*/
	138	fid->parent_i_pos_hi = 0;
ea3983ac NJ	139	}
	140
	141	return type;
	142	}
	143
811b99fd	144	/*
21b6633d SM	145	* Map a NFS file handle to a corresponding dentry.
	146	* The dentry may or may not be connected to the filesystem root.
	147	*/
ea3983ac	148	static struct dentry fat_fh_to_dentry(struct super_block sb, struct fid *fid,
21b6633d SM	149	int fh_len, int fh_type)
21b6633d SM	150	{
7669e8fb SM	151	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
	152	fat_nfs_get_inode);
	153	}
21b6633d	154
ea3983ac NJ	155	static struct dentry fat_fh_to_dentry_nostale(struct super_block sb,
	156	struct fid *fh, int fh_len,
	157	int fh_type)
	158	{
	159	struct inode *inode = NULL;
	160	struct fat_fid fid = (struct fat_fid )fh;
	161	loff_t i_pos;
	162
	163	switch (fh_type) {
	164	case FILEID_FAT_WITHOUT_PARENT:
	165	if (fh_len < FAT_FID_SIZE_WITHOUT_PARENT)
	166	return NULL;
	167	break;
	168	case FILEID_FAT_WITH_PARENT:
	169	if (fh_len < FAT_FID_SIZE_WITH_PARENT)
	170	return NULL;
	171	break;
	172	default:
	173	return NULL;
	174	}
	175	i_pos = fid->i_pos_hi;
	176	i_pos = (i_pos << 32) \| (fid->i_pos_low);
	177	inode = __fat_nfs_get_inode(sb, 0, fid->i_gen, i_pos);
	178
	179	return d_obtain_alias(inode);
	180	}
	181
7669e8fb SM	182	/*
	183	* Find the parent for a file specified by NFS handle.
	184	* This requires that the handle contain the i_ino of the parent.
	185	*/
ea3983ac	186	static struct dentry fat_fh_to_parent(struct super_block sb, struct fid *fid,
7669e8fb SM	187	int fh_len, int fh_type)
	188	{
	189	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
	190	fat_nfs_get_inode);
21b6633d SM	191	}
21b6633d SM	192
ea3983ac NJ	193	static struct dentry fat_fh_to_parent_nostale(struct super_block sb,
	194	struct fid *fh, int fh_len,
	195	int fh_type)
	196	{
	197	struct inode *inode = NULL;
	198	struct fat_fid fid = (struct fat_fid )fh;
	199	loff_t i_pos;
	200
	201	if (fh_len < FAT_FID_SIZE_WITH_PARENT)
	202	return NULL;
	203
	204	switch (fh_type) {
	205	case FILEID_FAT_WITH_PARENT:
	206	i_pos = fid->parent_i_pos_hi;
	207	i_pos = (i_pos << 32) \| (fid->parent_i_pos_low);
	208	inode = __fat_nfs_get_inode(sb, 0, fid->parent_i_gen, i_pos);
	209	break;
	210	}
	211
	212	return d_obtain_alias(inode);
	213	}
	214
f1e6fb0a NJ	215	/*
	216	* Rebuild the parent for a directory that is not connected
	217	* to the filesystem root
	218	*/
	219	static
	220	struct inode fat_rebuild_parent(struct super_block sb, int parent_logstart)
	221	{
	222	int search_clus, clus_to_match;
	223	struct msdos_dir_entry *de;
	224	struct inode *parent = NULL;
	225	struct inode *dummy_grand_parent = NULL;
	226	struct fat_slot_info sinfo;
	227	struct msdos_sb_info *sbi = MSDOS_SB(sb);
	228	sector_t blknr = fat_clus_to_blknr(sbi, parent_logstart);
	229	struct buffer_head *parent_bh = sb_bread(sb, blknr);
	230	if (!parent_bh) {
	231	fat_msg(sb, KERN_ERR,
	232	"unable to read cluster of parent directory");
	233	return NULL;
	234	}
	235
	236	de = (struct msdos_dir_entry *) parent_bh->b_data;
	237	clus_to_match = fat_get_start(sbi, &de[0]);
	238	search_clus = fat_get_start(sbi, &de[1]);
	239
	240	dummy_grand_parent = fat_dget(sb, search_clus);
	241	if (!dummy_grand_parent) {
	242	dummy_grand_parent = new_inode(sb);
	243	if (!dummy_grand_parent) {
	244	brelse(parent_bh);
	245	return parent;
	246	}
	247
	248	dummy_grand_parent->i_ino = iunique(sb, MSDOS_ROOT_INO);
	249	fat_fill_inode(dummy_grand_parent, &de[1]);
	250	MSDOS_I(dummy_grand_parent)->i_pos = -1;
	251	}
	252
	253	if (!fat_scan_logstart(dummy_grand_parent, clus_to_match, &sinfo))
	254	parent = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
	255
	256	brelse(parent_bh);
	257	iput(dummy_grand_parent);
	258
	259	return parent;
	260	}
	261
21b6633d SM	262	/*
	263	* Find the parent for a directory that is not currently connected to
	264	* the filesystem root.
	265	*
2b0143b5	266	* On entry, the caller holds d_inode(child_dir)->i_mutex.
21b6633d	267	*/
ea3983ac	268	static struct dentry fat_get_parent(struct dentry child_dir)
21b6633d SM	269	{
	270	struct super_block *sb = child_dir->d_sb;
	271	struct buffer_head *bh = NULL;
	272	struct msdos_dir_entry *de;
7669e8fb	273	struct inode *parent_inode = NULL;
f1e6fb0a	274	struct msdos_sb_info *sbi = MSDOS_SB(sb);
21b6633d	275
2b0143b5	276	if (!fat_get_dotdot_entry(d_inode(child_dir), &bh, &de)) {
f1e6fb0a	277	int parent_logstart = fat_get_start(sbi, de);
7669e8fb	278	parent_inode = fat_dget(sb, parent_logstart);
f1e6fb0a NJ	279	if (!parent_inode && sbi->options.nfs == FAT_NFS_NOSTALE_RO)
f1e6fb0a NJ	280	parent_inode = fat_rebuild_parent(sb, parent_logstart);
21b6633d	281	}
21b6633d	282	brelse(bh);
21b6633d	283
7669e8fb	284	return d_obtain_alias(parent_inode);
21b6633d	285	}
ea3983ac NJ	286
ea3983ac NJ	287	const struct export_operations fat_export_ops = {
e21fc203	288	.encode_fh = generic_encode_ino32_fh,
ea3983ac NJ	289	.fh_to_dentry = fat_fh_to_dentry,
	290	.fh_to_parent = fat_fh_to_parent,
	291	.get_parent = fat_get_parent,
	292	};
	293
	294	const struct export_operations fat_export_ops_nostale = {
	295	.encode_fh = fat_encode_fh_nostale,
	296	.fh_to_dentry = fat_fh_to_dentry_nostale,
	297	.fh_to_parent = fat_fh_to_parent_nostale,
	298	.get_parent = fat_get_parent,
	299	};