/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.

 *

 * Copyright 2012 Nexenta Systems, Inc.  All rights reserved.

 * Copyright (c) 2013 by Delphix. All rights reserved.

 */

/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

#ifndef	_NFS_NFS_H

#define	_NFS_NFS_H

/*	nfs.h 2.38 88/08/19 SMI 	*/

#include <sys/isa_defs.h>

#include <sys/vfs.h>

#include <sys/stream.h>

#include <rpc/types.h>

#include <sys/types32.h>

#ifdef _KERNEL

#include <rpc/rpc_rdma.h>

#include <rpc/rpc.h>

#include <sys/fcntl.h>

#include <sys/kstat.h>

#include <sys/dirent.h>

#include <sys/zone.h>

#include <sys/tsol/label.h>

#include <sys/nvpair.h>

#include <nfs/mount.h>

#include <sys/vfs_opreg.h>

#endif

#include <vm/page.h>

#include <rpc/rpc_sztypes.h>

#include <sys/sysmacros.h>

#ifdef	__cplusplus

extern "C" {

#endif

/*

 * remote file service numbers

 */

#define	NFS_PROGRAM	((rpcprog_t)100003)

#define	NFS_VERSMIN	((rpcvers_t)2)

#define	NFS_VERSMAX	((rpcvers_t)4)

#define	NFS_VERSION	((rpcvers_t)2)

#define	NFS_PORT	2049

/*

 * Used to determine registration and service handling of versions

 */

#define	NFS_VERSMIN_DEFAULT	((rpcvers_t)2)

#define	NFS_VERSMAX_DEFAULT	((rpcvers_t)4)

extern rpcvers_t nfs_versmin;

extern rpcvers_t nfs_versmax;

/*

 * Default delegation setting for the server ==> "on"

 */

#define	NFS_SERVER_DELEGATION_DEFAULT	(TRUE)

/* Maximum size of data portion of a remote request */

#define	NFS_MAXDATA	8192

#define	NFS_MAXNAMLEN	255

#define	NFS_MAXPATHLEN	1024

/*

 * Rpc retransmission parameters

 */

#define	NFS_TIMEO	11	/* initial timeout for clts in 10th of a sec */

#define	NFS_RETRIES	5	/* times to retry request */

#define	NFS_COTS_TIMEO	600	/* initial timeout for cots in 10th of a sec */

/*

 * The value of UID_NOBODY/GID_NOBODY presented to the world via NFS.

 * UID_NOBODY/GID_NOBODY is translated to NFS_UID_NOBODY/NFS_GID_NOBODY

 * when being sent out over the network and NFS_UID_NOBODY/NFS_GID_NOBODY

 * is translated to UID_NOBODY/GID_NOBODY when received.

 */

#define	NFS_UID_NOBODY	-2

#define	NFS_GID_NOBODY	-2

/*

 * maximum transfer size for different interfaces

 */

#define	ECTSIZE	2048

#define	IETSIZE	8192

/*

 * WebNFS error status

 */

enum wnfsstat {

	WNFSERR_CLNT_FLAVOR = 20001	/* invalid client sec flavor */

};

/*

 * Error status

 * Should include all possible net errors.

 * For now we just cast errno into an enum nfsstat.

 */

enum nfsstat {

	NFS_OK = 0,			/* no error */

	NFSERR_PERM = 1,		/* Not owner */

	NFSERR_NOENT = 2,		/* No such file or directory */

	NFSERR_IO = 5,			/* I/O error */

	NFSERR_NXIO = 6,		/* No such device or address */

	NFSERR_ACCES = 13,		/* Permission denied */

	NFSERR_EXIST = 17,		/* File exists */

	NFSERR_XDEV = 18,		/* Cross-device link */

	NFSERR_NODEV = 19,		/* No such device */

	NFSERR_NOTDIR = 20,		/* Not a directory */

	NFSERR_ISDIR = 21,		/* Is a directory */

	NFSERR_INVAL = 22,		/* Invalid argument */

	NFSERR_FBIG = 27,		/* File too large */

	NFSERR_NOSPC = 28,		/* No space left on device */

	NFSERR_ROFS = 30,		/* Read-only file system */

	NFSERR_OPNOTSUPP = 45,		/* Operation not supported */

	NFSERR_NAMETOOLONG = 63,	/* File name too long */

	NFSERR_NOTEMPTY = 66,		/* Directory not empty */

	NFSERR_DQUOT = 69,		/* Disc quota exceeded */

	NFSERR_STALE = 70,		/* Stale NFS file handle */

	NFSERR_REMOTE = 71,		/* Object is remote */

	NFSERR_WFLUSH = 99		/* write cache flushed */

};

typedef enum nfsstat nfsstat;

/*

 * File types

 */

enum nfsftype {

	NFNON,

	NFREG,		/* regular file */

	NFDIR,		/* directory */

	NFBLK,		/* block special */

	NFCHR,		/* character special */

	NFLNK,		/* symbolic link */

	NFSOC		/* socket */

};

/*

 * Macros for converting device numbers to and from the format

 * SunOS 4.x used. SVR4 uses 14 bit majors and 18 bits minors,

 * SunOS 4.x used 8 bit majors and 8 bit minors. It isn't sufficient

 * to use the cmpdev() and expdev() macros because they only compress

 * 7 bit (and smaller) majors. We must compress 8 bit majors too.

 * If the major or minor exceeds 8 bits, then we send it out in

 * full 32 bit format and hope that the peer can deal with it.

 */

#define	SO4_BITSMAJOR	8	/* # of SunOS 4.x major device bits */

#define	SO4_BITSMINOR	8	/* # of SunOS 4.x minor device bits */

#define	SO4_MAXMAJ	0xff	/* SunOS 4.x max major value */

#define	SO4_MAXMIN	0xff	/* SunOS 4.x max minor value */

/*

 * Convert to over-the-wire device number format

 */

#define	nfsv2_cmpdev(x) \

	((uint32_t) \

	((getmajor(x) > SO4_MAXMAJ || getminor(x) > SO4_MAXMIN) ? NODEV : \

	((getmajor(x) << SO4_BITSMINOR) | (getminor(x) & SO4_MAXMIN))))

/*

 * Convert from over-the-wire format to SVR4 device number format

 */

#define	nfsv2_expdev(x) \

	makedevice((((x) >> SO4_BITSMINOR) & SO4_MAXMAJ), (x) & SO4_MAXMIN)

/*

 * Special kludge for fifos (named pipes)  [to adhere to NFS Protocol Spec]

 *

 * VFIFO is not in the protocol spec (VNON will be replaced by VFIFO)

 * so the over-the-wire representation is VCHR with a '-1' device number.

 *

 * NOTE: This kludge becomes unnecessary with the Protocol Revision,

 *	 but it may be necessary to support it (backwards compatibility).

 */

#define	NFS_FIFO_TYPE	NFCHR

#define	NFS_FIFO_MODE	S_IFCHR

#define	NFS_FIFO_DEV	((uint32_t)-1)

/* identify fifo in nfs attributes */

#define	NA_ISFIFO(NA)	(((NA)->na_type == NFS_FIFO_TYPE) && \

			    ((NA)->na_rdev == NFS_FIFO_DEV))

