[mirror_ubuntu-jammy-kernel.git] / fs / nfsd / nfsfh.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
 *
 * This file describes the layout of the file handles as passed
 * over the wire.
 */
#ifndef _LINUX_NFSD_NFSFH_H
#define _LINUX_NFSD_NFSFH_H

#include <linux/crc32.h>
#include <linux/sunrpc/svc.h>
#include <uapi/linux/nfsd/nfsfh.h>
#include <linux/iversion.h>
#include <linux/exportfs.h>

static inline __u32 ino_t_to_u32(ino_t ino)
{
	return (__u32) ino;
}

static inline ino_t u32_to_ino_t(__u32 uino)
{
	return (ino_t) uino;
}

/*
 * This is the internal representation of an NFS handle used in knfsd.
 * pre_mtime/post_version will be used to support wcc_attr's in NFSv3.
 */
typedef struct svc_fh {
	struct knfsd_fh		fh_handle;	/* FH data */
	int			fh_maxsize;	/* max size for fh_handle */
	struct dentry *		fh_dentry;	/* validated dentry */
	struct svc_export *	fh_export;	/* export pointer */

	bool			fh_locked;	/* inode locked by us */
	bool			fh_want_write;	/* remount protection taken */
	bool			fh_no_wcc;	/* no wcc data needed */
	bool			fh_no_atomic_attr;
						/*
						 * wcc data is not atomic with
						 * operation
						 */
	int			fh_flags;	/* FH flags */
#ifdef CONFIG_NFSD_V3
	bool			fh_post_saved;	/* post-op attrs saved */
	bool			fh_pre_saved;	/* pre-op attrs saved */

	/* Pre-op attributes saved during fh_lock */
	__u64			fh_pre_size;	/* size before operation */
	struct timespec64	fh_pre_mtime;	/* mtime before oper */
	struct timespec64	fh_pre_ctime;	/* ctime before oper */
	/*
	 * pre-op nfsv4 change attr: note must check IS_I_VERSION(inode)
	 *  to find out if it is valid.
	 */
	u64			fh_pre_change;

	/* Post-op attributes saved in fh_unlock */
	struct kstat		fh_post_attr;	/* full attrs after operation */
	u64			fh_post_change; /* nfsv4 change; see above */
#endif /* CONFIG_NFSD_V3 */
} svc_fh;
#define NFSD4_FH_FOREIGN (1<<0)
#define SET_FH_FLAG(c, f) ((c)->fh_flags |= (f))
#define HAS_FH_FLAG(c, f) ((c)->fh_flags & (f))

enum nfsd_fsid {
	FSID_DEV = 0,
	FSID_NUM,
	FSID_MAJOR_MINOR,
	FSID_ENCODE_DEV,
	FSID_UUID4_INUM,
	FSID_UUID8,
	FSID_UUID16,
	FSID_UUID16_INUM,
};

enum fsid_source {
	FSIDSOURCE_DEV,
	FSIDSOURCE_FSID,
	FSIDSOURCE_UUID,
};
extern enum fsid_source fsid_source(const struct svc_fh *fhp);


/*
 * This might look a little large to "inline" but in all calls except
 * one, 'vers' is constant so moste of the function disappears.
 *
 * In some cases the values are considered to be host endian and in
 * others, net endian. fsidv is always considered to be u32 as the
 * callers don't know which it will be. So we must use __force to keep
 * sparse from complaining. Since these values are opaque to the
 * client, that shouldn't be a problem.
 */
