[mirror_ubuntu-bionic-kernel.git] / include / linux / nfsd / nfsfh.h

/*
 * include/linux/nfsd/nfsfh.h
 *
 * This file describes the layout of the file handles as passed
 * over the wire.
 *
 * Earlier versions of knfsd used to sign file handles using keyed MD5
 * or SHA. I've removed this code, because it doesn't give you more
 * security than blocking external access to port 2049 on your firewall.
 *
 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
 */

#ifndef _LINUX_NFSD_FH_H
#define _LINUX_NFSD_FH_H

#include <asm/types.h>
#ifdef __KERNEL__
# include <linux/types.h>
# include <linux/string.h>
# include <linux/fs.h>
#endif
#include <linux/nfsd/const.h>
#include <linux/nfsd/debug.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 file handle.
 * by Neil Brown <neilb@cse.unsw.edu.au> - March 2000
 *
 * The file handle is seens as a list of 4byte words.
 * The first word contains a version number (1) and four 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 4byte values are in host-byte-order.
 *
 * The auth_type field specifies how the filehandle can be authenticated
 * This might allow a file to be confirmed to be in a writable part of a
 * filetree without checking the path from it upto the root.
 * Current values:
 *     0  - No authentication.  fb_auth is 0 bytes long
 * Possible future values:
 *     1  - 4 bytes taken from MD5 hash of the remainer of the file handle
 *          prefixed by a secret and with the important export flags.
 *
 * 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
 *
 * The fileid_type identified how the file within the filesystem is encoded.
 * This is (will be) passed to, and set by, the underlying filesystem if it supports
 * filehandle operations.  The filesystem must not use the value '0' or '0xff' and may
 * only use the values 1 and 2 as defined below:
 *  Current values:
 *    0   - The root, or export point, of the filesystem.  fb_fileid is 0 bytes.
 *    1   - 32bit inode number, 32 bit generation number.
 *    2   - 32bit inode number, 32 bit generation number, 32 bit parent directory inode number.
 *
 */
struct nfs_fhbase_new {
	__u8		fb_version;	/* == 1, even => nfs_fhbase_old */
	__u8		fb_auth_type;
	__u8		fb_fsid_type;
	__u8		fb_fileid_type;
	__u32		fb_auth[1];
/*	__u32		fb_fsid[0]; floating */
/*	__u32		fb_fileid[0]; floating */
};

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_auth			fh_base.fh_new.fb_auth
#define	fh_fsid			fh_base.fh_new.fb_auth

#ifdef __KERNEL__

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 */
	struct dentry *		fh_dentry;	/* validated dentry */
	struct svc_export *	fh_export;	/* export pointer */
	int			fh_maxsize;	/* max size for fh_handle */

	unsigned char		fh_locked;	/* inode locked by us */

#ifdef CONFIG_NFSD_V3
	unsigned char		fh_post_saved;	/* post-op attrs saved */
	unsigned char		fh_pre_saved;	/* pre-op attrs saved */

	/* Pre-op attributes saved during fh_lock */
	__u64			fh_pre_size;	/* size before operation */
	struct timespec		fh_pre_mtime;	/* mtime before oper */
	struct timespec		fh_pre_ctime;	/* ctime before oper */

	/* Post-op attributes saved in fh_unlock */
	umode_t			fh_post_mode;	/* i_mode */
	nlink_t			fh_post_nlink;	/* i_nlink */
	uid_t			fh_post_uid;	/* i_uid */
	gid_t			fh_post_gid;	/* i_gid */
	__u64			fh_post_size;	/* i_size */
	unsigned long		fh_post_blocks; /* i_blocks */
	unsigned long		fh_post_blksize;/* i_blksize */
	__be32			fh_post_rdev[2];/* i_rdev */
	struct timespec		fh_post_atime;	/* i_atime */
	struct timespec		fh_post_mtime;	/* i_mtime */
	struct timespec		fh_post_ctime;	/* i_ctime */