/* set fifo in nfs attributes */

#define	NA_SETFIFO(NA)	{ \

		(NA)->na_type = NFS_FIFO_TYPE; \

		(NA)->na_rdev = NFS_FIFO_DEV; \

		(NA)->na_mode = ((NA)->na_mode & ~S_IFMT) | NFS_FIFO_MODE; \

		}

/*

 * Check for time overflow using a kernel tunable to determine whether

 * we should accept or reject an unsigned 32-bit time value. Time value in NFS

 * v2/3 protocol is unsigned 32 bit, but ILP32 kernel only allows 31 bits.

 * In nfsv4, time value is a signed 64 bit, so needs to be checked for

 * overflow as well (e.g. for setattr). So define the tunable as follows:

 * nfs_allow_preepoch_time is TRUE if pre-epoch (negative) times are allowed

 * and is FALSE (the default) otherwise. For nfsv2/3 this means that

 * if negative times are allowed, the uint32_t time value is interpreted

 * as a signed int, otherwise as a large positive number. For nfsv4,

 * we use the value as is - except that if negative times are not allowed,

 * we will not accept a negative value otw.

 *

 * So for nfsv2/3 (uint32_t):

 *

 * If nfs_allow_preepoch_time is

 * FALSE, the maximum time value is INT32_MAX for 32-bit kernels and

 * UINT32_MAX for 64-bit kernels (to allow times larger than 2038)

 * and the minimum is zero. Note that in that case, a 32-bit application

 * running on a 64-bit kernel will not be able to access files with

 * the larger time values.

 * If nfs_allow_preepoch_time is TRUE, the maximum time value is INT32_MAX

 * for both kernel configurations and the minimum is INT32_MIN.

 *

 * And for nfsv4 (int64_t):

 *

 * nfsv4 allows for negative values in the protocol, and has a 64-bit

 * time field, so nfs_allow_preepoch_time can be ignored.

 */