static inline void mk_fsid(int vers, u32 *fsidv, dev_t dev, ino_t ino,
			   u32 fsid, unsigned char *uuid)
{
	u32 *up;
	switch(vers) {
	case FSID_DEV:
		fsidv[0] = (__force __u32)htonl((MAJOR(dev)<<16) |
				 MINOR(dev));
		fsidv[1] = ino_t_to_u32(ino);
		break;
	case FSID_NUM:
		fsidv[0] = fsid;
		break;
	case FSID_MAJOR_MINOR:
		fsidv[0] = (__force __u32)htonl(MAJOR(dev));
		fsidv[1] = (__force __u32)htonl(MINOR(dev));
		fsidv[2] = ino_t_to_u32(ino);
		break;

	case FSID_ENCODE_DEV:
		fsidv[0] = new_encode_dev(dev);
		fsidv[1] = ino_t_to_u32(ino);
		break;

	case FSID_UUID4_INUM:
		/* 4 byte fsid and inode number */
		up = (u32*)uuid;
		fsidv[0] = ino_t_to_u32(ino);
		fsidv[1] = up[0] ^ up[1] ^ up[2] ^ up[3];
		break;

	case FSID_UUID8:
		/* 8 byte fsid  */
		up = (u32*)uuid;
		fsidv[0] = up[0] ^ up[2];
		fsidv[1] = up[1] ^ up[3];
		break;

	case FSID_UUID16:
		/* 16 byte fsid - NFSv3+ only */
		memcpy(fsidv, uuid, 16);
		break;

	case FSID_UUID16_INUM:
		/* 8 byte inode and 16 byte fsid */
		*(u64*)fsidv = (u64)ino;
		memcpy(fsidv+2, uuid, 16);
		break;
	default: BUG();
	}
}

static inline int key_len(int type)
{
	switch(type) {
	case FSID_DEV:		return 8;
	case FSID_NUM: 		return 4;
	case FSID_MAJOR_MINOR:	return 12;
	case FSID_ENCODE_DEV:	return 8;
	case FSID_UUID4_INUM:	return 8;
	case FSID_UUID8:	return 8;
	case FSID_UUID16:	return 16;
	case FSID_UUID16_INUM:	return 24;
	default: return 0;
	}
}

/*
 * Shorthand for dprintk()'s
 */
extern char * SVCFH_fmt(struct svc_fh *fhp);

/*
 * Function prototypes
 */
__be32	fh_verify(struct svc_rqst *, struct svc_fh *, umode_t, int);
__be32	fh_compose(struct svc_fh *, struct svc_export *, struct dentry *, struct svc_fh *);
__be32	fh_update(struct svc_fh *);
void	fh_put(struct svc_fh *);

static __inline__ struct svc_fh *
fh_copy(struct svc_fh *dst, struct svc_fh *src)
{
	WARN_ON(src->fh_dentry || src->fh_locked);
			
	*dst = *src;
	return dst;
}

static inline void
fh_copy_shallow(struct knfsd_fh *dst, struct knfsd_fh *src)
{
	dst->fh_size = src->fh_size;
	memcpy(&dst->fh_base, &src->fh_base, src->fh_size);
}

static __inline__ struct svc_fh *
fh_init(struct svc_fh *fhp, int maxsize)
{
	memset(fhp, 0, sizeof(*fhp));
	fhp->fh_maxsize = maxsize;
	return fhp;
}

static inline bool fh_match(struct knfsd_fh *fh1, struct knfsd_fh *fh2)
{
	if (fh1->fh_size != fh2->fh_size)
		return false;
	if (memcmp(fh1->fh_base.fh_pad, fh2->fh_base.fh_pad, fh1->fh_size) != 0)
		return false;
	return true;
}

static inline bool fh_fsid_match(struct knfsd_fh *fh1, struct knfsd_fh *fh2)
{
	if (fh1->fh_fsid_type != fh2->fh_fsid_type)
		return false;
	if (memcmp(fh1->fh_fsid, fh2->fh_fsid, key_len(fh1->fh_fsid_type)) != 0)
		return false;
	return true;
}

#ifdef CONFIG_CRC32
/**
 * knfsd_fh_hash - calculate the crc32 hash for the filehandle
 * @fh - pointer to filehandle
 *
 * returns a crc32 hash for the filehandle that is compatible with
 * the one displayed by "wireshark".
 */

static inline u32
knfsd_fh_hash(struct knfsd_fh *fh)
{
	return ~crc32_le(0xFFFFFFFF, (unsigned char *)&fh->fh_base, fh->fh_size);
}
#else
static inline u32
knfsd_fh_hash(struct knfsd_fh *fh)
{
	return 0;
}
#endif

#ifdef CONFIG_NFSD_V3
/*
 * The wcc data stored in current_fh should be cleared
 * between compound ops.
 */
static inline void
fh_clear_wcc(struct svc_fh *fhp)
{
	fhp->fh_post_saved = false;
	fhp->fh_pre_saved = false;
}