#endif /* CONFIG_NFSD_V3 */

} svc_fh;

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(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.
 */
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] = 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] = htonl(MAJOR(dev));
		fsidv[1] = 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 *, int, 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__ struct svc_fh *
fh_init(struct svc_fh *fhp, int maxsize)
{
	memset(fhp, 0, sizeof(*fhp));
	fhp->fh_maxsize = maxsize;
	return fhp;
}

#ifdef CONFIG_NFSD_V3
/*
 * Fill in the pre_op attr for the wcc data
 */
static inline void
fill_pre_wcc(struct svc_fh *fhp)
{
	struct inode    *inode;

	inode = fhp->fh_dentry->d_inode;
	if (!fhp->fh_pre_saved) {
		fhp->fh_pre_mtime = inode->i_mtime;
		fhp->fh_pre_ctime = inode->i_ctime;
			fhp->fh_pre_size  = inode->i_size;
			fhp->fh_pre_saved = 1;
	}
}

/*
 * Fill in the post_op attr for the wcc data
 */
static inline void
fill_post_wcc(struct svc_fh *fhp)
{
	struct inode    *inode = fhp->fh_dentry->d_inode;

	if (fhp->fh_post_saved)
		printk("nfsd: inode locked twice during operation.\n");

	fhp->fh_post_mode       = inode->i_mode;
	fhp->fh_post_nlink      = inode->i_nlink;
	fhp->fh_post_uid	= inode->i_uid;
	fhp->fh_post_gid	= inode->i_gid;
	fhp->fh_post_size       = inode->i_size;
	fhp->fh_post_blksize    = BLOCK_SIZE;
	fhp->fh_post_blocks     = inode->i_blocks;
	fhp->fh_post_rdev[0]    = htonl((u32)imajor(inode));
	fhp->fh_post_rdev[1]    = htonl((u32)iminor(inode));
	fhp->fh_post_atime      = inode->i_atime;
	fhp->fh_post_mtime      = inode->i_mtime;
	fhp->fh_post_ctime      = inode->i_ctime;
	fhp->fh_post_saved      = 1;
}
#else
#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;

	dfprintk(FILEOP, "nfsd: fh_lock(%s) locked = %d\n",
			SVCFH_fmt(fhp), fhp->fh_locked);

	BUG_ON(!dentry);

	if (fhp->fh_locked) {
		printk(KERN_WARNING "fh_lock: %s/%s already locked!\n",
			dentry->d_parent->d_name.name, dentry->d_name.name);
		return;
	}

	inode = dentry->d_inode;
	mutex_lock_nested(&inode->i_mutex, subclass);
	fill_pre_wcc(fhp);
	fhp->fh_locked = 1;
}

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)
{
	BUG_ON(!fhp->fh_dentry);

	if (fhp->fh_locked) {
		fill_post_wcc(fhp);
		mutex_unlock(&fhp->fh_dentry->d_inode->i_mutex);
		fhp->fh_locked = 0;
	}
}
#endif /* __KERNEL__ */


#endif /* _LINUX_NFSD_FH_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* include/linux/nfsd/nfsfh.h
	3	*
	4	* This file describes the layout of the file handles as passed
	5	* over the wire.
	6	*
	7	* Earlier versions of knfsd used to sign file handles using keyed MD5
	8	* or SHA. I've removed this code, because it doesn't give you more
	9	* security than blocking external access to port 2049 on your firewall.
	10	*
	11	* Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
	12	*/
	13
	14	#ifndef _LINUX_NFSD_FH_H
	15	#define _LINUX_NFSD_FH_H
	16
	17	#include <asm/types.h>
	18	#ifdef __KERNEL__
