/*
* 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
* 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 2014 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>
#ifdef _KERNEL
#include <rpc/rpc_rdma.h>
#include <sys/vfs_opreg.h>
#endif
#include <rpc/rpc_sztypes.h>
#include <sys/sysmacros.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* remote file service numbers
*/
/*
* Used to determine registration and service handling of versions
*/
extern rpcvers_t nfs_versmin;
extern rpcvers_t nfs_versmax;
/*
* Default delegation setting for the server ==> "on"
*/
/* Maximum size of data portion of a remote request */
/*
* Rpc retransmission parameters
*/
/*
* 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.
*/
/*
* maximum transfer size for different interfaces
*/
/*
* WebNFS error status
*/
enum wnfsstat {
};
/*
* Error status
* Should include all possible net errors.
* For now we just cast errno into an enum nfsstat.
*/
enum nfsstat {
};
/*
* File types
*/
enum nfsftype {
};
/*
* 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.
*/
/*
* Convert to over-the-wire device number format
*/
#define nfsv2_cmpdev(x) \
((uint32_t) \
/*
* Convert from over-the-wire format to SVR4 device number format
*/
#define nfsv2_expdev(x) \
/*
* 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).
*/
/* identify fifo in nfs attributes */
/* set fifo in nfs attributes */
}
/*
* 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 */
/*
* 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.
*/
/*
* 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.
*/
#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 */
/*
* check if a time_t (int32_t) is ok when preepoch times are allowed -
* every 32-bit value is accepted
*/
/*
* check if a time_t (int32_t) is ok when preepoch times are not allowed -
* only positive values are accepted.
*/
#endif /* _LP64 */
/* Check if an nfstime3 (uint32_t) can be stored in the system time */
/* Check if an nfs2_timeval (uint32_t) can be stored in the system time. */
/*
* 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.
*/
/* Test if all attr times are valid */
/*
* 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...
*/
if (nfs_allow_preepoch_time) { \
} else { \
}
/* macro to check for overflowed time attribute fields - version 3 */
/* macro to check for overflowed time attribute fields - version 2 */
/* Check that a size3 value is not overflowed */
#endif /* _KERNEL */
/*
* Size of an fhandle in bytes
*/
struct nfs_fid {
};
/*
* "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.
*/
/*
* 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.
*/
/*
* 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 {
} fhandle_t;
/*
* This is the in-memory structure for an NFSv3 extended filehandle.
*/
typedef struct {
} fhandle3_t;
/*
* This is the in-memory structure for an NFSv4 extended filehandle.
*/
typedef struct {
} fhandle4_t;
/*
* Arguments to remote write and writecache
*/
/*
* The `over the wire' representation of the first four arguments.
*/
struct otw_nfswriteargs {
};
struct nfswriteargs {
#ifdef _KERNEL
/* rdma related info */
#endif /* _KERNEL */
};
/*
* NFS timeval struct using unsigned int as specified in V2 protocol.
* tv_sec and tv_usec used to match existing code.
*/
struct nfs2_timeval {
};
/*
* File attributes
*/
struct nfsfattr {
};
/*
* Arguments to remote read
*/
struct nfsreadargs {
#ifdef _KERNEL
/* used in rdma transports */
#endif
};
/*
* Status OK portion of remote read reply
*/
struct nfsrrok {
#ifdef _KERNEL
#endif
};
/*
* Reply from remote read
*/
struct nfsrdresult {
union {
} rr_u;
};
/*
* File attributes which can be set
*/
struct nfssattr {
};
/*
* Reply status with file attributes
*/
struct nfsattrstat {
union {
} ns_u;
};
/*
* NFS_OK part of read sym link reply union
*/
struct nfssrok {
};
/*
* Result of reading symbolic link
*/
struct nfsrdlnres {
union {
} rl_u;
};
/*
* Arguments to readdir
*/
struct nfsrddirargs {
};
/*
* NFS_OK part of readdir result
*/
struct nfsrdok {
};
/*
* Readdir result
*/
struct nfsrddirres {
union {
} rd_u;
};
/*
* Arguments for directory operations
*/
struct nfsdiropargs {
};
/*
* NFS_OK part of directory operation result
*/
struct nfsdrok {
};
/*
* Results from directory operation
*/
struct nfsdiropres {
union {
} dr_u;
};
/*
* arguments to setattr
*/
struct nfssaargs {
};
/*
* arguments to create and mkdir
*/
struct nfscreatargs {
};
/*
* arguments to link
*/
struct nfslinkargs {
};
/*
* arguments to rename
*/
struct nfsrnmargs {
};
/*
* arguments to symlink
*/
struct nfsslargs {
};
/*
* NFS_OK part of statfs operation
*/
struct nfsstatfsok {
};
/*
* Results of statfs operation
*/
struct nfsstatfs {
union {
} fs_u;
};
#ifdef _KERNEL
/*
* XDR routines for handling structures defined above
*/
#ifdef _LITTLE_ENDIAN
#endif
#ifdef _LITTLE_ENDIAN
#endif
#endif
/*
* Remote file service routines
*/
#define RFS_NULL 0
#ifdef _KERNEL
/*
* The NFS Version 2 service procedures
*/
struct exportinfo; /* defined in nfs/export.h */
struct servinfo; /* defined in nfs/nfs_clnt.h */
struct mntinfo; /* defined in nfs/nfs_clnt.h */
extern void *rfs_getattr_getfh(fhandle_t *);
extern void *rfs_setattr_getfh(struct nfssaargs *);
extern void *rfs_lookup_getfh(struct nfsdiropargs *);
extern void *rfs_readlink_getfh(fhandle_t *);
extern void rfs_rlfree(struct nfsrdlnres *);
extern void *rfs_read_getfh(struct nfsreadargs *);
extern void rfs_rdfree(struct nfsrdresult *);
extern void *rfs_write_getfh(struct nfswriteargs *);
extern void *rfs_create_getfh(struct nfscreatargs *);
extern void *rfs_remove_getfh(struct nfsdiropargs *);
extern void *rfs_rename_getfh(struct nfsrnmargs *);
extern void *rfs_link_getfh(struct nfslinkargs *);
extern void *rfs_symlink_getfh(struct nfsslargs *);
extern void *rfs_mkdir_getfh(struct nfscreatargs *);
extern void *rfs_rmdir_getfh(struct nfsdiropargs *);
extern void *rfs_readdir_getfh(struct nfsrddirargs *);
extern void rfs_rddirfree(struct nfsrddirres *);
extern void *rfs_statfs_getfh(fhandle_t *);
extern void rfs_srvrinit(void);
extern void rfs_srvrfini(void);
/*
* flags to define path types during Multi Component Lookups
* using the public filehandle
*/
/* index for svstat_ptr */
/* function defs for NFS kernel */
extern int nfs_waitfor_purge_complete(vnode_t *);
extern void nfs_purge_rddir_cache(vnode_t *);
extern void nfs_async_manager(struct vfs *);
extern void nfs_async_manager_stop(struct vfs *);
extern void nfs_async_stop(struct vfs *);
extern int nfs_async_stop_sig(struct vfs *);
extern int nfs_clntinit(void);
extern void nfs_clntfini(void);
extern int nfstsize(void);
extern int nfs_srvinit(void);
extern void nfs_srvfini(void);
extern int newnum(void);
extern char *newname(void);
extern int nfs_subrinit(void);
extern void nfs_subrfini(void);
extern int nfsinit(int, char *);
extern void nfsfini(void);
extern int nfs_vfsinit(void);
extern void nfs_vfsfini(void);
caller_context_t *);
extern void nfs_perror(int, char *, ...);
extern void nfs_cmn_err(int, int, char *, ...);
extern int mount_root(char *, char *, int, struct nfs_args *, int *);
extern void nfs_lockcompletion(vnode_t *, int);
extern void nfsauth_init(void);
extern void nfsauth_fini(void);
struct knetconfig *, cred_t *);
extern boolean_t nfs_has_ctty(void);
extern void nfs_srv_stop_all(void);
extern void nfs_srv_quiesce_all(void);
extern int rfs4_dss_setpaths(char *, size_t);
extern int nfs_setmod_check(page_t *);
extern time_t rfs4_lease_time;
extern time_t rfs4_grace_period;
extern kstat_named_t *global_svstat_ptr[];
extern kstat_named_t *rfsproccnt_v2_ptr;
extern kmutex_t nfs_minor_lock;
extern int nfs_major;
extern int nfs_minor;
extern vfsops_t *nfs_vfsops;
extern struct vnodeops *nfs_vnodeops;
extern const struct fs_operation_def nfs_vnodeops_template[];
extern int nfsfstyp;
extern void (*nfs_srv_quiesce_func)(void);
extern int (*nfs_srv_dss_func)(char *, size_t);
/*
* Per-zone stats as consumed by nfsstat(1m)
*/
struct nfs_version_stats {
};
/*
* A bit of asymmetry: nfs:0:nfs_client isn't part of this structure.
*/
struct nfs_stats {
};
/*
* Key used to retrieve counters.
*/
extern zone_key_t nfsstat_zone_key;
/*
* Zone callback functions.
*/
extern void *nfsstat_zone_init(zoneid_t);
extern void nfsstat_zone_fini(zoneid_t, void *);
#endif /* _KERNEL */
/*
* Version 3 declarations and definitions.
*/
typedef char *filename3;
typedef char *nfspath3;
/*
* These three are really opaque arrays, but we treat them as
* uint64 for efficiency sake
*/
typedef struct nfs_fh3 {
union nfs_fh3_u {
struct nfs_fh3_i {
} nfs_fh3_i;
} fh3_u;
} nfs_fh3;
/*
* nfs_fh3.fh3_flags values
*/
/*
* Two elements were added to the
* diropargs3 structure for performance (xdr-inlining).
* They are not included as part of the args
* that are encoded or decoded:
* dirp - ptr to the nfs_fh3
* flag indicating when to free the name that was
* allocated during decode.
*/
struct diropargs3 {
int flags;
};
struct nfstime3 {
};
struct specdata3 {
};
enum nfsstat3 {
NFS3_OK = 0,
};
enum ftype3 {
};
struct fattr3 {
};
#ifdef _KERNEL
struct fattr3_res {
};
#endif /* _KERNEL */
struct post_op_attr {
};
#ifdef _KERNEL
struct post_op_vattr {
};
#endif /* _KERNEL */
struct wcc_attr {
};
struct pre_op_attr {
};
struct wcc_data {
};
struct post_op_fh3 {
};
enum time_how {
DONT_CHANGE = 0,
};
struct set_mode3 {
};
struct set_uid3 {
};
struct set_gid3 {
};
struct set_size3 {
};
struct set_atime {
};
struct set_mtime {
};
struct sattr3 {
};
/*
* A couple of defines to make resok and resfail look like the
* correct things in a response type independent manner.
*/
struct GETATTR3args {
};
struct GETATTR3resok {
};
struct GETATTR3res {
union {
} res_u;
};
#ifdef _KERNEL
struct GETATTR3vres {
};
#endif /* _KERNEL */
struct sattrguard3 {
};
struct SETATTR3args {
};
struct SETATTR3resok {
};
struct SETATTR3resfail {
};
struct SETATTR3res {
union {
} res_u;
};
struct LOOKUP3args {
};
struct LOOKUP3resok {
};
struct LOOKUP3resfail {
};
struct LOOKUP3res {
union {
} res_u;
};
#ifdef _KERNEL
struct LOOKUP3vres {
};
#endif /* _KERNEL */
struct ACCESS3args {
};
struct ACCESS3resok {
};
struct ACCESS3resfail {
};
struct ACCESS3res {
union {
} res_u;
};
struct READLINK3args {
};
struct READLINK3resok {
};
struct READLINK3resfail {
};
struct READLINK3res {
union {
} res_u;
};
struct READ3args {
#ifdef _KERNEL
/* for read using rdma */
char *res_data_val_alt;
#endif
};
struct READ3resok {
struct {
char *data_val;
} data;
#ifdef _KERNEL
#endif
};
struct READ3resfail {
};
struct READ3res {
union {
} res_u;
};
#ifdef _KERNEL
/*
* READ3 reply that directly decodes fattr3 directly into vattr
*/
struct READ3vres {
struct {
char *data_val;
} data;
};
#endif /* _KERNEL */
/*
* READ3 reply that uiomoves data directly into a struct uio
* ignores any attributes returned
*/
struct READ3uiores {
#ifdef _KERNEL
#endif
};
enum stable_how {
UNSTABLE = 0,
};
struct WRITE3args {
struct {
char *data_val;
} data;
#ifdef _KERNEL
#endif
};
struct WRITE3resok {
};
struct WRITE3resfail {
};
struct WRITE3res {
union {
} res_u;
};
enum createmode3 {
UNCHECKED = 0,
};
struct createhow3 {
union {
} createhow3_u;
};
struct CREATE3args {
};
struct CREATE3resok {
};
struct CREATE3resfail {
};
struct CREATE3res {
union {
} res_u;
};
struct MKDIR3args {
};
struct MKDIR3resok {
};
struct MKDIR3resfail {
};
struct MKDIR3res {
union {
} res_u;
};
struct symlinkdata3 {
};
struct SYMLINK3args {
};
struct SYMLINK3resok {
};
struct SYMLINK3resfail {
};
struct SYMLINK3res {
union {
} res_u;
};
struct devicedata3 {
};
struct mknoddata3 {
union {
} mknoddata3_u;
};
struct MKNOD3args {
};
struct MKNOD3resok {
};
struct MKNOD3resfail {
};
struct MKNOD3res {
union {
} res_u;
};
struct REMOVE3args {
};
struct REMOVE3resok {
};
struct REMOVE3resfail {
};
struct REMOVE3res {
union {
} res_u;
};
struct RMDIR3args {
};
struct RMDIR3resok {
};
struct RMDIR3resfail {
};
struct RMDIR3res {
union {
} res_u;
};
struct RENAME3args {
};
struct RENAME3resok {
};
struct RENAME3resfail {
};
struct RENAME3res {
union {
} res_u;
};
struct LINK3args {
};
struct LINK3resok {
};
struct LINK3resfail {
};
struct LINK3res {
union {
} res_u;
};
struct READDIR3args {
};
struct entry3 {
};
struct dirlist3 {
};
struct READDIR3resok {
};
struct READDIR3resfail {
};
struct READDIR3res {
union {
} res_u;
};
#ifdef _KERNEL
struct READDIR3vres {
};
#endif /* _KERNEL */
struct READDIRPLUS3args {
};
struct entryplus3 {
};
struct dirlistplus3 {
};
struct entryplus3_info {
};
struct READDIRPLUS3resok {
};
struct READDIRPLUS3resfail {
};
struct READDIRPLUS3res {
union {
} res_u;
};
#ifdef _KERNEL
struct entryplus3_va_fh {
int va_valid;
int fh_valid;
};
struct READDIRPLUS3vres {
};
#endif /* _KERNEL */
struct FSSTAT3args {
};
struct FSSTAT3resok {
};
struct FSSTAT3resfail {
};
struct FSSTAT3res {
union {
} res_u;
};
struct FSINFO3args {
};
struct FSINFO3resok {
};
struct FSINFO3resfail {
};
struct FSINFO3res {
union {
} res_u;
};
struct PATHCONF3args {
};
struct nfs3_pathconf_info {
};
struct PATHCONF3resok {
};
struct PATHCONF3resfail {
};
struct PATHCONF3res {
union {
} res_u;
};
struct COMMIT3args {
};
struct COMMIT3resok {
};
struct COMMIT3resfail {
};
struct COMMIT3res {
union {
} res_u;
};
#ifndef _KERNEL
extern void *nfsproc3_null_3();
extern GETATTR3res *nfsproc3_getattr_3();
extern SETATTR3res *nfsproc3_setattr_3();
extern LOOKUP3res *nfsproc3_lookup_3();
extern ACCESS3res *nfsproc3_access_3();
extern READLINK3res *nfsproc3_readlink_3();
extern READ3res *nfsproc3_read_3();
extern WRITE3res *nfsproc3_write_3();
extern CREATE3res *nfsproc3_create_3();
extern MKDIR3res *nfsproc3_mkdir_3();
extern SYMLINK3res *nfsproc3_symlink_3();
extern MKNOD3res *nfsproc3_mknod_3();
extern REMOVE3res *nfsproc3_remove_3();
extern RMDIR3res *nfsproc3_rmdir_3();
extern RENAME3res *nfsproc3_rename_3();
extern LINK3res *nfsproc3_link_3();
extern READDIR3res *nfsproc3_readdir_3();
extern READDIRPLUS3res *nfsproc3_readdirplus_3();
extern FSSTAT3res *nfsproc3_fsstat_3();
extern FSINFO3res *nfsproc3_fsinfo_3();
extern PATHCONF3res *nfsproc3_pathconf_3();
extern COMMIT3res *nfsproc3_commit_3();
#endif /* !_KERNEL */
#ifdef _KERNEL
/* the NFS Version 3 XDR functions */
/*
* The NFS Version 3 service procedures.
*/
struct exportinfo; /* defined in nfs/export.h */
struct servinfo; /* defined in nfs/nfs_clnt.h */
struct mntinfo; /* defined in nfs/nfs_clnt.h */
extern void *rfs3_getattr_getfh(GETATTR3args *);
extern void *rfs3_setattr_getfh(SETATTR3args *);
extern void *rfs3_lookup_getfh(LOOKUP3args *);
extern void *rfs3_access_getfh(ACCESS3args *);
extern void *rfs3_readlink_getfh(READLINK3args *);
extern void rfs3_readlink_free(READLINK3res *);
extern void *rfs3_read_getfh(READ3args *);
extern void rfs3_read_free(READ3res *);
extern void *rfs3_write_getfh(WRITE3args *);
extern void *rfs3_create_getfh(CREATE3args *);
extern void *rfs3_mkdir_getfh(MKDIR3args *);
extern void *rfs3_symlink_getfh(SYMLINK3args *);
extern void *rfs3_mknod_getfh(MKNOD3args *);
extern void *rfs3_remove_getfh(REMOVE3args *);
extern void *rfs3_rmdir_getfh(RMDIR3args *);
extern void *rfs3_rename_getfh(RENAME3args *);
extern void *rfs3_link_getfh(LINK3args *);
extern void *rfs3_readdir_getfh(READDIR3args *);
extern void rfs3_readdir_free(READDIR3res *);
extern void *rfs3_readdirplus_getfh(READDIRPLUS3args *);
extern void rfs3_readdirplus_free(READDIRPLUS3res *);
extern void *rfs3_fsstat_getfh(FSSTAT3args *);
extern void *rfs3_fsinfo_getfh(FSINFO3args *);
extern void *rfs3_pathconf_getfh(PATHCONF3args *);
extern void *rfs3_commit_getfh(COMMIT3args *);
extern void rfs3_srvrinit(void);
extern void rfs3_srvrfini(void);
cred_t *);
cred_t *);
cred_t *);
extern int nfs3tsize(void);
extern int nfs3init(int, char *);
extern void nfs3fini(void);
extern int nfs3_vfsinit(void);
extern void nfs3_vfsfini(void);
struct exportinfo **, struct sec_ol *);
cred_t *, int);
extern kstat_named_t *rfsproccnt_v3_ptr;
extern vfsops_t *nfs3_vfsops;
extern struct vnodeops *nfs3_vnodeops;
extern const struct fs_operation_def nfs3_vnodeops_template[];
/*
* Some servers do not properly update the attributes of the
* directory when changes are made. To allow interoperability
* with these broken servers, the nfs_disable_rddir_cache
* parameter can be used to disable readdir response caching.
*/
extern int nfs_disable_rddir_cache;
/*
*/
extern void nfs4_clnt_init(void);
extern void nfs4_clnt_fini(void);
/*
* Does NFS4 server have a vnode delegated? TRUE if so, FALSE if not.
*/
/*
* VOP_GETATTR call. If a NFS4 delegation is present on the supplied vnode
* call back to the delegated client to get attributes for AT_MTIME and
* AT_SIZE. Invoke VOP_GETATTR to get all other attributes or all attributes
* if no delegation is present.
*/
extern void rfs4_hold_deleg_policy(void);
extern void rfs4_rele_deleg_policy(void);
struct exportinfo *);
/*
* Copy Reduction support.
* xuio_t wrapper with additional private data.
*/
typedef struct nfs_xuio {
} nfs_xuio_t;
extern void rfs_free_xuio(void *);
#endif /* _KERNEL */
#ifdef __cplusplus
}
#endif
#endif /* _NFS_NFS_H */