/*
 * We could use i_version alone as the change attribute.  However,
 * i_version can go backwards after a reboot.  On its own that doesn't
 * necessarily cause a problem, but if i_version goes backwards and then
 * is incremented again it could reuse a value that was previously used
 * before boot, and a client who queried the two values might
 * incorrectly assume nothing changed.
 *
 * By using both ctime and the i_version counter we guarantee that as
 * long as time doesn't go backwards we never reuse an old value.
 */
static inline u64 nfsd4_change_attribute(struct kstat *stat,
					 struct inode *inode)
{
	if (inode->i_sb->s_export_op->fetch_iversion)
		return inode->i_sb->s_export_op->fetch_iversion(inode);
	else if (IS_I_VERSION(inode)) {
		u64 chattr;

		chattr =  stat->ctime.tv_sec;
		chattr <<= 30;
		chattr += stat->ctime.tv_nsec;
		chattr += inode_query_iversion(inode);
		return chattr;
	} else
		return time_to_chattr(&stat->ctime);
}

extern void fill_pre_wcc(struct svc_fh *fhp);
extern void fill_post_wcc(struct svc_fh *fhp);
#else
#define fh_clear_wcc(ignored)
#define fill_pre_wcc(ignored)
#define fill_post_wcc(notused)
#endif /* CONFIG_NFSD_V3 */


/*
 * Lock a file handle/inode
 * NOTE: both fh_lock and fh_unlock are done "by hand" in
 * vfs.c:nfsd_rename as it needs to grab 2 i_mutex's at once
 * so, any changes here should be reflected there.
 */

static inline void
fh_lock_nested(struct svc_fh *fhp, unsigned int subclass)
{
	struct dentry	*dentry = fhp->fh_dentry;
	struct inode	*inode;

	BUG_ON(!dentry);

	if (fhp->fh_locked) {
		printk(KERN_WARNING "fh_lock: %pd2 already locked!\n",
			dentry);
		return;
	}

	inode = d_inode(dentry);
	inode_lock_nested(inode, subclass);
	fill_pre_wcc(fhp);
	fhp->fh_locked = true;
}

static inline void
fh_lock(struct svc_fh *fhp)
{
	fh_lock_nested(fhp, I_MUTEX_NORMAL);
}

/*
 * Unlock a file handle/inode
 */
static inline void
fh_unlock(struct svc_fh *fhp)
{
	if (fhp->fh_locked) {
		fill_post_wcc(fhp);
		inode_unlock(d_inode(fhp->fh_dentry));
		fhp->fh_locked = false;
	}
}

#endif /* _LINUX_NFSD_NFSFH_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
9c69de4c CH	2	/*
	3	* Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
	4	*
	5	* This file describes the layout of the file handles as passed
	6	* over the wire.
	7	*/
	8	#ifndef _LINUX_NFSD_NFSFH_H
	9	#define _LINUX_NFSD_NFSFH_H
	10
6e8b50d1	11	#include <linux/crc32.h>
9c69de4c CH	12	#include <linux/sunrpc/svc.h>
9c69de4c CH	13	#include <uapi/linux/nfsd/nfsfh.h>
1f15a550	14	#include <linux/iversion.h>
3cc55f44	15	#include <linux/exportfs.h>
9c69de4c CH	16
	17	static inline __u32 ino_t_to_u32(ino_t ino)
	18	{
	19	return (__u32) ino;
	20	}
	21
	22	static inline ino_t u32_to_ino_t(__u32 uino)
	23	{
	24	return (ino_t) uino;
	25	}
