[linux.git] / fs / nfsd / nfsfh.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <[email protected]>
 *
 * 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>

/*
 * 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 identifies 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 knfsd_fh {
	unsigned int	fh_size;	/*
					 * Points to the current size while
					 * building a new file handle.
					 */
	union {
		char			fh_raw[NFS4_FHSIZE];
		struct {
			u8		fh_version;	/* == 1 */
			u8		fh_auth_type;	/* deprecated */
			u8		fh_fsid_type;
			u8		fh_fileid_type;
			u32		fh_fsid[]; /* flexible-array member */
		};
	};
};

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_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
						 */
	bool			fh_use_wgather;	/* NFSv2 wgather option */
	bool			fh_64bit_cookies;/* readdir cookie size */
	int			fh_flags;	/* FH flags */
	bool			fh_post_saved;	/* post-op attrs saved */
	bool			fh_pre_saved;	/* pre-op attrs saved */

	/* Pre-op attributes saved when inode is locked */
	__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_fill_post_attrs() */
	struct kstat		fh_post_attr;	/* full attrs after operation */
	u64			fh_post_change; /* nfsv4 change; see above */
} 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_verify_local(struct net *, struct svc_cred *, struct auth_domain *,
			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, const struct svc_fh *src)
{
	WARN_ON(src->fh_dentry);

	*dst = *src;
	return dst;
}