#ifdef _KERNEL

extern bool_t		nfs_allow_preepoch_time;

#ifdef _LP64

/*

 * If no negative otw values are allowed, may use the full 32-bits of the

 * time to represent time later than 2038, by presenting the value as an

 * unsigned (but this can only be used by 64-bit apps due to cstat32

 * restrictions). If negative values are allowed, cannot represent times

 * after 2038. Either way, all 32 bits have a valid representation.

 */

/* Check if nfstime4 seconds (int64_t) can be stored in the system time */

#define	NFS4_TIME_OK(tt)	TRUE

#define	NFS3_TIME_OVERFLOW(tt)	(FALSE)

#define	NFS2_TIME_OVERFLOW(tt)	(FALSE)

/*

 * check if a time_t (int64_t) is ok when preepoch times are allowed -

 * nfsv2/3: every 32-bit value is accepted, but can't overflow 64->32.

 * nfsv4: every value is valid.

 */

#define	NFS_PREEPOCH_TIME_T_OK(tt)					\

	(((tt) >= (time_t)INT32_MIN) && ((tt) <= (time_t)INT32_MAX))

/*

 * check if a time_t (int64_t) is ok when preepoch times are not allowed -

 * nfsv2/3: every positive 32-bit value is accepted, but can't overflow 64->32.

 * nfsv4: every value is valid.

 */

#define	NFS_NO_PREEPOCH_TIME_T_OK(tt)					\

	(((tt) >= 0) && ((tt) <= (time_t)(ulong_t)UINT32_MAX))

#else /* not _LP64 */

/*

 * Cannot represent times after 2038 in a 32-bit kernel, but we may wish to

 * restrict the use of negative values (which violate the protocol).

 * So if negative times allowed, all uint32 time values are valid. Otherwise

 * only those which are less than INT32_MAX (msb=0).

 *

 * NFSv4 uses int64_t for the time, so in a 32-bit kernel the nfsv4 value

 * must fit in an int32_t.

 */

/* Only allow signed 32-bit time values */

/* Check if an nfstime4 (int64_t) can be stored in the system time */

#define	NFS4_TIME_OK(tt)						\

	(((tt) <= INT32_MAX) &&	((tt) >= INT32_MIN))

#define	NFS3_TIME_OVERFLOW(tt)	((tt) > INT32_MAX)

#define	NFS2_TIME_OVERFLOW(tt)	((tt) > INT32_MAX)

/*

 * check if a time_t (int32_t) is ok when preepoch times are allowed -

 * every 32-bit value is accepted

 */

#define	NFS_PREEPOCH_TIME_T_OK(tt)	TRUE

/*

 * check if a time_t (int32_t) is ok when preepoch times are not allowed -

 * only positive values are accepted.

 */

#define	NFS_NO_PREEPOCH_TIME_T_OK(tt)	((tt) >= 0)

#endif /* _LP64 */

/* Check if an nfstime3 (uint32_t) can be stored in the system time */

#define	NFS3_TIME_OK(tt)						\

	(nfs_allow_preepoch_time || (!NFS3_TIME_OVERFLOW(tt)))

/* Check if an nfs2_timeval (uint32_t) can be stored in the system time. */

#define	NFS2_TIME_OK(tt)						\

	(nfs_allow_preepoch_time || (!NFS2_TIME_OVERFLOW(tt)))