1557aca7	26
9c69de4c CH	27	/*
	28	* This is the internal representation of an NFS handle used in knfsd.
	29	* pre_mtime/post_version will be used to support wcc_attr's in NFSv3.
	30	*/
	31	typedef struct svc_fh {
	32	struct knfsd_fh fh_handle; /* FH data */
fcaba026	33	int fh_maxsize; /* max size for fh_handle */
9c69de4c CH	34	struct dentry * fh_dentry; /* validated dentry */
9c69de4c CH	35	struct svc_export * fh_export; /* export pointer */
9c69de4c	36
aaf91ec1 JL	37	bool fh_locked; /* inode locked by us */
aaf91ec1 JL	38	bool fh_want_write; /* remount protection taken */
daab110e	39	bool fh_no_wcc; /* no wcc data needed */
716a8bc7 TM	40	bool fh_no_atomic_attr;
	41	/*
	42	* wcc data is not atomic with
	43	* operation
	44	*/
b9e8638e	45	int fh_flags; /* FH flags */
9c69de4c	46	#ifdef CONFIG_NFSD_V3
aaf91ec1 JL	47	bool fh_post_saved; /* post-op attrs saved */
aaf91ec1 JL	48	bool fh_pre_saved; /* pre-op attrs saved */
9c69de4c CH	49
	50	/* Pre-op attributes saved during fh_lock */
	51	__u64 fh_pre_size; /* size before operation */
92c5e469 AB	52	struct timespec64 fh_pre_mtime; /* mtime before oper */
92c5e469 AB	53	struct timespec64 fh_pre_ctime; /* ctime before oper */
9c69de4c CH	54	/*
	55	* pre-op nfsv4 change attr: note must check IS_I_VERSION(inode)
	56	* to find out if it is valid.
	57	*/
	58	u64 fh_pre_change;
	59
	60	/* Post-op attributes saved in fh_unlock */
	61	struct kstat fh_post_attr; /* full attrs after operation */
	62	u64 fh_post_change; /* nfsv4 change; see above */
	63	#endif /* CONFIG_NFSD_V3 */
9c69de4c	64	} svc_fh;
b9e8638e OK	65	#define NFSD4_FH_FOREIGN (1<<0)
	66	#define SET_FH_FLAG(c, f) ((c)->fh_flags \|= (f))
	67	#define HAS_FH_FLAG(c, f) ((c)->fh_flags & (f))
1557aca7 BF	68
	69	enum nfsd_fsid {
	70	FSID_DEV = 0,
	71	FSID_NUM,
	72	FSID_MAJOR_MINOR,
	73	FSID_ENCODE_DEV,
	74	FSID_UUID4_INUM,
	75	FSID_UUID8,
	76	FSID_UUID16,
	77	FSID_UUID16_INUM,
	78	};
	79
	80	enum fsid_source {
	81	FSIDSOURCE_DEV,
	82	FSIDSOURCE_FSID,
	83	FSIDSOURCE_UUID,
	84	};
2c42f804	85	extern enum fsid_source fsid_source(const struct svc_fh *fhp);
1557aca7 BF	86
1557aca7 BF	87
94ec938b JL	88	/*
94ec938b JL	89	* This might look a little large to "inline" but in all calls except
1557aca7	90	* one, 'vers' is constant so moste of the function disappears.
94ec938b JL	91	*
	92	* In some cases the values are considered to be host endian and in
	93	* others, net endian. fsidv is always considered to be u32 as the
	94	* callers don't know which it will be. So we must use __force to keep
	95	* sparse from complaining. Since these values are opaque to the
	96	* client, that shouldn't be a problem.
1557aca7 BF	97	*/
	98	static inline void mk_fsid(int vers, u32 *fsidv, dev_t dev, ino_t ino,
	99	u32 fsid, unsigned char *uuid)
	100	{
	101	u32 *up;
	102	switch(vers) {
	103	case FSID_DEV:
94ec938b	104	fsidv[0] = (__force __u32)htonl((MAJOR(dev)<<16) \|
1557aca7 BF	105	MINOR(dev));
	106	fsidv[1] = ino_t_to_u32(ino);
	107	break;
	108	case FSID_NUM:
	109	fsidv[0] = fsid;
	110	break;
	111	case FSID_MAJOR_MINOR:
94ec938b JL	112	fsidv[0] = (__force __u32)htonl(MAJOR(dev));
94ec938b JL	113	fsidv[1] = (__force __u32)htonl(MINOR(dev));
1557aca7 BF	114	fsidv[2] = ino_t_to_u32(ino);
	115	break;
	116
	117	case FSID_ENCODE_DEV:
	118	fsidv[0] = new_encode_dev(dev);
	119	fsidv[1] = ino_t_to_u32(ino);
	120	break;
	121
	122	case FSID_UUID4_INUM:
	123	/* 4 byte fsid and inode number */
	124	up = (u32*)uuid;
	125	fsidv[0] = ino_t_to_u32(ino);
	126	fsidv[1] = up[0] ^ up[1] ^ up[2] ^ up[3];
	127	break;
	128
	129	case FSID_UUID8:
	130	/* 8 byte fsid */
	131	up = (u32*)uuid;
	132	fsidv[0] = up[0] ^ up[2];
	133	fsidv[1] = up[1] ^ up[3];
	134	break;
	135
	136	case FSID_UUID16:
	137	/* 16 byte fsid - NFSv3+ only */
	138	memcpy(fsidv, uuid, 16);
	139	break;
	140
	141	case FSID_UUID16_INUM:
	142	/* 8 byte inode and 16 byte fsid */
	143	(u64)fsidv = (u64)ino;
	144	memcpy(fsidv+2, uuid, 16);
	145	break;
	146	default: BUG();
	147	}
	148	}
	149
	150	static inline int key_len(int type)
	151	{
	152	switch(type) {
	153	case FSID_DEV: return 8;
	154	case FSID_NUM: return 4;
	155	case FSID_MAJOR_MINOR: return 12;
	156	case FSID_ENCODE_DEV: return 8;
	157	case FSID_UUID4_INUM: return 8;
	158	case FSID_UUID8: return 8;
	159	case FSID_UUID16: return 16;
	160	case FSID_UUID16_INUM: return 24;
	161	default: return 0;
	162	}
	163	}
	164
	165	/*
	166	* Shorthand for dprintk()'s
	167	*/
	168	extern char * SVCFH_fmt(struct svc_fh *fhp);
	169
	170	/*
	171	* Function prototypes
	172	*/