1da177e4 LT	19	# include <linux/types.h>
	20	# include <linux/string.h>
	21	# include <linux/fs.h>
	22	#endif
	23	#include <linux/nfsd/const.h>
	24	#include <linux/nfsd/debug.h>
	25
	26	/*
	27	* This is the old "dentry style" Linux NFSv2 file handle.
	28	*
	29	* The xino and xdev fields are currently used to transport the
	30	* ino/dev of the exported inode.
	31	*/
	32	struct nfs_fhbase_old {
	33	__u32 fb_dcookie; /* dentry cookie - always 0xfeebbaca */
	34	__u32 fb_ino; /* our inode number */
	35	__u32 fb_dirino; /* dir inode number, 0 for directories */
	36	__u32 fb_dev; /* our device */
	37	__u32 fb_xdev;
	38	__u32 fb_xino;
	39	__u32 fb_generation;
	40	};
	41
	42	/*
	43	* This is the new flexible, extensible style NFSv2/v3 file handle.
	44	* by Neil Brown <neilb@cse.unsw.edu.au> - March 2000
	45	*
	46	* The file handle is seens as a list of 4byte words.
	47	* The first word contains a version number (1) and four descriptor bytes
	48	* that tell how the remaining 3 variable length fields should be handled.
	49	* These three bytes are auth_type, fsid_type and fileid_type.
	50	*
	51	* All 4byte values are in host-byte-order.
	52	*
	53	* The auth_type field specifies how the filehandle can be authenticated
	54	* This might allow a file to be confirmed to be in a writable part of a
	55	* filetree without checking the path from it upto the root.
	56	* Current values:
	57	* 0 - No authentication. fb_auth is 0 bytes long
	58	* Possible future values:
	59	* 1 - 4 bytes taken from MD5 hash of the remainer of the file handle
	60	* prefixed by a secret and with the important export flags.
	61	*
	62	* The fsid_type identifies how the filesystem (or export point) is
	63	* encoded.
	64	* Current values:
	65	* 0 - 4 byte device id (ms-2-bytes major, ls-2-bytes minor), 4byte inode number
	66	* NOTE: we cannot use the kdev_t device id value, because kdev_t.h
	67	* says we mustn't. We must break it up and reassemble.
	68	* 1 - 4 byte user specified identifier
	69	* 2 - 4 byte major, 4 byte minor, 4 byte inode number - DEPRECATED
	70	* 3 - 4 byte device id, encoded for user-space, 4 byte inode number
	71	*
	72	* The fileid_type identified how the file within the filesystem is encoded.
	73	* This is (will be) passed to, and set by, the underlying filesystem if it supports
	74	* filehandle operations. The filesystem must not use the value '0' or '0xff' and may
	75	* only use the values 1 and 2 as defined below:
	76	* Current values:
	77	* 0 - The root, or export point, of the filesystem. fb_fileid is 0 bytes.
	78	* 1 - 32bit inode number, 32 bit generation number.
	79	* 2 - 32bit inode number, 32 bit generation number, 32 bit parent directory inode number.
	80	*
	81	*/
	82	struct nfs_fhbase_new {
83	__u8 fb_version; /* == 1, even => nfs_fhbase_old */
84	__u8 fb_auth_type;
85	__u8 fb_fsid_type;
86	__u8 fb_fileid_type;
87	__u32 fb_auth[1];
88	/* __u32 fb_fsid[0]; floating */
89	/* __u32 fb_fileid[0]; floating */
90	};
91
92	struct knfsd_fh {
93	unsigned int fh_size; /* significant for NFSv3.
94	* Points to the current size while building
95	* a new file handle
96	*/
97	union {
98	struct nfs_fhbase_old fh_old;
99	__u32 fh_pad[NFS4_FHSIZE/4];
100	struct nfs_fhbase_new fh_new;
101	} fh_base;
102	};
103
104	#define ofh_dcookie fh_base.fh_old.fb_dcookie
105	#define ofh_ino fh_base.fh_old.fb_ino
106	#define ofh_dirino fh_base.fh_old.fb_dirino
107	#define ofh_dev fh_base.fh_old.fb_dev
108	#define ofh_xdev fh_base.fh_old.fb_xdev
109	#define ofh_xino fh_base.fh_old.fb_xino
110	#define ofh_generation fh_base.fh_old.fb_generation
111
112	#define fh_version fh_base.fh_new.fb_version
113	#define fh_fsid_type fh_base.fh_new.fb_fsid_type
114	#define fh_auth_type fh_base.fh_new.fb_auth_type
115	#define fh_fileid_type fh_base.fh_new.fb_fileid_type
116	#define fh_auth fh_base.fh_new.fb_auth
117	#define fh_fsid fh_base.fh_new.fb_auth
118
119	#ifdef __KERNEL__
120
121	static inline __u32 ino_t_to_u32(ino_t ino)
122	{
123	return (__u32) ino;
124	}
125
126	static inline ino_t u32_to_ino_t(__u32 uino)
127	{
128	return (ino_t) uino;
129	}
130
131	/*
132	* This is the internal representation of an NFS handle used in knfsd.
133	* pre_mtime/post_version will be used to support wcc_attr's in NFSv3.
134	*/
135	typedef struct svc_fh {
136	struct knfsd_fh fh_handle; /* FH data */
137	struct dentry * fh_dentry; /* validated dentry */
138	struct svc_export * fh_export; /* export pointer */
139	int fh_maxsize; /* max size for fh_handle */
140
141	unsigned char fh_locked; /* inode locked by us */
142
143	#ifdef CONFIG_NFSD_V3
144	unsigned char fh_post_saved; /* post-op attrs saved */
145	unsigned char fh_pre_saved; /* pre-op attrs saved */
146
147	/* Pre-op attributes saved during fh_lock */
148	__u64 fh_pre_size; /* size before operation */
149	struct timespec fh_pre_mtime; /* mtime before oper */
150	struct timespec fh_pre_ctime; /* ctime before oper */
151
152	/* Post-op attributes saved in fh_unlock */
153	umode_t fh_post_mode; /* i_mode */
154	nlink_t fh_post_nlink; /* i_nlink */
155	uid_t fh_post_uid; /* i_uid */
156	gid_t fh_post_gid; /* i_gid */
157	__u64 fh_post_size; /* i_size */
158	unsigned long fh_post_blocks; /* i_blocks */
159	unsigned long fh_post_blksize;/* i_blksize */
c7afef1f	160	__be32 fh_post_rdev[2];/* i_rdev */
1da177e4 LT	161	struct timespec fh_post_atime; /* i_atime */
	162	struct timespec fh_post_mtime; /* i_mtime */
	163	struct timespec fh_post_ctime; /* i_ctime */
	164	#endif /* CONFIG_NFSD_V3 */
	165
	166	} svc_fh;
	167