static inline void
fh_copy_shallow(struct knfsd_fh *dst, const struct knfsd_fh *src)
{
	dst->fh_size = src->fh_size;
	memcpy(&dst->fh_raw, &src->fh_raw, 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(const struct knfsd_fh *fh1,
			    const struct knfsd_fh *fh2)
{
	if (fh1->fh_size != fh2->fh_size)
		return false;
	if (memcmp(fh1->fh_raw, fh2->fh_raw, fh1->fh_size) != 0)
		return false;
	return true;
}

static inline bool fh_fsid_match(const struct knfsd_fh *fh1,
				 const 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, fh->fh_raw, fh->fh_size);
}
#else
static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
{
	return 0;
}
#endif

/**
 * fh_clear_pre_post_attrs - Reset pre/post attributes
 * @fhp: file handle to be updated
 *
 */
static inline void fh_clear_pre_post_attrs(struct svc_fh *fhp)
{
	fhp->fh_post_saved = false;
	fhp->fh_pre_saved = false;
}

u64 nfsd4_change_attribute(const struct kstat *stat);
__be32 __must_check fh_fill_pre_attrs(struct svc_fh *fhp);
__be32 fh_fill_post_attrs(struct svc_fh *fhp);
__be32 __must_check fh_fill_both_attrs(struct svc_fh *fhp);
#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 <[email protected]>
	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>
ef5825e3 N	16
ef5825e3	17	/*
ef5825e3 N	18	* The file handle starts with a sequence of four-byte words.
	19	* The first word contains a version number (1) and three descriptor bytes
	20	* that tell how the remaining 3 variable length fields should be handled.
	21	* These three bytes are auth_type, fsid_type and fileid_type.
	22	*
	23	* All four-byte values are in host-byte-order.
	24	*
	25	* The auth_type field is deprecated and must be set to 0.
	26	*
	27	* The fsid_type identifies how the filesystem (or export point) is
	28	* encoded.
	29	* Current values:
	30	* 0 - 4 byte device id (ms-2-bytes major, ls-2-bytes minor), 4byte inode number
	31	* NOTE: we cannot use the kdev_t device id value, because kdev_t.h
	32	* says we mustn't. We must break it up and reassemble.
	33	* 1 - 4 byte user specified identifier
	34	* 2 - 4 byte major, 4 byte minor, 4 byte inode number - DEPRECATED
	35	* 3 - 4 byte device id, encoded for user-space, 4 byte inode number
	36	* 4 - 4 byte inode number and 4 byte uuid
	37	* 5 - 8 byte uuid
	38	* 6 - 16 byte uuid
	39	* 7 - 8 byte inode number and 16 byte uuid
	40	*
c645a883	41	* The fileid_type identifies how the file within the filesystem is encoded.
ef5825e3 N	42	* The values for this field are filesystem specific, exccept that
	43	* filesystems must not use the values '0' or '0xff'. 'See enum fid_type'
	44	* in include/linux/exportfs.h for currently registered values.
	45	*/
ef5825e3 N	46
ef5825e3 N	47	struct knfsd_fh {
d8b26071 N	48	unsigned int fh_size; /*
	49	* Points to the current size while
	50	* building a new file handle.
ef5825e3 N	51	*/
ef5825e3 N	52	union {
d8b26071 N	53	char fh_raw[NFS4_FHSIZE];
	54	struct {
	55	u8 fh_version; /* == 1 */
	56	u8 fh_auth_type; /* deprecated */
	57	u8 fh_fsid_type;
	58	u8 fh_fileid_type;
	59	u32 fh_fsid[]; /* flexible-array member */
	60	};
	61	};
ef5825e3 N	62	};
ef5825e3 N	63
9c69de4c CH	64	static inline __u32 ino_t_to_u32(ino_t ino)
	65	{
	66	return (__u32) ino;
	67	}
	68
	69	static inline ino_t u32_to_ino_t(__u32 uino)
	70	{
	71	return (ino_t) uino;
	72	}
1557aca7	73
9c69de4c CH	74	/*
	75	* This is the internal representation of an NFS handle used in knfsd.
	76	* pre_mtime/post_version will be used to support wcc_attr's in NFSv3.
	77	*/
	78	typedef struct svc_fh {
	79	struct knfsd_fh fh_handle; /* FH data */
fcaba026	80	int fh_maxsize; /* max size for fh_handle */
9c69de4c CH	81	struct dentry * fh_dentry; /* validated dentry */
9c69de4c CH	82	struct svc_export * fh_export; /* export pointer */
9c69de4c	83
aaf91ec1	84	bool fh_want_write; /* remount protection taken */
daab110e	85	bool fh_no_wcc; /* no wcc data needed */
716a8bc7 TM	86	bool fh_no_atomic_attr;
	87	/*
	88	* wcc data is not atomic with
	89	* operation
	90	*/
c689bdd3 N	91	bool fh_use_wgather; /* NFSv2 wgather option */
c689bdd3 N	92	bool fh_64bit_cookies;/* readdir cookie size */
b9e8638e	93	int fh_flags; /* FH flags */
aaf91ec1 JL	94	bool fh_post_saved; /* post-op attrs saved */
aaf91ec1 JL	95	bool fh_pre_saved; /* pre-op attrs saved */
9c69de4c	96
dd8dd403	97	/* Pre-op attributes saved when inode is locked */
9c69de4c	98	__u64 fh_pre_size; /* size before operation */
92c5e469 AB	99	struct timespec64 fh_pre_mtime; /* mtime before oper */
92c5e469 AB	100	struct timespec64 fh_pre_ctime; /* ctime before oper */
9c69de4c CH	101	/*
	102	* pre-op nfsv4 change attr: note must check IS_I_VERSION(inode)
	103	* to find out if it is valid.
	104	*/
	105	u64 fh_pre_change;
	106
dd8dd403	107	/* Post-op attributes saved in fh_fill_post_attrs() */
9c69de4c CH	108	struct kstat fh_post_attr; /* full attrs after operation */
9c69de4c CH	109	u64 fh_post_change; /* nfsv4 change; see above */
9c69de4c	110	} svc_fh;
b9e8638e OK	111	#define NFSD4_FH_FOREIGN (1<<0)
	112	#define SET_FH_FLAG(c, f) ((c)->fh_flags \|= (f))
	113	#define HAS_FH_FLAG(c, f) ((c)->fh_flags & (f))
1557aca7 BF	114
	115	enum nfsd_fsid {
	116	FSID_DEV = 0,
	117	FSID_NUM,
	118	FSID_MAJOR_MINOR,
	119	FSID_ENCODE_DEV,
	120	FSID_UUID4_INUM,
	121	FSID_UUID8,
	122	FSID_UUID16,
	123	FSID_UUID16_INUM,
	124	};
	125
	126	enum fsid_source {
	127	FSIDSOURCE_DEV,
	128	FSIDSOURCE_FSID,
	129	FSIDSOURCE_UUID,
	130	};
2c42f804	131	extern enum fsid_source fsid_source(const struct svc_fh *fhp);
1557aca7 BF	132
1557aca7 BF	133
94ec938b JL	134	/*
94ec938b JL	135	* This might look a little large to "inline" but in all calls except
1557aca7	136	* one, 'vers' is constant so moste of the function disappears.
94ec938b JL	137	*
	138	* In some cases the values are considered to be host endian and in
	139	* others, net endian. fsidv is always considered to be u32 as the
	140	* callers don't know which it will be. So we must use __force to keep
	141	* sparse from complaining. Since these values are opaque to the
	142	* client, that shouldn't be a problem.
1557aca7 BF	143	*/
	144	static inline void mk_fsid(int vers, u32 *fsidv, dev_t dev, ino_t ino,
	145	u32 fsid, unsigned char *uuid)
	146	{
	147	u32 *up;
	148	switch(vers) {
	149	case FSID_DEV:
94ec938b	150	fsidv[0] = (__force __u32)htonl((MAJOR(dev)<<16) \|
1557aca7 BF	151	MINOR(dev));
	152	fsidv[1] = ino_t_to_u32(ino);
	153	break;
	154	case FSID_NUM:
	155	fsidv[0] = fsid;
	156	break;
	157	case FSID_MAJOR_MINOR:
94ec938b JL	158	fsidv[0] = (__force __u32)htonl(MAJOR(dev));
94ec938b JL	159	fsidv[1] = (__force __u32)htonl(MINOR(dev));
1557aca7 BF	160	fsidv[2] = ino_t_to_u32(ino);
	161	break;
	162
	163	case FSID_ENCODE_DEV:
	164	fsidv[0] = new_encode_dev(dev);
	165	fsidv[1] = ino_t_to_u32(ino);
	166	break;
	167
	168	case FSID_UUID4_INUM:
	169	/* 4 byte fsid and inode number */
	170	up = (u32*)uuid;
	171	fsidv[0] = ino_t_to_u32(ino);
	172	fsidv[1] = up[0] ^ up[1] ^ up[2] ^ up[3];
	173	break;
	174
	175	case FSID_UUID8:
	176	/* 8 byte fsid */
	177	up = (u32*)uuid;
	178	fsidv[0] = up[0] ^ up[2];
	179	fsidv[1] = up[1] ^ up[3];
	180	break;
	181
	182	case FSID_UUID16:
	183	/* 16 byte fsid - NFSv3+ only */
	184	memcpy(fsidv, uuid, 16);
	185	break;
	186
	187	case FSID_UUID16_INUM:
	188	/* 8 byte inode and 16 byte fsid */
	189	(u64)fsidv = (u64)ino;
	190	memcpy(fsidv+2, uuid, 16);
	191	break;
	192	default: BUG();
	193	}
	194	}
	195
	196	static inline int key_len(int type)
	197	{
	198	switch(type) {
	199	case FSID_DEV: return 8;
	200	case FSID_NUM: return 4;
	201	case FSID_MAJOR_MINOR: return 12;
	202	case FSID_ENCODE_DEV: return 8;
	203	case FSID_UUID4_INUM: return 8;
	204	case FSID_UUID8: return 8;
	205	case FSID_UUID16: return 16;
	206	case FSID_UUID16_INUM: return 24;
	207	default: return 0;
	208	}
	209	}
	210
	211	/*
	212	* Shorthand for dprintk()'s
	213	*/
	214	extern char * SVCFH_fmt(struct svc_fh *fhp);
	215
	216	/*
	217	* Function prototypes
	218	*/
175a4eb7	219	__be32 fh_verify(struct svc_rqst , struct svc_fh , umode_t, int);
c63f0e48 N	220	__be32 fh_verify_local(struct net , struct svc_cred , struct auth_domain *,
c63f0e48 N	221	struct svc_fh *, umode_t, int);
1557aca7 BF	222	__be32 fh_compose(struct svc_fh , struct svc_export , struct dentry , struct svc_fh );
	223	__be32 fh_update(struct svc_fh *);
	224	void fh_put(struct svc_fh *);
	225
	226	static __inline__ struct svc_fh *
b48f8056	227	fh_copy(struct svc_fh dst, const struct svc_fh src)
1557aca7	228	{
dd8dd403 N	229	WARN_ON(src->fh_dentry);
dd8dd403 N	230
1557aca7 BF	231	dst = src;
	232	return dst;
	233	}
	234
	235	static inline void
b48f8056	236	fh_copy_shallow(struct knfsd_fh dst, const struct knfsd_fh src)
1557aca7 BF	237	{
1557aca7 BF	238	dst->fh_size = src->fh_size;
d8b26071	239	memcpy(&dst->fh_raw, &src->fh_raw, src->fh_size);
1557aca7 BF	240	}
	241
	242	static __inline__ struct svc_fh *
	243	fh_init(struct svc_fh *fhp, int maxsize)
	244	{
	245	memset(fhp, 0, sizeof(*fhp));
	246	fhp->fh_maxsize = maxsize;
	247	return fhp;
	248	}
	249
b48f8056 CL	250	static inline bool fh_match(const struct knfsd_fh *fh1,
b48f8056 CL	251	const struct knfsd_fh *fh2)
4d94c2ef CH	252	{
	253	if (fh1->fh_size != fh2->fh_size)
	254	return false;
d8b26071	255	if (memcmp(fh1->fh_raw, fh2->fh_raw, fh1->fh_size) != 0)
4d94c2ef CH	256	return false;
	257	return true;
	258	}
	259
b48f8056 CL	260	static inline bool fh_fsid_match(const struct knfsd_fh *fh1,
b48f8056 CL	261	const struct knfsd_fh *fh2)
9558f250 CH	262	{
	263	if (fh1->fh_fsid_type != fh2->fh_fsid_type)
	264	return false;
0ab39de6	265	if (memcmp(fh1->fh_fsid, fh2->fh_fsid, key_len(fh1->fh_fsid_type)) != 0)
9558f250 CH	266	return false;
	267	return true;
	268	}
	269
6e8b50d1 JL	270	#ifdef CONFIG_CRC32
	271	/**
	272	* knfsd_fh_hash - calculate the crc32 hash for the filehandle
	273	* @fh - pointer to filehandle
	274	*
	275	* returns a crc32 hash for the filehandle that is compatible with
	276	* the one displayed by "wireshark".
	277	*/
1736aec8	278	static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
6e8b50d1	279	{
d8b26071	280	return ~crc32_le(0xFFFFFFFF, fh->fh_raw, fh->fh_size);
6e8b50d1 JL	281	}
6e8b50d1 JL	282	#else
1736aec8	283	static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
6e8b50d1 JL	284	{
	285	return 0;
	286	}
	287	#endif
	288
fcb5e3fa CL	289	/**
	290	* fh_clear_pre_post_attrs - Reset pre/post attributes
	291	* @fhp: file handle to be updated
	292	*
2336745e	293	*/
fcb5e3fa	294	static inline void fh_clear_pre_post_attrs(struct svc_fh *fhp)
2336745e	295	{
aaf91ec1 JL	296	fhp->fh_post_saved = false;
aaf91ec1 JL	297	fhp->fh_pre_saved = false;
2336745e KM	298	}
2336745e KM	299
f67eef8d	300	u64 nfsd4_change_attribute(const struct kstat *stat);
a332018a JL	301	__be32 __must_check fh_fill_pre_attrs(struct svc_fh *fhp);
	302	__be32 fh_fill_post_attrs(struct svc_fh *fhp);
	303	__be32 __must_check fh_fill_both_attrs(struct svc_fh *fhp);
9c69de4c	304	#endif /* _LINUX_NFSD_NFSFH_H */