175a4eb7	173	__be32 fh_verify(struct svc_rqst , struct svc_fh , umode_t, int);
1557aca7 BF	174	__be32 fh_compose(struct svc_fh , struct svc_export , struct dentry , struct svc_fh );
	175	__be32 fh_update(struct svc_fh *);
	176	void fh_put(struct svc_fh *);
	177
	178	static __inline__ struct svc_fh *
	179	fh_copy(struct svc_fh dst, struct svc_fh src)
	180	{
	181	WARN_ON(src->fh_dentry \|\| src->fh_locked);
	182
	183	dst = src;
	184	return dst;
	185	}
	186
	187	static inline void
	188	fh_copy_shallow(struct knfsd_fh dst, struct knfsd_fh src)
	189	{
	190	dst->fh_size = src->fh_size;
	191	memcpy(&dst->fh_base, &src->fh_base, src->fh_size);
	192	}
	193
	194	static __inline__ struct svc_fh *
	195	fh_init(struct svc_fh *fhp, int maxsize)
	196	{
	197	memset(fhp, 0, sizeof(*fhp));
	198	fhp->fh_maxsize = maxsize;
	199	return fhp;
	200	}
	201
4d94c2ef CH	202	static inline bool fh_match(struct knfsd_fh fh1, struct knfsd_fh fh2)
	203	{
	204	if (fh1->fh_size != fh2->fh_size)
	205	return false;
	206	if (memcmp(fh1->fh_base.fh_pad, fh2->fh_base.fh_pad, fh1->fh_size) != 0)
	207	return false;
	208	return true;
	209	}
	210
9558f250 CH	211	static inline bool fh_fsid_match(struct knfsd_fh fh1, struct knfsd_fh fh2)
	212	{
	213	if (fh1->fh_fsid_type != fh2->fh_fsid_type)
	214	return false;
0ab39de6	215	if (memcmp(fh1->fh_fsid, fh2->fh_fsid, key_len(fh1->fh_fsid_type)) != 0)
9558f250 CH	216	return false;
	217	return true;
	218	}
	219
6e8b50d1 JL	220	#ifdef CONFIG_CRC32
	221	/**
	222	* knfsd_fh_hash - calculate the crc32 hash for the filehandle
	223	* @fh - pointer to filehandle
	224	*
	225	* returns a crc32 hash for the filehandle that is compatible with
	226	* the one displayed by "wireshark".
	227	*/
	228
	229	static inline u32
	230	knfsd_fh_hash(struct knfsd_fh *fh)
	231	{
	232	return ~crc32_le(0xFFFFFFFF, (unsigned char *)&fh->fh_base, fh->fh_size);
	233	}
	234	#else
	235	static inline u32
	236	knfsd_fh_hash(struct knfsd_fh *fh)
	237	{
	238	return 0;
	239	}
	240	#endif
	241