/*

 * Test if time_t (signed long) can be sent over the wire - for v2/3 only if:

 * 1. The time value can fit in a uint32_t; and

 * 2. Either the time value is positive or allow preepoch times.

 * No restrictions for nfsv4.

 */

#define	NFS_TIME_T_OK(tt)						\

	(nfs_allow_preepoch_time ?					\

		NFS_PREEPOCH_TIME_T_OK(tt) : NFS_NO_PREEPOCH_TIME_T_OK(tt))

#define	NFS4_TIME_T_OK(tt)		TRUE

/* Test if all attr times are valid */

#define	NFS_VAP_TIME_OK(vap)						\

	(nfs_allow_preepoch_time ?					\

		(NFS_PREEPOCH_TIME_T_OK((vap)->va_atime.tv_sec) &&	\

		NFS_PREEPOCH_TIME_T_OK((vap)->va_mtime.tv_sec) &&	\

		NFS_PREEPOCH_TIME_T_OK((vap)->va_ctime.tv_sec)) :	\

		(NFS_NO_PREEPOCH_TIME_T_OK((vap)->va_atime.tv_sec) &&	\

		NFS_NO_PREEPOCH_TIME_T_OK((vap)->va_mtime.tv_sec) &&	\

		NFS_NO_PREEPOCH_TIME_T_OK((vap)->va_ctime.tv_sec)))

#define	NFS4_VAP_TIME_OK(vap)			TRUE

/*

 * To extend the sign or not extend the sign, that is the question.

 * Note: The correct way is to code a macro:

 * #define	NFS_TIME_T_CONVERT(tt)					\

 *	(nfs_allow_preepoch_time ? (int32_t)(tt) : (uint32_t)(tt))

 * But the 64-bit compiler does not extend the sign in that case (why?)

 * so we'll do it the ugly way...

 */

#define	NFS_TIME_T_CONVERT(systt, tt)		\

	if (nfs_allow_preepoch_time) {		\

		systt = (int32_t)(tt);		\

	} else {				\

		systt = (uint32_t)(tt);		\

	}

/* macro to check for overflowed time attribute fields - version 3 */

#define	NFS3_FATTR_TIME_OK(attrs)			\

	(NFS3_TIME_OK((attrs)->atime.seconds) &&	\

	NFS3_TIME_OK((attrs)->mtime.seconds) &&		\

	NFS3_TIME_OK((attrs)->ctime.seconds))

/* macro to check for overflowed time attribute fields - version 2 */

#define	NFS2_FATTR_TIME_OK(attrs)			\

	(NFS2_TIME_OK((attrs)->na_atime.tv_sec) &&	\

	NFS2_TIME_OK((attrs)->na_mtime.tv_sec) &&	\

	NFS2_TIME_OK((attrs)->na_ctime.tv_sec))

/* Check that a size3 value is not overflowed */

#define	NFS3_SIZE_OK(size)	((size) <= MAXOFFSET_T)

#endif /* _KERNEL */

/*

 * Size of an fhandle in bytes

 */

#define	NFS_FHSIZE	32

struct nfs_fid {

	ushort_t nf_len;

	ushort_t nf_pad;

	char	nf_data[NFS_FHSIZE];

};

/*

 * "Legacy" filehandles use NFS_FHMAXDATA (10) byte fids. Filesystems that

 * return a larger fid than NFS_FHMAXDATA, such as ZFS's .zfs snapshot

 * directory, can use up to (((64 - 8) / 2) - 2) bytes for their fid.

 * This currently holds for both NFSv3 and NFSv4.

 */

#define	NFS_FHMAXDATA		10

#define	NFS_FH3MAXDATA		26

#define	NFS_FH4MAXDATA		26

/*

 * The original nfs file handle size for version 3 was 32 which was

 * the same in version 2; now we're making it bigger to to deal with

 * ZFS snapshot FIDs.

 *

 * If the size of fhandle3_t changes or if Version 3 uses some other

 * filehandle format, this constant may need to change.

 */

#define	NFS3_OLDFHSIZE	32

#define	NFS3_MAXFHSIZE	64

/*

 * This is the actual definition of a legacy filehandle.  There is some

 * dependence on this layout in NFS-related code, particularly in the

 * user-level lock manager, so be careful about changing it.

 *

 * Currently only NFSv2 uses this structure.

 */