af6a4e28 N	168	enum nfsd_fsid {
	169	FSID_DEV = 0,
	170	FSID_NUM,
	171	FSID_MAJOR_MINOR,
	172	FSID_ENCODE_DEV,
	173	FSID_UUID4_INUM,
	174	FSID_UUID8,
	175	FSID_UUID16,
	176	FSID_UUID16_INUM,
	177	};
1da177e4	178
af6a4e28 N	179	enum fsid_source {
	180	FSIDSOURCE_DEV,
	181	FSIDSOURCE_FSID,
	182	FSIDSOURCE_UUID,
	183	};
	184	extern enum fsid_source fsid_source(struct svc_fh *fhp);
1da177e4	185
1da177e4	186
af6a4e28 N	187	/* This might look a little large to "inline" but in all calls except
	188	* one, 'vers' is constant so moste of the function disappears.
	189	*/
	190	static inline void mk_fsid(int vers, u32 *fsidv, dev_t dev, ino_t ino,
	191	u32 fsid, unsigned char *uuid)
1da177e4	192	{
af6a4e28 N	193	u32 *up;
	194	switch(vers) {
	195	case FSID_DEV:
	196	fsidv[0] = htonl((MAJOR(dev)<<16) \|
	197	MINOR(dev));
	198	fsidv[1] = ino_t_to_u32(ino);
	199	break;
	200	case FSID_NUM:
	201	fsidv[0] = fsid;
	202	break;
	203	case FSID_MAJOR_MINOR:
	204	fsidv[0] = htonl(MAJOR(dev));
	205	fsidv[1] = htonl(MINOR(dev));
	206	fsidv[2] = ino_t_to_u32(ino);
	207	break;
	208
	209	case FSID_ENCODE_DEV:
	210	fsidv[0] = new_encode_dev(dev);
	211	fsidv[1] = ino_t_to_u32(ino);
	212	break;
	213
	214	case FSID_UUID4_INUM:
	215	/* 4 byte fsid and inode number */
	216	up = (u32*)uuid;
	217	fsidv[0] = ino_t_to_u32(ino);
	218	fsidv[1] = up[0] ^ up[1] ^ up[2] ^ up[3];
	219	break;
	220
	221	case FSID_UUID8:
	222	/* 8 byte fsid */
	223	up = (u32*)uuid;
	224	fsidv[0] = up[0] ^ up[2];
	225	fsidv[1] = up[1] ^ up[3];
	226	break;
	227
	228	case FSID_UUID16:
	229	/* 16 byte fsid - NFSv3+ only */
	230	memcpy(fsidv, uuid, 16);
	231	break;
	232
	233	case FSID_UUID16_INUM:
	234	/* 8 byte inode and 16 byte fsid */
	235	(u64)fsidv = (u64)ino;
	236	memcpy(fsidv+2, uuid, 16);
	237	break;
	238	default: BUG();
	239	}
1da177e4 LT	240	}
	241
	242	static inline int key_len(int type)
	243	{
	244	switch(type) {
af6a4e28 N	245	case FSID_DEV: return 8;
	246	case FSID_NUM: return 4;
	247	case FSID_MAJOR_MINOR: return 12;
	248	case FSID_ENCODE_DEV: return 8;
	249	case FSID_UUID4_INUM: return 8;
	250	case FSID_UUID8: return 8;
	251	case FSID_UUID16: return 16;
	252	case FSID_UUID16_INUM: return 24;
1da177e4 LT	253	default: return 0;
	254	}
	255	}
	256
	257	/*
	258	* Shorthand for dprintk()'s
	259	*/
	260	extern char * SVCFH_fmt(struct svc_fh *fhp);
	261
	262	/*
	263	* Function prototypes
	264	*/