1557aca7	242	#ifdef CONFIG_NFSD_V3
2336745e KM	243	/*
	244	* The wcc data stored in current_fh should be cleared
	245	* between compound ops.
	246	*/
	247	static inline void
	248	fh_clear_wcc(struct svc_fh *fhp)
	249	{
aaf91ec1 JL	250	fhp->fh_post_saved = false;
aaf91ec1 JL	251	fhp->fh_pre_saved = false;
2336745e KM	252	}
2336745e KM	253
630458e7 BF	254	/*
	255	* We could use i_version alone as the change attribute. However,
	256	* i_version can go backwards after a reboot. On its own that doesn't
	257	* necessarily cause a problem, but if i_version goes backwards and then
	258	* is incremented again it could reuse a value that was previously used
	259	* before boot, and a client who queried the two values might
	260	* incorrectly assume nothing changed.
	261	*
	262	* By using both ctime and the i_version counter we guarantee that as
	263	* long as time doesn't go backwards we never reuse an old value.
	264	*/
39ca1bf6 AG	265	static inline u64 nfsd4_change_attribute(struct kstat *stat,
39ca1bf6 AG	266	struct inode *inode)
630458e7	267	{
3cc55f44 BF	268	if (inode->i_sb->s_export_op->fetch_iversion)
	269	return inode->i_sb->s_export_op->fetch_iversion(inode);
	270	else if (IS_I_VERSION(inode)) {
4b03d997 BF	271	u64 chattr;
4b03d997 BF	272
70b87f77 BF	273	chattr = stat->ctime.tv_sec;
	274	chattr <<= 30;
	275	chattr += stat->ctime.tv_nsec;
	276	chattr += inode_query_iversion(inode);
4b03d997 BF	277	return chattr;
	278	} else
	279	return time_to_chattr(&stat->ctime);
630458e7 BF	280	}
630458e7 BF	281
39ca1bf6 AG	282	extern void fill_pre_wcc(struct svc_fh *fhp);
39ca1bf6 AG	283	extern void fill_post_wcc(struct svc_fh *fhp);
1557aca7	284	#else
2336745e KM	285	#define fh_clear_wcc(ignored)
2336745e KM	286	#define fill_pre_wcc(ignored)
1557aca7 BF	287	#define fill_post_wcc(notused)
	288	#endif /* CONFIG_NFSD_V3 */
	289
	290
	291	/*
	292	* Lock a file handle/inode
	293	* NOTE: both fh_lock and fh_unlock are done "by hand" in
	294	* vfs.c:nfsd_rename as it needs to grab 2 i_mutex's at once
	295	* so, any changes here should be reflected there.
	296	*/
	297
	298	static inline void
	299	fh_lock_nested(struct svc_fh *fhp, unsigned int subclass)
	300	{
	301	struct dentry *dentry = fhp->fh_dentry;
	302	struct inode *inode;
	303
	304	BUG_ON(!dentry);
	305
	306	if (fhp->fh_locked) {
a6a9f18f AV	307	printk(KERN_WARNING "fh_lock: %pd2 already locked!\n",
a6a9f18f AV	308	dentry);
1557aca7 BF	309	return;
	310	}
	311
2b0143b5	312	inode = d_inode(dentry);
5955102c	313	inode_lock_nested(inode, subclass);
1557aca7	314	fill_pre_wcc(fhp);
aaf91ec1	315	fhp->fh_locked = true;
1557aca7 BF	316	}
	317
	318	static inline void
	319	fh_lock(struct svc_fh *fhp)
	320	{
	321	fh_lock_nested(fhp, I_MUTEX_NORMAL);
	322	}
	323
	324	/*
	325	* Unlock a file handle/inode
	326	*/
	327	static inline void
	328	fh_unlock(struct svc_fh *fhp)
	329	{
1557aca7 BF	330	if (fhp->fh_locked) {
1557aca7 BF	331	fill_post_wcc(fhp);
5955102c	332	inode_unlock(d_inode(fhp->fh_dentry));
aaf91ec1	333	fhp->fh_locked = false;
1557aca7 BF	334	}
	335	}
	336
9c69de4c	337	#endif /* _LINUX_NFSD_NFSFH_H */