typedef struct svcfh {

	fsid_t	fh_fsid;			/* filesystem id */

	ushort_t fh_len;			/* file number length */

	char	fh_data[NFS_FHMAXDATA];		/* and data */

	ushort_t fh_xlen;			/* export file number length */

	char	fh_xdata[NFS_FHMAXDATA];	/* and data */

} fhandle_t;

/*

 * This is the in-memory structure for an NFSv3 extended filehandle.

 */

typedef struct {

	fsid_t	_fh3_fsid;			/* filesystem id */

	ushort_t _fh3_len;			/* file number length */

	char	_fh3_data[NFS_FH3MAXDATA];		/* and data */

	ushort_t _fh3_xlen;			/* export file number length */

	char	_fh3_xdata[NFS_FH3MAXDATA];	/* and data */

} fhandle3_t;

/*

 * This is the in-memory structure for an NFSv4 extended filehandle.

 */

typedef struct {

	fsid_t	fhx_fsid;			/* filesystem id */

	ushort_t fhx_len;			/* file number length */

	char	fhx_data[NFS_FH4MAXDATA];	/* and data */

	ushort_t fhx_xlen;			/* export file number length */

	char	fhx_xdata[NFS_FH4MAXDATA];	/* and data */

} fhandle4_t;

/*

 * Arguments to remote write and writecache

 */

/*

 * The `over the wire' representation of the first four arguments.

 */

struct otw_nfswriteargs {

	fhandle_t	otw_wa_fhandle;

	uint32_t	otw_wa_begoff;

	uint32_t	otw_wa_offset;

	uint32_t	otw_wa_totcount;

};

struct nfswriteargs {

	struct otw_nfswriteargs *wa_args;	/* ptr to the otw arguments */

	struct otw_nfswriteargs wa_args_buf;	/* space for otw arguments */

	uint32_t	wa_count;

	char		*wa_data;	/* data to write (up to NFS_MAXDATA) */

	mblk_t		*wa_mblk;	/* pointer to mblks containing data */

#ifdef _KERNEL

	/* rdma related info */

	struct clist	*wa_rlist;

	CONN		*wa_conn;

#endif /* _KERNEL */

};

#define	wa_fhandle	wa_args->otw_wa_fhandle

#define	wa_begoff	wa_args->otw_wa_begoff

#define	wa_offset	wa_args->otw_wa_offset

#define	wa_totcount	wa_args->otw_wa_totcount

/*

 * NFS timeval struct using unsigned int as specified in V2 protocol.

 * tv_sec and tv_usec used to match existing code.

 */

struct nfs2_timeval {

	uint32_t tv_sec;

	uint32_t tv_usec;

};

typedef struct nfs2_timeval nfs2_timeval;

/*

 * File attributes

 */

struct nfsfattr {

	enum nfsftype	na_type;	/* file type */

	uint32_t	na_mode;	/* protection mode bits */

	uint32_t	na_nlink;	/* # hard links */

	uint32_t	na_uid;		/* owner user id */

	uint32_t	na_gid;		/* owner group id */

	uint32_t	na_size;	/* file size in bytes */

	uint32_t	na_blocksize;	/* preferred block size */

	uint32_t	na_rdev;	/* special device # */

	uint32_t	na_blocks;	/* Kb of disk used by file */

	uint32_t	na_fsid;	/* device # */

	uint32_t	na_nodeid;	/* inode # */

	struct nfs2_timeval na_atime;	/* time of last access */

	struct nfs2_timeval na_mtime;	/* time of last modification */

	struct nfs2_timeval na_ctime;	/* time of last change */

};

#define	n2v_type(x)	(NA_ISFIFO(x) ? VFIFO : nf_to_vt[(x)->na_type])

#define	n2v_rdev(x)	(NA_ISFIFO(x) ? 0 : (x)->na_rdev)

/*

 * Arguments to remote read

 */

struct nfsreadargs {

	fhandle_t	ra_fhandle;	/* handle for file */

	uint32_t	ra_offset;	/* byte offset in file */

	uint32_t	ra_count;	/* immediate read count */

	uint32_t	ra_totcount;	/* total read cnt (from this offset) */