83b11340 AV	265	__be32 fh_verify(struct svc_rqst , struct svc_fh , int, int);
	266	__be32 fh_compose(struct svc_fh , struct svc_export , struct dentry , struct svc_fh );
	267	__be32 fh_update(struct svc_fh *);
1da177e4 LT	268	void fh_put(struct svc_fh *);
	269
	270	static __inline__ struct svc_fh *
	271	fh_copy(struct svc_fh dst, struct svc_fh src)
	272	{
e2df0c86	273	WARN_ON(src->fh_dentry \|\| src->fh_locked);
1da177e4 LT	274
	275	dst = src;
	276	return dst;
	277	}
	278
	279	static __inline__ struct svc_fh *
	280	fh_init(struct svc_fh *fhp, int maxsize)
	281	{
	282	memset(fhp, 0, sizeof(*fhp));
	283	fhp->fh_maxsize = maxsize;
	284	return fhp;
	285	}
	286
	287	#ifdef CONFIG_NFSD_V3
	288	/*
	289	* Fill in the pre_op attr for the wcc data
	290	*/
	291	static inline void
	292	fill_pre_wcc(struct svc_fh *fhp)
	293	{
	294	struct inode *inode;
	295
	296	inode = fhp->fh_dentry->d_inode;
	297	if (!fhp->fh_pre_saved) {
	298	fhp->fh_pre_mtime = inode->i_mtime;
	299	fhp->fh_pre_ctime = inode->i_ctime;
	300	fhp->fh_pre_size = inode->i_size;
	301	fhp->fh_pre_saved = 1;
	302	}
	303	}
	304
	305	/*
	306	* Fill in the post_op attr for the wcc data
	307	*/
	308	static inline void
	309	fill_post_wcc(struct svc_fh *fhp)
	310	{
	311	struct inode *inode = fhp->fh_dentry->d_inode;
	312
	313	if (fhp->fh_post_saved)
	314	printk("nfsd: inode locked twice during operation.\n");
	315
	316	fhp->fh_post_mode = inode->i_mode;
	317	fhp->fh_post_nlink = inode->i_nlink;
	318	fhp->fh_post_uid = inode->i_uid;
	319	fhp->fh_post_gid = inode->i_gid;
	320	fhp->fh_post_size = inode->i_size;
ba52de12 TT	321	fhp->fh_post_blksize = BLOCK_SIZE;
ba52de12 TT	322	fhp->fh_post_blocks = inode->i_blocks;
1da177e4 LT	323	fhp->fh_post_rdev[0] = htonl((u32)imajor(inode));
	324	fhp->fh_post_rdev[1] = htonl((u32)iminor(inode));
	325	fhp->fh_post_atime = inode->i_atime;
	326	fhp->fh_post_mtime = inode->i_mtime;
	327	fhp->fh_post_ctime = inode->i_ctime;
	328	fhp->fh_post_saved = 1;
	329	}
	330	#else
	331	#define fill_pre_wcc(ignored)
	332	#define fill_post_wcc(notused)
	333	#endif /* CONFIG_NFSD_V3 */
	334
	335
	336	/*
	337	* Lock a file handle/inode
	338	* NOTE: both fh_lock and fh_unlock are done "by hand" in
1b1dcc1b	339	* vfs.c:nfsd_rename as it needs to grab 2 i_mutex's at once
1da177e4 LT	340	* so, any changes here should be reflected there.
1da177e4 LT	341	*/
12fd3520	342
1da177e4	343	static inline void
12fd3520	344	fh_lock_nested(struct svc_fh *fhp, unsigned int subclass)
1da177e4 LT	345	{
	346	struct dentry *dentry = fhp->fh_dentry;
	347	struct inode *inode;
	348
	349	dfprintk(FILEOP, "nfsd: fh_lock(%s) locked = %d\n",
	350	SVCFH_fmt(fhp), fhp->fh_locked);
	351
e2df0c86 N	352	BUG_ON(!dentry);
e2df0c86 N	353
1da177e4 LT	354	if (fhp->fh_locked) {
	355	printk(KERN_WARNING "fh_lock: %s/%s already locked!\n",
	356	dentry->d_parent->d_name.name, dentry->d_name.name);
	357	return;
	358	}
	359
	360	inode = dentry->d_inode;
12fd3520	361	mutex_lock_nested(&inode->i_mutex, subclass);
1da177e4 LT	362	fill_pre_wcc(fhp);
	363	fhp->fh_locked = 1;
	364	}
	365
12fd3520 PZ	366	static inline void
	367	fh_lock(struct svc_fh *fhp)
	368	{
	369	fh_lock_nested(fhp, I_MUTEX_NORMAL);
	370	}
	371
1da177e4 LT	372	/*
	373	* Unlock a file handle/inode
	374	*/
	375	static inline void
	376	fh_unlock(struct svc_fh *fhp)
	377	{
e2df0c86	378	BUG_ON(!fhp->fh_dentry);
1da177e4 LT	379
	380	if (fhp->fh_locked) {
	381	fill_post_wcc(fhp);
1b1dcc1b	382	mutex_unlock(&fhp->fh_dentry->d_inode->i_mutex);
1da177e4 LT	383	fhp->fh_locked = 0;
	384	}
	385	}
	386	#endif /* __KERNEL__ */
	387
	388
	389	#endif /* _LINUX_NFSD_FH_H */