[linux-2.6-block.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 <linux/iversion.h>
#include <linux/exportfs.h>
#include <linux/nfs4.h>


/*
 * This is the old "dentry style" Linux NFSv2 file handle.
 *
 * The xino and xdev fields are currently used to transport the
 * ino/dev of the exported inode.
 */
struct nfs_fhbase_old {
	u32		fb_dcookie;	/* dentry cookie - always 0xfeebbaca */
	u32		fb_ino;		/* our inode number */
	u32		fb_dirino;	/* dir inode number, 0 for directories */
	u32		fb_dev;		/* our device */
	u32		fb_xdev;
	u32		fb_xino;
	u32		fb_generation;
};

/*
 * This is the new flexible, extensible style NFSv2/v3/v4 file handle.
 *
 * The file handle starts with a sequence of four-byte words.
 * The first word contains a version number (1) and three descriptor bytes
 * that tell how the remaining 3 variable length fields should be handled.
 * These three bytes are auth_type, fsid_type and fileid_type.
 *
 * All four-byte values are in host-byte-order.
 *
 * The auth_type field is deprecated and must be set to 0.
 *
 * The fsid_type identifies how the filesystem (or export point) is
 *    encoded.
 *  Current values:
 *     0  - 4 byte device id (ms-2-bytes major, ls-2-bytes minor), 4byte inode number
 *        NOTE: we cannot use the kdev_t device id value, because kdev_t.h
 *              says we mustn't.  We must break it up and reassemble.
 *     1  - 4 byte user specified identifier
 *     2  - 4 byte major, 4 byte minor, 4 byte inode number - DEPRECATED
 *     3  - 4 byte device id, encoded for user-space, 4 byte inode number
 *     4  - 4 byte inode number and 4 byte uuid
 *     5  - 8 byte uuid
 *     6  - 16 byte uuid
 *     7  - 8 byte inode number and 16 byte uuid
 *
 * The fileid_type identified how the file within the filesystem is encoded.
 *   The values for this field are filesystem specific, exccept that
 *   filesystems must not use the values '0' or '0xff'. 'See enum fid_type'
 *   in include/linux/exportfs.h for currently registered values.
 */
struct nfs_fhbase_new {
	union {
		struct {
			u8		fb_version_aux;	/* == 1, even => nfs_fhbase_old */
			u8		fb_auth_type_aux;
			u8		fb_fsid_type_aux;
			u8		fb_fileid_type_aux;
			u32		fb_auth[1];
		/*	u32		fb_fsid[0]; floating */
		/*	u32		fb_fileid[0]; floating */
		};
		struct {
			u8		fb_version;	/* == 1, even => nfs_fhbase_old */
			u8		fb_auth_type;
			u8		fb_fsid_type;
			u8		fb_fileid_type;
			u32		fb_auth_flex[]; /* flexible-array member */
		};
	};
};

struct knfsd_fh {
	unsigned int	fh_size;	/* significant for NFSv3.
					 * Points to the current size while building
					 * a new file handle
					 */
	union {
		struct nfs_fhbase_old	fh_old;
		u32			fh_pad[NFS4_FHSIZE/4];
		struct nfs_fhbase_new	fh_new;
	} fh_base;
};

#define ofh_dcookie		fh_base.fh_old.fb_dcookie
#define ofh_ino			fh_base.fh_old.fb_ino
#define ofh_dirino		fh_base.fh_old.fb_dirino
#define ofh_dev			fh_base.fh_old.fb_dev
#define ofh_xdev		fh_base.fh_old.fb_xdev
#define ofh_xino		fh_base.fh_old.fb_xino
#define ofh_generation		fh_base.fh_old.fb_generation

#define	fh_version		fh_base.fh_new.fb_version
#define	fh_fsid_type		fh_base.fh_new.fb_fsid_type
#define	fh_auth_type		fh_base.fh_new.fb_auth_type
#define	fh_fileid_type		fh_base.fh_new.fb_fileid_type
#define	fh_fsid			fh_base.fh_new.fb_auth_flex

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(const struct knfsd_fh *fh)
{
	return ~crc32_le(0xFFFFFFFF, (unsigned char *)&fh->fh_base, fh->fh_size);
}
#else
static inline u32 knfsd_fh_hash(const 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	12	#include <linux/sunrpc/svc.h>
1f15a550	13	#include <linux/iversion.h>
3cc55f44	14	#include <linux/exportfs.h>
ef5825e3 N	15	#include <linux/nfs4.h>
	16
	17
	18	/*
	19	* This is the old "dentry style" Linux NFSv2 file handle.
	20	*
	21	* The xino and xdev fields are currently used to transport the
	22	* ino/dev of the exported inode.
	23	*/
	24	struct nfs_fhbase_old {
	25	u32 fb_dcookie; /* dentry cookie - always 0xfeebbaca */
	26	u32 fb_ino; /* our inode number */
	27	u32 fb_dirino; /* dir inode number, 0 for directories */
	28	u32 fb_dev; /* our device */
	29	u32 fb_xdev;
	30	u32 fb_xino;
	31	u32 fb_generation;
	32	};
	33
	34	/*
	35	* This is the new flexible, extensible style NFSv2/v3/v4 file handle.
	36	*
	37	* The file handle starts with a sequence of four-byte words.
	38	* The first word contains a version number (1) and three descriptor bytes
	39	* that tell how the remaining 3 variable length fields should be handled.
	40	* These three bytes are auth_type, fsid_type and fileid_type.
	41	*
	42	* All four-byte values are in host-byte-order.
	43	*
	44	* The auth_type field is deprecated and must be set to 0.
	45	*
	46	* The fsid_type identifies how the filesystem (or export point) is
	47	* encoded.
	48	* Current values:
	49	* 0 - 4 byte device id (ms-2-bytes major, ls-2-bytes minor), 4byte inode number
	50	* NOTE: we cannot use the kdev_t device id value, because kdev_t.h
	51	* says we mustn't. We must break it up and reassemble.
	52	* 1 - 4 byte user specified identifier
	53	* 2 - 4 byte major, 4 byte minor, 4 byte inode number - DEPRECATED
	54	* 3 - 4 byte device id, encoded for user-space, 4 byte inode number
	55	* 4 - 4 byte inode number and 4 byte uuid
	56	* 5 - 8 byte uuid
	57	* 6 - 16 byte uuid
	58	* 7 - 8 byte inode number and 16 byte uuid
	59	*
	60	* The fileid_type identified how the file within the filesystem is encoded.
	61	* The values for this field are filesystem specific, exccept that
	62	* filesystems must not use the values '0' or '0xff'. 'See enum fid_type'
	63	* in include/linux/exportfs.h for currently registered values.
	64	*/
	65	struct nfs_fhbase_new {
	66	union {
	67	struct {
	68	u8 fb_version_aux; /* == 1, even => nfs_fhbase_old */
	69	u8 fb_auth_type_aux;
	70	u8 fb_fsid_type_aux;
	71	u8 fb_fileid_type_aux;
	72	u32 fb_auth[1];
	73	/* u32 fb_fsid[0]; floating */
	74	/* u32 fb_fileid[0]; floating */
	75	};
	76	struct {
	77	u8 fb_version; /* == 1, even => nfs_fhbase_old */
	78	u8 fb_auth_type;
79	u8 fb_fsid_type;
80	u8 fb_fileid_type;
81	u32 fb_auth_flex[]; /* flexible-array member */
82	};
83	};
84	};
85
86	struct knfsd_fh {
87	unsigned int fh_size; /* significant for NFSv3.
88	* Points to the current size while building
89	* a new file handle
90	*/
91	union {
92	struct nfs_fhbase_old fh_old;
93	u32 fh_pad[NFS4_FHSIZE/4];
94	struct nfs_fhbase_new fh_new;
95	} fh_base;
96	};
97
98	#define ofh_dcookie fh_base.fh_old.fb_dcookie
99	#define ofh_ino fh_base.fh_old.fb_ino
100	#define ofh_dirino fh_base.fh_old.fb_dirino
101	#define ofh_dev fh_base.fh_old.fb_dev
102	#define ofh_xdev fh_base.fh_old.fb_xdev
103	#define ofh_xino fh_base.fh_old.fb_xino
104	#define ofh_generation fh_base.fh_old.fb_generation
105
106	#define fh_version fh_base.fh_new.fb_version
107	#define fh_fsid_type fh_base.fh_new.fb_fsid_type
108	#define fh_auth_type fh_base.fh_new.fb_auth_type
109	#define fh_fileid_type fh_base.fh_new.fb_fileid_type
110	#define fh_fsid fh_base.fh_new.fb_auth_flex
9c69de4c CH	111
	112	static inline __u32 ino_t_to_u32(ino_t ino)
	113	{
	114	return (__u32) ino;
	115	}
	116
	117	static inline ino_t u32_to_ino_t(__u32 uino)
	118	{
	119	return (ino_t) uino;
	120	}
1557aca7	121
9c69de4c CH	122	/*
	123	* This is the internal representation of an NFS handle used in knfsd.
	124	* pre_mtime/post_version will be used to support wcc_attr's in NFSv3.
	125	*/
	126	typedef struct svc_fh {
	127	struct knfsd_fh fh_handle; /* FH data */
fcaba026	128	int fh_maxsize; /* max size for fh_handle */
9c69de4c CH	129	struct dentry * fh_dentry; /* validated dentry */
9c69de4c CH	130	struct svc_export * fh_export; /* export pointer */
9c69de4c	131
aaf91ec1 JL	132	bool fh_locked; /* inode locked by us */
aaf91ec1 JL	133	bool fh_want_write; /* remount protection taken */
daab110e	134	bool fh_no_wcc; /* no wcc data needed */
716a8bc7 TM	135	bool fh_no_atomic_attr;
	136	/*
	137	* wcc data is not atomic with
	138	* operation
	139	*/
b9e8638e	140	int fh_flags; /* FH flags */
9c69de4c	141	#ifdef CONFIG_NFSD_V3
aaf91ec1 JL	142	bool fh_post_saved; /* post-op attrs saved */
aaf91ec1 JL	143	bool fh_pre_saved; /* pre-op attrs saved */
9c69de4c CH	144
	145	/* Pre-op attributes saved during fh_lock */
	146	__u64 fh_pre_size; /* size before operation */
92c5e469 AB	147	struct timespec64 fh_pre_mtime; /* mtime before oper */
92c5e469 AB	148	struct timespec64 fh_pre_ctime; /* ctime before oper */
9c69de4c CH	149	/*
	150	* pre-op nfsv4 change attr: note must check IS_I_VERSION(inode)
	151	* to find out if it is valid.
	152	*/
	153	u64 fh_pre_change;
	154
	155	/* Post-op attributes saved in fh_unlock */
	156	struct kstat fh_post_attr; /* full attrs after operation */
	157	u64 fh_post_change; /* nfsv4 change; see above */
	158	#endif /* CONFIG_NFSD_V3 */
9c69de4c	159	} svc_fh;
b9e8638e OK	160	#define NFSD4_FH_FOREIGN (1<<0)
	161	#define SET_FH_FLAG(c, f) ((c)->fh_flags \|= (f))
	162	#define HAS_FH_FLAG(c, f) ((c)->fh_flags & (f))
1557aca7 BF	163
	164	enum nfsd_fsid {
	165	FSID_DEV = 0,
	166	FSID_NUM,
	167	FSID_MAJOR_MINOR,
	168	FSID_ENCODE_DEV,
	169	FSID_UUID4_INUM,
	170	FSID_UUID8,
	171	FSID_UUID16,
	172	FSID_UUID16_INUM,
	173	};
	174
	175	enum fsid_source {
	176	FSIDSOURCE_DEV,
	177	FSIDSOURCE_FSID,
	178	FSIDSOURCE_UUID,
	179	};
2c42f804	180	extern enum fsid_source fsid_source(const struct svc_fh *fhp);
1557aca7 BF	181
1557aca7 BF	182
94ec938b JL	183	/*
94ec938b JL	184	* This might look a little large to "inline" but in all calls except
1557aca7	185	* one, 'vers' is constant so moste of the function disappears.
94ec938b JL	186	*
	187	* In some cases the values are considered to be host endian and in
	188	* others, net endian. fsidv is always considered to be u32 as the
	189	* callers don't know which it will be. So we must use __force to keep
	190	* sparse from complaining. Since these values are opaque to the
	191	* client, that shouldn't be a problem.
1557aca7 BF	192	*/
	193	static inline void mk_fsid(int vers, u32 *fsidv, dev_t dev, ino_t ino,
	194	u32 fsid, unsigned char *uuid)
	195	{
	196	u32 *up;
	197	switch(vers) {
	198	case FSID_DEV:
94ec938b	199	fsidv[0] = (__force __u32)htonl((MAJOR(dev)<<16) \|
1557aca7 BF	200	MINOR(dev));
	201	fsidv[1] = ino_t_to_u32(ino);
	202	break;
	203	case FSID_NUM:
	204	fsidv[0] = fsid;
	205	break;
	206	case FSID_MAJOR_MINOR:
94ec938b JL	207	fsidv[0] = (__force __u32)htonl(MAJOR(dev));
94ec938b JL	208	fsidv[1] = (__force __u32)htonl(MINOR(dev));
1557aca7 BF	209	fsidv[2] = ino_t_to_u32(ino);
	210	break;
	211
	212	case FSID_ENCODE_DEV:
	213	fsidv[0] = new_encode_dev(dev);
	214	fsidv[1] = ino_t_to_u32(ino);
	215	break;
	216
	217	case FSID_UUID4_INUM:
	218	/* 4 byte fsid and inode number */
	219	up = (u32*)uuid;
	220	fsidv[0] = ino_t_to_u32(ino);
	221	fsidv[1] = up[0] ^ up[1] ^ up[2] ^ up[3];
	222	break;
	223
	224	case FSID_UUID8:
	225	/* 8 byte fsid */
	226	up = (u32*)uuid;
	227	fsidv[0] = up[0] ^ up[2];
	228	fsidv[1] = up[1] ^ up[3];
	229	break;
	230
	231	case FSID_UUID16:
	232	/* 16 byte fsid - NFSv3+ only */
	233	memcpy(fsidv, uuid, 16);
	234	break;
	235
	236	case FSID_UUID16_INUM:
	237	/* 8 byte inode and 16 byte fsid */
	238	(u64)fsidv = (u64)ino;
	239	memcpy(fsidv+2, uuid, 16);
	240	break;
	241	default: BUG();
	242	}
	243	}
	244
	245	static inline int key_len(int type)
	246	{
	247	switch(type) {
	248	case FSID_DEV: return 8;
	249	case FSID_NUM: return 4;
	250	case FSID_MAJOR_MINOR: return 12;
	251	case FSID_ENCODE_DEV: return 8;
	252	case FSID_UUID4_INUM: return 8;
	253	case FSID_UUID8: return 8;
	254	case FSID_UUID16: return 16;
	255	case FSID_UUID16_INUM: return 24;
	256	default: return 0;
	257	}
	258	}
	259
	260	/*
	261	* Shorthand for dprintk()'s
	262	*/
	263	extern char * SVCFH_fmt(struct svc_fh *fhp);
	264
	265	/*
	266	* Function prototypes
	267	*/
175a4eb7	268	__be32 fh_verify(struct svc_rqst , struct svc_fh , umode_t, int);
1557aca7 BF	269	__be32 fh_compose(struct svc_fh , struct svc_export , struct dentry , struct svc_fh );
	270	__be32 fh_update(struct svc_fh *);
	271	void fh_put(struct svc_fh *);
	272
	273	static __inline__ struct svc_fh *
	274	fh_copy(struct svc_fh dst, struct svc_fh src)
	275	{
	276	WARN_ON(src->fh_dentry \|\| src->fh_locked);
	277
	278	dst = src;
	279	return dst;
	280	}
	281
	282	static inline void
	283	fh_copy_shallow(struct knfsd_fh dst, struct knfsd_fh src)
	284	{
	285	dst->fh_size = src->fh_size;
	286	memcpy(&dst->fh_base, &src->fh_base, src->fh_size);
	287	}
	288
	289	static __inline__ struct svc_fh *
	290	fh_init(struct svc_fh *fhp, int maxsize)
	291	{
	292	memset(fhp, 0, sizeof(*fhp));
	293	fhp->fh_maxsize = maxsize;
	294	return fhp;
	295	}
	296
4d94c2ef CH	297	static inline bool fh_match(struct knfsd_fh fh1, struct knfsd_fh fh2)
	298	{
	299	if (fh1->fh_size != fh2->fh_size)
	300	return false;
	301	if (memcmp(fh1->fh_base.fh_pad, fh2->fh_base.fh_pad, fh1->fh_size) != 0)
	302	return false;
	303	return true;
	304	}
	305
9558f250 CH	306	static inline bool fh_fsid_match(struct knfsd_fh fh1, struct knfsd_fh fh2)
	307	{
	308	if (fh1->fh_fsid_type != fh2->fh_fsid_type)
	309	return false;
0ab39de6	310	if (memcmp(fh1->fh_fsid, fh2->fh_fsid, key_len(fh1->fh_fsid_type)) != 0)
9558f250 CH	311	return false;
	312	return true;
	313	}
	314
6e8b50d1 JL	315	#ifdef CONFIG_CRC32
	316	/**
	317	* knfsd_fh_hash - calculate the crc32 hash for the filehandle
	318	* @fh - pointer to filehandle
	319	*
	320	* returns a crc32 hash for the filehandle that is compatible with
	321	* the one displayed by "wireshark".
	322	*/
1736aec8	323	static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
6e8b50d1 JL	324	{
	325	return ~crc32_le(0xFFFFFFFF, (unsigned char *)&fh->fh_base, fh->fh_size);
	326	}
	327	#else
1736aec8	328	static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
6e8b50d1 JL	329	{
	330	return 0;
	331	}
	332	#endif
	333
1557aca7	334	#ifdef CONFIG_NFSD_V3
2336745e KM	335	/*
	336	* The wcc data stored in current_fh should be cleared
	337	* between compound ops.
	338	*/
	339	static inline void
	340	fh_clear_wcc(struct svc_fh *fhp)
	341	{
aaf91ec1 JL	342	fhp->fh_post_saved = false;
aaf91ec1 JL	343	fhp->fh_pre_saved = false;
2336745e KM	344	}
2336745e KM	345
630458e7 BF	346	/*
	347	* We could use i_version alone as the change attribute. However,
	348	* i_version can go backwards after a reboot. On its own that doesn't
	349	* necessarily cause a problem, but if i_version goes backwards and then
	350	* is incremented again it could reuse a value that was previously used
	351	* before boot, and a client who queried the two values might
	352	* incorrectly assume nothing changed.
	353	*
	354	* By using both ctime and the i_version counter we guarantee that as
	355	* long as time doesn't go backwards we never reuse an old value.
	356	*/
39ca1bf6 AG	357	static inline u64 nfsd4_change_attribute(struct kstat *stat,
39ca1bf6 AG	358	struct inode *inode)
630458e7	359	{
3cc55f44 BF	360	if (inode->i_sb->s_export_op->fetch_iversion)
	361	return inode->i_sb->s_export_op->fetch_iversion(inode);
	362	else if (IS_I_VERSION(inode)) {
4b03d997 BF	363	u64 chattr;
4b03d997 BF	364
70b87f77 BF	365	chattr = stat->ctime.tv_sec;
	366	chattr <<= 30;
	367	chattr += stat->ctime.tv_nsec;
	368	chattr += inode_query_iversion(inode);
4b03d997 BF	369	return chattr;
	370	} else
	371	return time_to_chattr(&stat->ctime);
630458e7 BF	372	}
630458e7 BF	373
39ca1bf6 AG	374	extern void fill_pre_wcc(struct svc_fh *fhp);
39ca1bf6 AG	375	extern void fill_post_wcc(struct svc_fh *fhp);
1557aca7	376	#else
2336745e KM	377	#define fh_clear_wcc(ignored)
2336745e KM	378	#define fill_pre_wcc(ignored)
1557aca7 BF	379	#define fill_post_wcc(notused)
	380	#endif /* CONFIG_NFSD_V3 */
	381
	382
	383	/*
	384	* Lock a file handle/inode
	385	* NOTE: both fh_lock and fh_unlock are done "by hand" in
	386	* vfs.c:nfsd_rename as it needs to grab 2 i_mutex's at once
	387	* so, any changes here should be reflected there.
	388	*/
	389
	390	static inline void
	391	fh_lock_nested(struct svc_fh *fhp, unsigned int subclass)
	392	{
	393	struct dentry *dentry = fhp->fh_dentry;
	394	struct inode *inode;
	395
	396	BUG_ON(!dentry);
	397
	398	if (fhp->fh_locked) {
a6a9f18f AV	399	printk(KERN_WARNING "fh_lock: %pd2 already locked!\n",
a6a9f18f AV	400	dentry);
1557aca7 BF	401	return;
	402	}
	403
2b0143b5	404	inode = d_inode(dentry);
5955102c	405	inode_lock_nested(inode, subclass);
1557aca7	406	fill_pre_wcc(fhp);
aaf91ec1	407	fhp->fh_locked = true;
1557aca7 BF	408	}
	409
	410	static inline void
	411	fh_lock(struct svc_fh *fhp)
	412	{
	413	fh_lock_nested(fhp, I_MUTEX_NORMAL);
	414	}
	415
	416	/*
	417	* Unlock a file handle/inode
	418	*/
	419	static inline void
	420	fh_unlock(struct svc_fh *fhp)
	421	{
1557aca7 BF	422	if (fhp->fh_locked) {
1557aca7 BF	423	fill_post_wcc(fhp);
5955102c	424	inode_unlock(d_inode(fhp->fh_dentry));
aaf91ec1	425	fhp->fh_locked = false;
1557aca7 BF	426	}
	427	}
	428
9c69de4c	429	#endif /* _LINUX_NFSD_NFSFH_H */