OpenSolaris_b135/uts/common/nfs/nfs4_clnt.h
/*
* 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 2010 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Portions of this source code were derived from Berkeley 4.3 BSD
* under license from the Regents of the University of California.
*/
#ifndef _NFS4_CLNT_H
#define _NFS4_CLNT_H
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/kstat.h>
#include <sys/time.h>
#include <sys/flock.h>
#include <vm/page.h>
#include <nfs/nfs4_kprot.h>
#include <nfs/nfs4.h>
#include <nfs/rnode.h>
#include <sys/avl.h>
#include <sys/list.h>
#include <rpc/auth.h>
#include <sys/door.h>
#include <sys/condvar_impl.h>
#ifdef __cplusplus
extern "C" {
#endif
#define NFS4_SIZE_OK(size) ((size) <= MAXOFFSET_T)
/* Four states of nfs4_server's lease_valid */
#define NFS4_LEASE_INVALID 0
#define NFS4_LEASE_VALID 1
#define NFS4_LEASE_UNINITIALIZED 2
#define NFS4_LEASE_NOT_STARTED 3
/* flag to tell the renew thread it should exit */
#define NFS4_THREAD_EXIT 1
/* Default number of seconds to wait on GRACE and DELAY errors */
#define NFS4ERR_DELAY_TIME 10
/* Number of hash buckets for open owners for each nfs4_server */
#define NFS4_NUM_OO_BUCKETS 53
/* Number of freed open owners (per mntinfo4_t) to keep around */
#define NFS4_NUM_FREED_OPEN_OWNERS 8
/* Number of seconds to wait before retrying a SETCLIENTID(_CONFIRM) op */
#define NFS4_RETRY_SCLID_DELAY 10
/* Number of times we should retry a SETCLIENTID(_CONFIRM) op */
#define NFS4_NUM_SCLID_RETRIES 3
/* Number of times we should retry on open after getting NFS4ERR_BAD_SEQID */
#define NFS4_NUM_RETRY_BAD_SEQID 3
/*
* Macro to wakeup sleeping async worker threads.
*/
#define NFS4_WAKE_ASYNC_WORKER(work_cv) { \
if (CV_HAS_WAITERS(&work_cv[NFS4_ASYNC_QUEUE])) \
cv_signal(&work_cv[NFS4_ASYNC_QUEUE]); \
else if (CV_HAS_WAITERS(&work_cv[NFS4_ASYNC_PGOPS_QUEUE])) \
cv_signal(&work_cv[NFS4_ASYNC_PGOPS_QUEUE]); \
}
#define NFS4_WAKEALL_ASYNC_WORKERS(work_cv) { \
cv_broadcast(&work_cv[NFS4_ASYNC_QUEUE]); \
cv_broadcast(&work_cv[NFS4_ASYNC_PGOPS_QUEUE]); \
}
/*
* Is the attribute cache valid? If client holds a delegation, then attrs
* are by definition valid. If not, then check to see if attrs have timed out.
*/
#define ATTRCACHE4_VALID(vp) (VTOR4(vp)->r_deleg_type != OPEN_DELEGATE_NONE || \
gethrtime() < VTOR4(vp)->r_time_attr_inval)
/*
* Flags to indicate whether to purge the DNLC for non-directory vnodes
* in a call to nfs_purge_caches.
*/
#define NFS4_NOPURGE_DNLC 0
#define NFS4_PURGE_DNLC 1
/*
* Is cache valid?
* Swap is always valid, if no attributes (attrtime == 0) or
* if mtime matches cached mtime it is valid
* NOTE: mtime is now a timestruc_t.
* Caller should be holding the rnode r_statelock mutex.
*/
#define CACHE4_VALID(rp, mtime, fsize) \
((RTOV4(rp)->v_flag & VISSWAP) == VISSWAP || \
(((mtime).tv_sec == (rp)->r_attr.va_mtime.tv_sec && \
(mtime).tv_nsec == (rp)->r_attr.va_mtime.tv_nsec) && \
((fsize) == (rp)->r_attr.va_size)))
/*
* Macro to detect forced unmount or a zone shutdown.
*/
#define FS_OR_ZONE_GONE4(vfsp) \
(((vfsp)->vfs_flag & VFS_UNMOUNTED) || \
zone_status_get(curproc->p_zone) >= ZONE_IS_SHUTTING_DOWN)
/*
* Macro to help determine whether a request failed because the underlying
* filesystem has been forcibly unmounted or because of zone shutdown.
*/
#define NFS4_FRC_UNMT_ERR(err, vfsp) \
((err) == EIO && FS_OR_ZONE_GONE4((vfsp)))
/*
* Due to the way the address space callbacks are used to execute a delmap,
* we must keep track of how many times the same thread has called
* VOP_DELMAP()->nfs4_delmap(). This is done by having a list of
* nfs4_delmapcall_t's associated with each rnode4_t. This list is protected
* by the rnode4_t's r_statelock. The individual elements do not need to be
* protected as they will only ever be created, modified and destroyed by
* one thread (the call_id).
* See nfs4_delmap() for further explanation.
*/
typedef struct nfs4_delmapcall {
kthread_t *call_id;
int error; /* error from delmap */
list_node_t call_node;
} nfs4_delmapcall_t;
/*
* delmap address space callback args
*/
typedef struct nfs4_delmap_args {
vnode_t *vp;
offset_t off;
caddr_t addr;
size_t len;
uint_t prot;
uint_t maxprot;
uint_t flags;
cred_t *cr;
nfs4_delmapcall_t *caller; /* to retrieve errors from the cb */
} nfs4_delmap_args_t;
/*
* client side statistics
*/
/*
* Per-zone counters
*/
struct clstat4 {
kstat_named_t calls; /* client requests */
kstat_named_t badcalls; /* rpc failures */
kstat_named_t referrals; /* referrals */
kstat_named_t referlinks; /* referrals as symlinks */
kstat_named_t clgets; /* client handle gets */
kstat_named_t cltoomany; /* client handle cache misses */
#ifdef DEBUG
kstat_named_t clalloc; /* number of client handles */
kstat_named_t noresponse; /* server not responding cnt */
kstat_named_t failover; /* server failover count */
kstat_named_t remap; /* server remap count */
#endif
};
#ifdef DEBUG
/*
* The following are statistics that describe the behavior of the system as a
* whole and don't correspond to any particular zone.
*/
struct clstat4_debug {
kstat_named_t nrnode; /* number of allocated rnodes */
kstat_named_t access; /* size of access cache */
kstat_named_t dirent; /* size of readdir cache */
kstat_named_t dirents; /* size of readdir buf cache */
kstat_named_t reclaim; /* number of reclaims */
kstat_named_t clreclaim; /* number of cl reclaims */
kstat_named_t f_reclaim; /* number of free reclaims */
kstat_named_t a_reclaim; /* number of active reclaims */
kstat_named_t r_reclaim; /* number of rnode reclaims */
kstat_named_t rpath; /* bytes used to store rpaths */
};
extern struct clstat4_debug clstat4_debug;
#endif
/*
* The NFS specific async_reqs structure. iotype4 is grouped to support two
* types of async thread pools, please read comments section of mntinfo4_t
* definition for more information. Care should be taken while adding new
* members to this group.
*/
enum iotype4 {
NFS4_PUTAPAGE,
NFS4_PAGEIO,
NFS4_COMMIT,
NFS4_READ_AHEAD,
NFS4_READDIR,
NFS4_INACTIVE,
NFS4_ASYNC_TYPES
};
#define NFS4_ASYNC_PGOPS_TYPES (NFS4_COMMIT + 1)
/*
* NFS async requests queue type.
*/
enum ioqtype4 {
NFS4_ASYNC_QUEUE,
NFS4_ASYNC_PGOPS_QUEUE,
NFS4_MAX_ASYNC_QUEUES
};
/*
* Number of NFS async threads operating exclusively on page op requests.
*/
#define NUM_ASYNC_PGOPS_THREADS 0x2
struct nfs4_async_read_req {
void (*readahead)(); /* pointer to readahead function */
u_offset_t blkoff; /* offset in file */
struct seg *seg; /* segment to do i/o to */
caddr_t addr; /* address to do i/o to */
};
struct nfs4_pageio_req {
int (*pageio)(); /* pointer to pageio function */
page_t *pp; /* page list */
u_offset_t io_off; /* offset in file */
uint_t io_len; /* size of request */
int flags;
};
struct nfs4_readdir_req {
int (*readdir)(); /* pointer to readdir function */
struct rddir4_cache *rdc; /* pointer to cache entry to fill */
};
struct nfs4_commit_req {
void (*commit)(); /* pointer to commit function */
page_t *plist; /* page list */
offset4 offset; /* starting offset */
count4 count; /* size of range to be commited */
};
struct nfs4_async_reqs {
struct nfs4_async_reqs *a_next; /* pointer to next arg struct */
#ifdef DEBUG
kthread_t *a_queuer; /* thread id of queueing thread */
#endif
struct vnode *a_vp; /* vnode pointer */
struct cred *a_cred; /* cred pointer */
enum iotype4 a_io; /* i/o type */
union {
struct nfs4_async_read_req a_read_args;
struct nfs4_pageio_req a_pageio_args;
struct nfs4_readdir_req a_readdir_args;
struct nfs4_commit_req a_commit_args;
} a_args;
};
#define a_nfs4_readahead a_args.a_read_args.readahead
#define a_nfs4_blkoff a_args.a_read_args.blkoff
#define a_nfs4_seg a_args.a_read_args.seg
#define a_nfs4_addr a_args.a_read_args.addr
#define a_nfs4_putapage a_args.a_pageio_args.pageio
#define a_nfs4_pageio a_args.a_pageio_args.pageio
#define a_nfs4_pp a_args.a_pageio_args.pp
#define a_nfs4_off a_args.a_pageio_args.io_off
#define a_nfs4_len a_args.a_pageio_args.io_len
#define a_nfs4_flags a_args.a_pageio_args.flags
#define a_nfs4_readdir a_args.a_readdir_args.readdir
#define a_nfs4_rdc a_args.a_readdir_args.rdc
#define a_nfs4_commit a_args.a_commit_args.commit
#define a_nfs4_plist a_args.a_commit_args.plist
#define a_nfs4_offset a_args.a_commit_args.offset
#define a_nfs4_count a_args.a_commit_args.count
/*
* Security information
*/
typedef struct sv_secinfo {
uint_t count; /* how many sdata there are */
uint_t index; /* which sdata[index] */
struct sec_data *sdata;
} sv_secinfo_t;
/*
* Hash bucket for the mi's open owner list (mi_oo_list).
*/
typedef struct nfs4_oo_hash_bucket {
list_t b_oo_hash_list;
kmutex_t b_lock;
} nfs4_oo_hash_bucket_t;
/*
* Global array of ctags.
*/
extern ctag_t nfs4_ctags[];
typedef enum nfs4_tag_type {
TAG_NONE,
TAG_ACCESS,
TAG_CLOSE,
TAG_CLOSE_LOST,
TAG_CLOSE_UNDO,
TAG_COMMIT,
TAG_DELEGRETURN,
TAG_FSINFO,
TAG_GET_SYMLINK,
TAG_GETATTR,
TAG_GETATTR_FSLOCATION,
TAG_INACTIVE,
TAG_LINK,
TAG_LOCK,
TAG_LOCK_RECLAIM,
TAG_LOCK_RESEND,
TAG_LOCK_REINSTATE,
TAG_LOCK_UNKNOWN,
TAG_LOCKT,
TAG_LOCKU,
TAG_LOCKU_RESEND,
TAG_LOCKU_REINSTATE,
TAG_LOOKUP,
TAG_LOOKUP_PARENT,
TAG_LOOKUP_VALID,
TAG_LOOKUP_VPARENT,
TAG_MKDIR,
TAG_MKNOD,
TAG_MOUNT,
TAG_OPEN,
TAG_OPEN_CONFIRM,
TAG_OPEN_CONFIRM_LOST,
TAG_OPEN_DG,
TAG_OPEN_DG_LOST,
TAG_OPEN_LOST,
TAG_OPENATTR,
TAG_PATHCONF,
TAG_PUTROOTFH,
TAG_READ,
TAG_READAHEAD,
TAG_READDIR,
TAG_READLINK,
TAG_RELOCK,
TAG_REMAP_LOOKUP,
TAG_REMAP_LOOKUP_AD,
TAG_REMAP_LOOKUP_NA,
TAG_REMAP_MOUNT,
TAG_RMDIR,
TAG_REMOVE,
TAG_RENAME,
TAG_RENAME_VFH,
TAG_RENEW,
TAG_REOPEN,
TAG_REOPEN_LOST,
TAG_SECINFO,
TAG_SETATTR,
TAG_SETCLIENTID,
TAG_SETCLIENTID_CF,
TAG_SYMLINK,
TAG_WRITE
} nfs4_tag_type_t;
#define NFS4_TAG_INITIALIZER { \
{TAG_NONE, "", \
{0x20202020, 0x20202020, 0x20202020}}, \
{TAG_ACCESS, "access", \
{0x61636365, 0x73732020, 0x20202020}}, \
{TAG_CLOSE, "close", \
{0x636c6f73, 0x65202020, 0x20202020}}, \
{TAG_CLOSE_LOST, "lost close", \
{0x6c6f7374, 0x20636c6f, 0x73652020}}, \
{TAG_CLOSE_UNDO, "undo close", \
{0x756e646f, 0x20636c6f, 0x73652020}}, \
{TAG_COMMIT, "commit", \
{0x636f6d6d, 0x69742020, 0x20202020}}, \
{TAG_DELEGRETURN, "delegreturn", \
{0x64656c65, 0x67726574, 0x75726e20}}, \
{TAG_FSINFO, "fsinfo", \
{0x6673696e, 0x666f2020, 0x20202020}}, \
{TAG_GET_SYMLINK, "get symlink text", \
{0x67657420, 0x736c6e6b, 0x20747874}}, \
{TAG_GETATTR, "getattr", \
{0x67657461, 0x74747220, 0x20202020}}, \
{TAG_GETATTR_FSLOCATION, "getattr fslocation", \
{0x67657461, 0x74747220, 0x66736c6f}}, \
{TAG_INACTIVE, "inactive", \
{0x696e6163, 0x74697665, 0x20202020}}, \
{TAG_LINK, "link", \
{0x6c696e6b, 0x20202020, 0x20202020}}, \
{TAG_LOCK, "lock", \
{0x6c6f636b, 0x20202020, 0x20202020}}, \
{TAG_LOCK_RECLAIM, "reclaim lock", \
{0x7265636c, 0x61696d20, 0x6c6f636b}}, \
{TAG_LOCK_RESEND, "resend lock", \
{0x72657365, 0x6e64206c, 0x6f636b20}}, \
{TAG_LOCK_REINSTATE, "reinstate lock", \
{0x7265696e, 0x7374206c, 0x6f636b20}}, \
{TAG_LOCK_UNKNOWN, "unknown lock", \
{0x756e6b6e, 0x6f776e20, 0x6c6f636b}}, \
{TAG_LOCKT, "lock test", \
{0x6c6f636b, 0x5f746573, 0x74202020}}, \
{TAG_LOCKU, "unlock", \
{0x756e6c6f, 0x636b2020, 0x20202020}}, \
{TAG_LOCKU_RESEND, "resend locku", \
{0x72657365, 0x6e64206c, 0x6f636b75}}, \
{TAG_LOCKU_REINSTATE, "reinstate unlock", \
{0x7265696e, 0x73742075, 0x6e6c636b}}, \
{TAG_LOOKUP, "lookup", \
{0x6c6f6f6b, 0x75702020, 0x20202020}}, \
{TAG_LOOKUP_PARENT, "lookup parent", \
{0x6c6f6f6b, 0x75702070, 0x6172656e}}, \
{TAG_LOOKUP_VALID, "lookup valid", \
{0x6c6f6f6b, 0x75702076, 0x616c6964}}, \
{TAG_LOOKUP_VPARENT, "lookup valid parent", \
{0x6c6f6f6b, 0x766c6420, 0x7061726e}}, \
{TAG_MKDIR, "mkdir", \
{0x6d6b6469, 0x72202020, 0x20202020}}, \
{TAG_MKNOD, "mknod", \
{0x6d6b6e6f, 0x64202020, 0x20202020}}, \
{TAG_MOUNT, "mount", \
{0x6d6f756e, 0x74202020, 0x20202020}}, \
{TAG_OPEN, "open", \
{0x6f70656e, 0x20202020, 0x20202020}}, \
{TAG_OPEN_CONFIRM, "open confirm", \
{0x6f70656e, 0x5f636f6e, 0x6669726d}}, \
{TAG_OPEN_CONFIRM_LOST, "lost open confirm", \
{0x6c6f7374, 0x206f7065, 0x6e5f636f}}, \
{TAG_OPEN_DG, "open downgrade", \
{0x6f70656e, 0x20646772, 0x61646520}}, \
{TAG_OPEN_DG_LOST, "lost open downgrade", \
{0x6c737420, 0x6f70656e, 0x20646772}}, \
{TAG_OPEN_LOST, "lost open", \
{0x6c6f7374, 0x206f7065, 0x6e202020}}, \
{TAG_OPENATTR, "openattr", \
{0x6f70656e, 0x61747472, 0x20202020}}, \
{TAG_PATHCONF, "pathhconf", \
{0x70617468, 0x636f6e66, 0x20202020}}, \
{TAG_PUTROOTFH, "putrootfh", \
{0x70757472, 0x6f6f7466, 0x68202020}}, \
{TAG_READ, "read", \
{0x72656164, 0x20202020, 0x20202020}}, \
{TAG_READAHEAD, "readahead", \
{0x72656164, 0x61686561, 0x64202020}}, \
{TAG_READDIR, "readdir", \
{0x72656164, 0x64697220, 0x20202020}}, \
{TAG_READLINK, "readlink", \
{0x72656164, 0x6c696e6b, 0x20202020}}, \
{TAG_RELOCK, "relock", \
{0x72656c6f, 0x636b2020, 0x20202020}}, \
{TAG_REMAP_LOOKUP, "remap lookup", \
{0x72656d61, 0x70206c6f, 0x6f6b7570}}, \
{TAG_REMAP_LOOKUP_AD, "remap lookup attr dir", \
{0x72656d70, 0x206c6b75, 0x70206164}}, \
{TAG_REMAP_LOOKUP_NA, "remap lookup named attrs", \
{0x72656d70, 0x206c6b75, 0x70206e61}}, \
{TAG_REMAP_MOUNT, "remap mount", \
{0x72656d61, 0x70206d6f, 0x756e7420}}, \
{TAG_RMDIR, "rmdir", \
{0x726d6469, 0x72202020, 0x20202020}}, \
{TAG_REMOVE, "remove", \
{0x72656d6f, 0x76652020, 0x20202020}}, \
{TAG_RENAME, "rename", \
{0x72656e61, 0x6d652020, 0x20202020}}, \
{TAG_RENAME_VFH, "rename volatile fh", \
{0x72656e61, 0x6d652028, 0x76666829}}, \
{TAG_RENEW, "renew", \
{0x72656e65, 0x77202020, 0x20202020}}, \
{TAG_REOPEN, "reopen", \
{0x72656f70, 0x656e2020, 0x20202020}}, \
{TAG_REOPEN_LOST, "lost reopen", \
{0x6c6f7374, 0x2072656f, 0x70656e20}}, \
{TAG_SECINFO, "secinfo", \
{0x73656369, 0x6e666f20, 0x20202020}}, \
{TAG_SETATTR, "setattr", \
{0x73657461, 0x74747220, 0x20202020}}, \
{TAG_SETCLIENTID, "setclientid", \
{0x73657463, 0x6c69656e, 0x74696420}}, \
{TAG_SETCLIENTID_CF, "setclientid_confirm", \
{0x73636c6e, 0x7469645f, 0x636f6e66}}, \
{TAG_SYMLINK, "symlink", \
{0x73796d6c, 0x696e6b20, 0x20202020}}, \
{TAG_WRITE, "write", \
{0x77726974, 0x65202020, 0x20202020}} \
}
/*
* These flags are for differentiating the search criterian for
* find_open_owner(). The comparison is done with the open_owners's
* 'oo_just_created' flag.
*/
#define NFS4_PERM_CREATED 0x0
#define NFS4_JUST_CREATED 0x1
/*
* Hashed by the cr_uid and cr_ruid of credential 'oo_cred'. 'oo_cred_otw'
* is stored upon a successful OPEN. This is needed when the user's effective
* and real uid's don't match. The 'oo_cred_otw' overrides the credential
* passed down by VFS for async read/write, commit, lock, and close operations.
*
* The oo_ref_count keeps track the number of active references on this
* data structure + number of nfs4_open_streams point to this structure.
*
* 'oo_valid' tells whether this stuct is about to be freed or not.
*
* 'oo_just_created' tells us whether this struct has just been created but
* not been fully finalized (that is created upon an OPEN request and
* finalized upon the OPEN success).
*
* The 'oo_seqid_inuse' is for the open seqid synchronization. If a thread
* is currently using the open owner and it's open_seqid, then it sets the
* oo_seqid_inuse to true if it currently is not set. If it is set then it
* does a cv_wait on the oo_cv_seqid_sync condition variable. When the thread
* is done it unsets the oo_seqid_inuse and does a cv_signal to wake a process
* waiting on the condition variable.
*
* 'oo_last_good_seqid' is the last valid seqid this open owner sent OTW,
* and 'oo_last_good_op' is the operation that issued the last valid seqid.
*
* Lock ordering:
* mntinfo4_t::mi_lock > oo_lock (for searching mi_oo_list)
*
* oo_seqid_inuse > mntinfo4_t::mi_lock
* oo_seqid_inuse > rnode4_t::r_statelock
* oo_seqid_inuse > rnode4_t::r_statev4_lock
* oo_seqid_inuse > nfs4_open_stream_t::os_sync_lock
*
* The 'oo_seqid_inuse'/'oo_cv_seqid_sync' protects:
* oo_last_good_op
* oo_last_good_seqid
* oo_name
* oo_seqid
*
* The 'oo_lock' protects:
* oo_cred
* oo_cred_otw
* oo_foo_node
* oo_hash_node
* oo_just_created
* oo_ref_count
* oo_valid
*/
typedef struct nfs4_open_owner {
cred_t *oo_cred;
int oo_ref_count;
int oo_valid;
int oo_just_created;
seqid4 oo_seqid;
seqid4 oo_last_good_seqid;
nfs4_tag_type_t oo_last_good_op;
unsigned oo_seqid_inuse:1;
cred_t *oo_cred_otw;
kcondvar_t oo_cv_seqid_sync;
/*
* Fix this to always be 8 bytes
*/
uint64_t oo_name;
list_node_t oo_hash_node;
list_node_t oo_foo_node;
kmutex_t oo_lock;
} nfs4_open_owner_t;
/*
* Static server information.
* These fields are read-only once they are initialized; sv_lock
* should be held as writer if they are changed during mount:
* sv_addr
* sv_dhsec
* sv_hostname
* sv_hostnamelen
* sv_knconf
* sv_next
* sv_origknconf
*
* These fields are protected by sv_lock:
* sv_currsec
* sv_fhandle
* sv_flags
* sv_fsid
* sv_path
* sv_pathlen
* sv_pfhandle
* sv_save_secinfo
* sv_savesec
* sv_secdata
* sv_secinfo
* sv_supp_attrs
*
* Lock ordering:
* nfs_rtable4_lock > sv_lock
* rnode4_t::r_statelock > sv_lock
*/
typedef struct servinfo4 {
struct knetconfig *sv_knconf; /* bound TLI fd */
struct knetconfig *sv_origknconf; /* For RDMA save orig knconf */
struct netbuf sv_addr; /* server's address */
nfs4_fhandle_t sv_fhandle; /* this server's filehandle */
nfs4_fhandle_t sv_pfhandle; /* parent dir filehandle */
int sv_pathlen; /* Length of server path */
char *sv_path; /* Path name on server */
uint32_t sv_flags; /* flags for this server */
sec_data_t *sv_secdata; /* client initiated security data */
sv_secinfo_t *sv_secinfo; /* server security information */
sec_data_t *sv_currsec; /* security data currently used; */
/* points to one of the sec_data */
/* entries in sv_secinfo */
sv_secinfo_t *sv_save_secinfo; /* saved secinfo */
sec_data_t *sv_savesec; /* saved security data */
sec_data_t *sv_dhsec; /* AUTH_DH data from the user land */
char *sv_hostname; /* server's hostname */
int sv_hostnamelen; /* server's hostname length */
fattr4_fsid sv_fsid; /* fsid of shared obj */
fattr4_supported_attrs sv_supp_attrs;
struct servinfo4 *sv_next; /* next in list */
nfs_rwlock_t sv_lock;
} servinfo4_t;
/* sv_flags fields */
#define SV4_TRYSECINFO 0x001 /* try secinfo data from the server */
#define SV4_TRYSECDEFAULT 0x002 /* try a default flavor */
#define SV4_NOTINUSE 0x004 /* servinfo4_t had fatal errors */
#define SV4_ROOT_STALE 0x008 /* root vnode got ESTALE */
/*
* Lock call types. See nfs4frlock().
*/
typedef enum nfs4_lock_call_type {
NFS4_LCK_CTYPE_NORM,
NFS4_LCK_CTYPE_RECLAIM,
NFS4_LCK_CTYPE_RESEND,
NFS4_LCK_CTYPE_REINSTATE
} nfs4_lock_call_type_t;
/*
* This structure holds the information for a lost open/close/open downgrade/
* lock/locku request. It is also used for requests that are queued up so
* that the recovery thread can release server state after a forced
* unmount.
* "lr_op" is 0 if the struct is uninitialized. Otherwise, it is set to
* the proper OP_* nfs_opnum4 number. The other fields contain information
* to reconstruct the call.
*
* lr_dvp is used for OPENs with CREATE, so that we can do a PUTFH of the
* parent directroy without relying on vtodv (since we may not have a vp
* for the file we wish to create).
*
* lr_putfirst means that the request should go to the front of the resend
* queue, rather than the end.
*/
typedef struct nfs4_lost_rqst {
list_node_t lr_node;
nfs_opnum4 lr_op;
vnode_t *lr_vp;
vnode_t *lr_dvp;
nfs4_open_owner_t *lr_oop;
struct nfs4_open_stream *lr_osp;
struct nfs4_lock_owner *lr_lop;
cred_t *lr_cr;
flock64_t *lr_flk;
bool_t lr_putfirst;
union {
struct {
nfs4_lock_call_type_t lru_ctype;
nfs_lock_type4 lru_locktype;
} lru_lockargs; /* LOCK, LOCKU */
struct {
uint32_t lru_oaccess;
uint32_t lru_odeny;
enum open_claim_type4 lru_oclaim;
stateid4 lru_ostateid; /* reopen only */
component4 lru_ofile;
} lru_open_args;
struct {
uint32_t lru_dg_access;
uint32_t lru_dg_deny;
} lru_open_dg_args;
} nfs4_lr_u;
} nfs4_lost_rqst_t;
#define lr_oacc nfs4_lr_u.lru_open_args.lru_oaccess
#define lr_odeny nfs4_lr_u.lru_open_args.lru_odeny
#define lr_oclaim nfs4_lr_u.lru_open_args.lru_oclaim
#define lr_ostateid nfs4_lr_u.lru_open_args.lru_ostateid
#define lr_ofile nfs4_lr_u.lru_open_args.lru_ofile
#define lr_dg_acc nfs4_lr_u.lru_open_dg_args.lru_dg_access
#define lr_dg_deny nfs4_lr_u.lru_open_dg_args.lru_dg_deny
#define lr_ctype nfs4_lr_u.lru_lockargs.lru_ctype
#define lr_locktype nfs4_lr_u.lru_lockargs.lru_locktype
/*
* Recovery actions. Some actions can imply further recovery using a
* different recovery action (e.g., recovering the clientid leads to
* recovering open files and locks).
*/
typedef enum {
NR_UNUSED,
NR_CLIENTID,
NR_OPENFILES,
NR_FHEXPIRED,
NR_FAILOVER,
NR_WRONGSEC,
NR_EXPIRED,
NR_BAD_STATEID,
NR_BADHANDLE,
NR_BAD_SEQID,
NR_OLDSTATEID,
NR_GRACE,
NR_DELAY,
NR_LOST_LOCK,
NR_LOST_STATE_RQST,
NR_STALE,
NR_MOVED
} nfs4_recov_t;
/*
* Administrative and debug message framework.
*/
#define NFS4_MSG_MAX 100
extern int nfs4_msg_max;
#define NFS4_REFERRAL_LOOP_MAX 20
typedef enum {
RE_BAD_SEQID,
RE_BADHANDLE,
RE_CLIENTID,
RE_DEAD_FILE,
RE_END,
RE_FAIL_RELOCK,
RE_FAIL_REMAP_LEN,
RE_FAIL_REMAP_OP,
RE_FAILOVER,
RE_FILE_DIFF,
RE_LOST_STATE,
RE_OPENS_CHANGED,
RE_SIGLOST,
RE_SIGLOST_NO_DUMP,
RE_START,
RE_UNEXPECTED_ACTION,
RE_UNEXPECTED_ERRNO,
RE_UNEXPECTED_STATUS,
RE_WRONGSEC,
RE_LOST_STATE_BAD_OP,
RE_REFERRAL
} nfs4_event_type_t;
typedef enum {
RFS_NO_INSPECT,
RFS_INSPECT
} nfs4_fact_status_t;
typedef enum {
RF_BADOWNER,
RF_ERR,
RF_RENEW_EXPIRED,
RF_SRV_NOT_RESPOND,
RF_SRV_OK,
RF_SRVS_NOT_RESPOND,
RF_SRVS_OK,
RF_DELMAP_CB_ERR,
RF_SENDQ_FULL
} nfs4_fact_type_t;
typedef enum {
NFS4_MS_DUMP,
NFS4_MS_NO_DUMP
} nfs4_msg_status_t;
typedef struct nfs4_rfact {
nfs4_fact_type_t rf_type;
nfs4_fact_status_t rf_status;
bool_t rf_reboot;
nfs4_recov_t rf_action;
nfs_opnum4 rf_op;
nfsstat4 rf_stat4;
timespec_t rf_time;
int rf_error;
struct rnode4 *rf_rp1;
char *rf_char1;
} nfs4_rfact_t;
typedef struct nfs4_revent {
nfs4_event_type_t re_type;
nfsstat4 re_stat4;
uint_t re_uint;
pid_t re_pid;
struct mntinfo4 *re_mi;
struct rnode4 *re_rp1;
struct rnode4 *re_rp2;
char *re_char1;
char *re_char2;
nfs4_tag_type_t re_tag1;
nfs4_tag_type_t re_tag2;
seqid4 re_seqid1;
seqid4 re_seqid2;
} nfs4_revent_t;
typedef enum {
RM_EVENT,
RM_FACT
} nfs4_msg_type_t;
typedef struct nfs4_debug_msg {
timespec_t msg_time;
nfs4_msg_type_t msg_type;
char *msg_srv;
char *msg_mntpt;
union {
nfs4_rfact_t msg_fact;
nfs4_revent_t msg_event;
} rmsg_u;
nfs4_msg_status_t msg_status;
list_node_t msg_node;
} nfs4_debug_msg_t;
/*
* NFS private data per mounted file system
* The mi_lock mutex protects the following fields:
* mi_flags
* mi_in_recovery
* mi_recovflags
* mi_recovthread
* mi_error
* mi_printed
* mi_down
* mi_stsize
* mi_curread
* mi_curwrite
* mi_timers
* mi_curr_serv
* mi_klmconfig
* mi_oo_list
* mi_foo_list
* mi_foo_num
* mi_foo_max
* mi_lost_state
* mi_bseqid_list
* mi_ephemeral
* mi_ephemeral_tree
*
* Normally the netconfig information for the mount comes from
* mi_curr_serv and mi_klmconfig is NULL. If NLM calls need to use a
* different transport, mi_klmconfig contains the necessary netconfig
* information.
*
* The mi_async_lock mutex protects the following fields:
* mi_async_reqs
* mi_async_req_count
* mi_async_tail
* mi_async_curr[NFS4_MAX_ASYNC_QUEUES]
* mi_async_clusters
* mi_async_init_clusters
* mi_threads[NFS4_MAX_ASYNC_QUEUES]
* mi_inactive_thread
* mi_manager_thread
*
* The nfs4_server_t::s_lock protects the following fields:
* mi_clientid
* mi_clientid_next
* mi_clientid_prev
* mi_open_files
*
* The mntinfo4_t::mi_recovlock protects the following fields:
* mi_srvsettime
* mi_srvset_cnt
* mi_srv
*
* Changing mi_srv from one nfs4_server_t to a different one requires
* holding the mi_recovlock as RW_WRITER.
* Exception: setting mi_srv the first time in mount/mountroot is done
* holding the mi_recovlock as RW_READER.
*
* Locking order:
* mi4_globals::mig_lock > mi_async_lock
* mi_async_lock > nfs4_server_t::s_lock > mi_lock
* mi_recovlock > mi_rename_lock > nfs_rtable4_lock
* nfs4_server_t::s_recovlock > mi_recovlock
* rnode4_t::r_rwlock > mi_rename_lock
* nfs_rtable4_lock > mi_lock
* nfs4_server_t::s_lock > mi_msg_list_lock
* mi_recovlock > nfs4_server_t::s_lock
* mi_recovlock > nfs4_server_lst_lock
*
* The 'mi_oo_list' represents the hash buckets that contain the
* nfs4_open_owenrs for this particular mntinfo4.
*
* The 'mi_foo_list' represents the freed nfs4_open_owners for this mntinfo4.
* 'mi_foo_num' is the current number of freed open owners on the list,
* 'mi_foo_max' is the maximum number of freed open owners that are allowable
* on the list.
*
* mi_rootfh and mi_srvparentfh are read-only once created, but that just
* refers to the pointer. The contents must be updated to keep in sync
* with mi_curr_serv.
*
* The mi_msg_list_lock protects against adding/deleting entries to the
* mi_msg_list, and also the updating/retrieving of mi_lease_period;
*
* 'mi_zone' is initialized at structure creation time, and never
* changes; it may be read without a lock.
*
* mi_zone_node is linkage into the mi4_globals.mig_list, and is
* protected by mi4_globals.mig_list_lock.
*
* If MI4_EPHEMERAL is set in mi_flags, then mi_ephemeral points to an
* ephemeral structure for this ephemeral mount point. It can not be
* NULL. Also, mi_ephemeral_tree points to the root of the ephemeral
* tree.
*
* If MI4_EPHEMERAL is not set in mi_flags, then mi_ephemeral has
* to be NULL. If mi_ephemeral_tree is non-NULL, then this node
* is the enclosing mntinfo4 for the ephemeral tree.
*/
struct zone;
struct nfs4_ephemeral;
struct nfs4_ephemeral_tree;
struct nfs4_server;
typedef struct mntinfo4 {
kmutex_t mi_lock; /* protects mntinfo4 fields */
struct servinfo4 *mi_servers; /* server list */
struct servinfo4 *mi_curr_serv; /* current server */
struct nfs4_sharedfh *mi_rootfh; /* root filehandle */
struct nfs4_sharedfh *mi_srvparentfh; /* root's parent on server */
kcondvar_t mi_failover_cv; /* failover synchronization */
struct vfs *mi_vfsp; /* back pointer to vfs */
enum vtype mi_type; /* file type of the root vnode */
uint_t mi_flags; /* see below */
uint_t mi_recovflags; /* if recovery active; see below */
kthread_t *mi_recovthread; /* active recov thread or NULL */
uint_t mi_error; /* only set/valid when MI4_RECOV_FAIL */
/* is set in mi_flags */
int mi_tsize; /* transfer size (bytes) */
/* really read size */
int mi_stsize; /* server's max transfer size (bytes) */
/* really write size */
int mi_timeo; /* inital timeout in 10th sec */
int mi_retrans; /* times to retry request */
hrtime_t mi_acregmin; /* min time to hold cached file attr */
hrtime_t mi_acregmax; /* max time to hold cached file attr */
hrtime_t mi_acdirmin; /* min time to hold cached dir attr */
hrtime_t mi_acdirmax; /* max time to hold cached dir attr */
len_t mi_maxfilesize; /* for pathconf _PC_FILESIZEBITS */
int mi_curread; /* current read size */
int mi_curwrite; /* current write size */
uint_t mi_count; /* ref count */
/*
* Async I/O management
* We have 2 pools of threads working on async I/O:
* (1) Threads which work on all async queues. Default number of
* threads in this queue is 8. Threads in this pool work on async
* queue pointed by mi_async_curr[NFS4_ASYNC_QUEUE]. Number of
* active threads in this pool is tracked by
* mi_threads[NFS4_ASYNC_QUEUE].
* (ii)Threads which work only on page op async queues.
* Page ops queue comprises of NFS4_PUTAPAGE, NFS4_PAGEIO &
* NFS4_COMMIT. Default number of threads in this queue is 2
* (NUM_ASYNC_PGOPS_THREADS). Threads in this pool work on async
* queue pointed by mi_async_curr[NFS4_ASYNC_PGOPS_QUEUE]. Number
* of active threads in this pool is tracked by
* mi_threads[NFS4_ASYNC_PGOPS_QUEUE].
*
* In addition to above two pools, there is always one thread that
* handles over-the-wire requests for VOP_INACTIVE.
*/
struct nfs4_async_reqs *mi_async_reqs[NFS4_ASYNC_TYPES];
struct nfs4_async_reqs *mi_async_tail[NFS4_ASYNC_TYPES];
struct nfs4_async_reqs **mi_async_curr[NFS4_MAX_ASYNC_QUEUES];
/* current async queue */
uint_t mi_async_clusters[NFS4_ASYNC_TYPES];
uint_t mi_async_init_clusters;
uint_t mi_async_req_count; /* # outstanding work requests */
kcondvar_t mi_async_reqs_cv; /* signaled when there's work */
ushort_t mi_threads[NFS4_MAX_ASYNC_QUEUES];
/* number of active async threads */
ushort_t mi_max_threads; /* max number of async threads */
kthread_t *mi_manager_thread; /* async manager thread id */
kthread_t *mi_inactive_thread; /* inactive thread id */
kcondvar_t mi_inact_req_cv; /* notify VOP_INACTIVE thread */
kcondvar_t mi_async_work_cv[NFS4_MAX_ASYNC_QUEUES];
/* tell workers to work */
kcondvar_t mi_async_cv; /* all pool threads exited */
kmutex_t mi_async_lock;
/*
* Other stuff
*/
struct pathcnf *mi_pathconf; /* static pathconf kludge */
rpcprog_t mi_prog; /* RPC program number */
rpcvers_t mi_vers; /* RPC program version number */
char **mi_rfsnames; /* mapping to proc names */
kstat_named_t *mi_reqs; /* count of requests */
clock_t mi_printftime; /* last error printf time */
nfs_rwlock_t mi_recovlock; /* separate ops from recovery (v4) */
time_t mi_grace_wait; /* non-zero represents time to wait */
/* when we switched nfs4_server_t - only for observability purposes */
time_t mi_srvsettime;
nfs_rwlock_t mi_rename_lock; /* atomic volfh rename */
struct nfs4_fname *mi_fname; /* root fname */
list_t mi_lost_state; /* resend list */
list_t mi_bseqid_list; /* bad seqid list */
/*
* Client Side Failover stats
*/
uint_t mi_noresponse; /* server not responding count */
uint_t mi_failover; /* failover to new server count */
uint_t mi_remap; /* remap to new server count */
/*
* Kstat statistics
*/
struct kstat *mi_io_kstats;
struct kstat *mi_ro_kstats;
kstat_t *mi_recov_ksp; /* ptr to the recovery kstat */
/*
* Volatile fh flags (nfsv4)
*/
uint32_t mi_fh_expire_type;
/*
* Lease Management
*/
struct mntinfo4 *mi_clientid_next;
struct mntinfo4 *mi_clientid_prev;
clientid4 mi_clientid; /* redundant info found in nfs4_server */
int mi_open_files; /* count of open files */
int mi_in_recovery; /* count of recovery instances */
kcondvar_t mi_cv_in_recov; /* cv for recovery threads */
/*
* Open owner stuff.
*/
struct nfs4_oo_hash_bucket mi_oo_list[NFS4_NUM_OO_BUCKETS];
list_t mi_foo_list;
int mi_foo_num;
int mi_foo_max;
/*
* Shared filehandle pool.
*/
nfs_rwlock_t mi_fh_lock;
avl_tree_t mi_filehandles;
/*
* Debug message queue.
*/
list_t mi_msg_list;
int mi_msg_count;
time_t mi_lease_period;
/*
* not guaranteed to be accurate.
* only should be used by debug queue.
*/
kmutex_t mi_msg_list_lock;
/*
* Zones support.
*/
struct zone *mi_zone; /* Zone mounted in */
list_node_t mi_zone_node; /* linkage into per-zone mi list */
/*
* Links for unmounting ephemeral mounts.
*/
struct nfs4_ephemeral *mi_ephemeral;
struct nfs4_ephemeral_tree *mi_ephemeral_tree;
uint_t mi_srvset_cnt; /* increment when changing the nfs4_server_t */
struct nfs4_server *mi_srv; /* backpointer to nfs4_server_t */
/*
* Referral related info.
*/
int mi_vfs_referral_loop_cnt;
} mntinfo4_t;
/*
* The values for mi_flags.
*
* MI4_HARD hard or soft mount
* MI4_PRINTED responding message printed
* MI4_INT allow INTR on hard mount
* MI4_DOWN server is down
* MI4_NOAC don't cache attributes
* MI4_NOCTO no close-to-open consistency
* MI4_LLOCK local locking only (no lockmgr)
* MI4_GRPID System V group id inheritance
* MI4_SHUTDOWN System is rebooting or shutting down
* MI4_LINK server supports link
* MI4_SYMLINK server supports symlink
* MI4_EPHEMERAL_RECURSED an ephemeral mount being unmounted
* due to a recursive call - no need
* for additional recursion
* MI4_ACL server supports NFSv4 ACLs
* MI4_MIRRORMOUNT is a mirrormount
* MI4_NOPRINT don't print messages
* MI4_DIRECTIO do direct I/O
* MI4_RECOV_ACTIV filesystem has recovery a thread
* MI4_REMOVE_ON_LAST_CLOSE remove from server's list
* MI4_RECOV_FAIL client recovery failed
* MI4_PUBLIC public/url option used
* MI4_MOUNTING mount in progress, don't failover
* MI4_POSIX_LOCK if server is using POSIX locking
* MI4_LOCK_DEBUG cmn_err'd posix lock err msg
* MI4_DEAD zone has released it
* MI4_INACTIVE_IDLE inactive thread idle
* MI4_BADOWNER_DEBUG badowner error msg per mount
* MI4_ASYNC_MGR_STOP tell async manager to die
* MI4_TIMEDOUT saw a timeout during zone shutdown
* MI4_EPHEMERAL is an ephemeral mount
*/
#define MI4_HARD 0x1
#define MI4_PRINTED 0x2
#define MI4_INT 0x4
#define MI4_DOWN 0x8
#define MI4_NOAC 0x10
#define MI4_NOCTO 0x20
#define MI4_LLOCK 0x80
#define MI4_GRPID 0x100
#define MI4_SHUTDOWN 0x200
#define MI4_LINK 0x400
#define MI4_SYMLINK 0x800
#define MI4_EPHEMERAL_RECURSED 0x1000
#define MI4_ACL 0x2000
/* MI4_MIRRORMOUNT is also defined in nfsstat.c */
#define MI4_MIRRORMOUNT 0x4000
#define MI4_REFERRAL 0x8000
/* 0x10000 is available */
#define MI4_NOPRINT 0x20000
#define MI4_DIRECTIO 0x40000
/* 0x80000 is available */
#define MI4_RECOV_ACTIV 0x100000
#define MI4_REMOVE_ON_LAST_CLOSE 0x200000
#define MI4_RECOV_FAIL 0x400000
#define MI4_PUBLIC 0x800000
#define MI4_MOUNTING 0x1000000
#define MI4_POSIX_LOCK 0x2000000
#define MI4_LOCK_DEBUG 0x4000000
#define MI4_DEAD 0x8000000
#define MI4_INACTIVE_IDLE 0x10000000
#define MI4_BADOWNER_DEBUG 0x20000000
#define MI4_ASYNC_MGR_STOP 0x40000000
#define MI4_TIMEDOUT 0x80000000
#define MI4_EPHEMERAL (MI4_MIRRORMOUNT | MI4_REFERRAL)
#define INTR4(vp) (VTOMI4(vp)->mi_flags & MI4_INT)
#define FAILOVER_MOUNT4(mi) (mi->mi_servers->sv_next)
/*
* Recovery flags.
*
* MI4R_NEED_CLIENTID is sort of redundant (it's the nfs4_server_t flag
* that's important), but some flag is needed to indicate that recovery is
* going on for the filesystem.
*/
#define MI4R_NEED_CLIENTID 0x1
#define MI4R_REOPEN_FILES 0x2
#define MI4R_NEED_SECINFO 0x4
#define MI4R_NEED_NEW_SERVER 0x8
#define MI4R_REMAP_FILES 0x10
#define MI4R_SRV_REBOOT 0x20 /* server has rebooted */
#define MI4R_LOST_STATE 0x40
#define MI4R_BAD_SEQID 0x80
#define MI4R_MOVED 0x100
#define MI4_HOLD(mi) { \
mi_hold(mi); \
}
#define MI4_RELE(mi) { \
mi_rele(mi); \
}
/*
* vfs pointer to mount info
*/
#define VFTOMI4(vfsp) ((mntinfo4_t *)((vfsp)->vfs_data))
/*
* vnode pointer to mount info
*/
#define VTOMI4(vp) ((mntinfo4_t *)(((vp)->v_vfsp)->vfs_data))
/*
* Lease Management
*
* lease_valid is initially set to NFS4_LEASE_NOT_STARTED. This is when the
* nfs4_server is first created. lease_valid is then set to
* NFS4_LEASE_UNITIALIZED when the renew thread is started. The extra state of
* NFS4_LEASE_NOT_STARTED is needed for client recovery (so we know if a thread
* already exists when we do SETCLIENTID). lease_valid is then set to
* NFS4_LEASE_VALID (if it is at NFS4_LEASE_UNITIALIZED) when a state creating
* operation (OPEN) is done. lease_valid stays at NFS4_LEASE_VALID as long as
* the lease is renewed. It is set to NFS4_LEASE_INVALID when the lease
* expires. Client recovery is needed to set the lease back to
* NFS4_LEASE_VALID from NFS4_LEASE_INVALID.
*
* The s_cred is the credential used to mount the first file system for this
* server. It used as the credential for the renew thread's calls to the
* server.
*
* The renew thread waits on the condition variable cv_thread_exit. If the cv
* is signalled, then the thread knows it must check s_thread_exit to see if
* it should exit. The cv is signaled when the last file system is unmounted
* from a particular server. s_thread_exit is set to 0 upon thread startup,
* and set to NFS4_THREAD_EXIT, when the last file system is unmounted thereby
* telling the thread to exit. s_thread_exit is needed to avoid spurious
* wakeups.
*
* state_ref_count is incremented every time a new file is opened and
* decremented every time a file is closed otw. This keeps track of whether
* the nfs4_server has state associated with it or not.
*
* s_refcnt is the reference count for storage management of the struct
* itself.
*
* mntinfo4_list points to the doubly linked list of mntinfo4s that share
* this nfs4_server (ie: <clientid, saddr> pair) in the current zone. This is
* needed for a nfs4_server to get a mntinfo4 for use in rfs4call.
*
* s_recovlock is used to synchronize recovery operations. The thread
* that is recovering the client must acquire it as a writer. If the
* thread is using the clientid (including recovery operations on other
* state), acquire it as a reader.
*
* The 's_otw_call_count' keeps track of the number of outstanding over the
* wire requests for this structure. The struct will not go away as long
* as this is non-zero (or s_refcnt is non-zero).
*
* The 's_cv_otw_count' is used in conjuntion with the 's_otw_call_count'
* variable to let the renew thread when an outstanding otw request has
* finished.
*
* 'zoneid' and 'zone_globals' are set at creation of this structure
* and are read-only after that; no lock is required to read them.
*
* s_lock protects: everything except cv_thread_exit and s_recovlock.
*
* s_program is used as the index into the nfs4_callback_globals's
* nfs4prog2server table. When a callback request comes in, we can
* use that request's program number (minus NFS4_CALLBACK) as an index
* into the nfs4prog2server. That entry will hold the nfs4_server_t ptr.
* We can then access that nfs4_server_t and its 's_deleg_list' (its list of
* delegated rnode4_ts).
*
* Lock order:
* nfs4_server::s_lock > mntinfo4::mi_lock
* nfs_rtable4_lock > s_lock
* nfs4_server_lst_lock > s_lock
* s_recovlock > s_lock
*/
struct nfs4_callback_globals;
typedef struct nfs4_server {
struct nfs4_server *forw;
struct nfs4_server *back;
struct netbuf saddr;
uint_t s_flags; /* see below */
uint_t s_refcnt;
clientid4 clientid; /* what we get from server */
nfs_client_id4 clidtosend; /* what we send to server */
mntinfo4_t *mntinfo4_list;
int lease_valid;
time_t s_lease_time;
time_t last_renewal_time;
timespec_t propagation_delay;
cred_t *s_cred;
kcondvar_t cv_thread_exit;
int s_thread_exit;
int state_ref_count;
int s_otw_call_count;
kcondvar_t s_cv_otw_count;
kcondvar_t s_clientid_pend;
kmutex_t s_lock;
list_t s_deleg_list;
rpcprog_t s_program;
nfs_rwlock_t s_recovlock;
kcondvar_t wait_cb_null; /* used to wait for CB_NULL */
zoneid_t zoneid; /* zone using this nfs4_server_t */
struct nfs4_callback_globals *zone_globals; /* globals */
} nfs4_server_t;
/* nfs4_server flags */
#define N4S_CLIENTID_SET 1 /* server has our clientid */
#define N4S_CLIENTID_PEND 0x2 /* server doesn't have clientid */
#define N4S_CB_PINGED 0x4 /* server has sent us a CB_NULL */
#define N4S_CB_WAITER 0x8 /* is/has wait{ing/ed} for cb_null */
#define N4S_INSERTED 0x10 /* list has reference for server */
#define N4S_BADOWNER_DEBUG 0x20 /* bad owner err msg per client */
#define N4S_CB_PAUSE_TIME 10000 /* Amount of time to pause (10ms) */
struct lease_time_arg {
time_t lease_time;
};
enum nfs4_delegreturn_policy {
IMMEDIATE,
FIRSTCLOSE,
LASTCLOSE,
INACTIVE
};
/*
* Operation hints for the recovery framework (mostly).
*
* EXCEPTIONS:
* OH_ACCESS, OH_GETACL, OH_GETATTR, OH_LOOKUP, OH_READDIR
* These hints exist to allow user visit/readdir a R4SRVSTUB dir.
* (dir represents the root of a server fs that has not yet been
* mounted at client)
*/
typedef enum {
OH_OTHER,
OH_READ,
OH_WRITE,
OH_COMMIT,
OH_VFH_RENAME,
OH_MOUNT,
OH_CLOSE,
OH_LOCKU,
OH_DELEGRETURN,
OH_ACCESS,
OH_GETACL,
OH_GETATTR,
OH_LOOKUP,
OH_READDIR
} nfs4_op_hint_t;
/*
* This data structure is used to track ephemeral mounts for both
* mirror mounts and referrals.
*
* Note that each nfs4_ephemeral can only have one other nfs4_ephemeral
* pointing at it. So we don't need two backpointers to walk
* back up the tree.
*
* An ephemeral tree is pointed to by an enclosing non-ephemeral
* mntinfo4. The root is also pointed to by its ephemeral
* mntinfo4. ne_child will get us back to it, while ne_prior
* will get us back to the non-ephemeral mntinfo4. This is an
* edge case we will need to be wary of when walking back up the
* tree.
*
* The way we handle this edge case is to have ne_prior be NULL
* for the root nfs4_ephemeral node.
*/
typedef struct nfs4_ephemeral {
mntinfo4_t *ne_mount; /* who encloses us */
struct nfs4_ephemeral *ne_child; /* first child node */
struct nfs4_ephemeral *ne_peer; /* next sibling */
struct nfs4_ephemeral *ne_prior; /* who points at us */
time_t ne_ref_time; /* time last referenced */
uint_t ne_mount_to; /* timeout at */
int ne_state; /* used to traverse */
} nfs4_ephemeral_t;
/*
* State for the node (set in ne_state):
*/
#define NFS4_EPHEMERAL_OK 0x0
#define NFS4_EPHEMERAL_VISIT_CHILD 0x1
#define NFS4_EPHEMERAL_VISIT_SIBLING 0x2
#define NFS4_EPHEMERAL_PROCESS_ME 0x4
#define NFS4_EPHEMERAL_CHILD_ERROR 0x8
#define NFS4_EPHEMERAL_PEER_ERROR 0x10
/*
* These are the locks used in processing ephemeral data:
*
* mi->mi_lock
*
* net->net_tree_lock
* This lock is used to gate all tree operations.
* If it is held, then no other process may
* traverse the tree. This allows us to not
* throw a hold on each vfs_t in the tree.
* Can be held for a "long" time.
*
* net->net_cnt_lock
* Used to protect refcnt and status.
* Must be held for a really short time.
*
* nfs4_ephemeral_thread_lock
* Is only held to create the harvester for the zone.
* There is no ordering imposed on it.
* Held for a really short time.
*
* Some further detail on the interactions:
*
* net_tree_lock controls access to net_root. Access needs to first be
* attempted in a non-blocking check.
*
* net_cnt_lock controls access to net_refcnt and net_status. It must only be
* held for very short periods of time, unless the refcnt is 0 and the status
* is INVALID.
*
* Before a caller can grab net_tree_lock, it must first grab net_cnt_lock
* to bump the net_refcnt. It then releases it and does the action specific
* algorithm to get the net_tree_lock. Once it has that, then it is okay to
* grab the net_cnt_lock and change the status. The status can only be
* changed if the caller has the net_tree_lock held as well.
*
* Note that the initial grab of net_cnt_lock must occur whilst
* mi_lock is being held. This prevents stale data in that if the
* ephemeral tree is non-NULL, then the harvester can not remove
* the tree from the mntinfo node until it grabs that lock. I.e.,
* we get the pointer to the tree and hold the lock atomically
* with respect to being in mi_lock.
*
* When a caller is done with net_tree_lock, it can decrement the net_refcnt
* either before it releases net_tree_lock or after.
*
* In either event, to decrement net_refcnt, it must hold net_cnt_lock.
*
* Note that the overall locking scheme for the nodes is to control access
* via the tree. The current scheme could easily be extended such that
* the enclosing root referenced a "forest" of trees. The underlying trees
* would be autonomous with respect to locks.
*
* Note that net_next is controlled by external locks
* particular to the data structure that the tree is being added to.
*/
typedef struct nfs4_ephemeral_tree {
mntinfo4_t *net_mount;
nfs4_ephemeral_t *net_root;
struct nfs4_ephemeral_tree *net_next;
kmutex_t net_tree_lock;
kmutex_t net_cnt_lock;
uint_t net_status;
uint_t net_refcnt;
} nfs4_ephemeral_tree_t;
/*
* State for the tree (set in net_status):
*/
#define NFS4_EPHEMERAL_TREE_OK 0x0
#define NFS4_EPHEMERAL_TREE_BUILDING 0x1
#define NFS4_EPHEMERAL_TREE_DEROOTING 0x2
#define NFS4_EPHEMERAL_TREE_INVALID 0x4
#define NFS4_EPHEMERAL_TREE_MOUNTING 0x8
#define NFS4_EPHEMERAL_TREE_UMOUNTING 0x10
#define NFS4_EPHEMERAL_TREE_LOCKED 0x20
#define NFS4_EPHEMERAL_TREE_PROCESSING (NFS4_EPHEMERAL_TREE_DEROOTING | \
NFS4_EPHEMERAL_TREE_INVALID | NFS4_EPHEMERAL_TREE_UMOUNTING | \
NFS4_EPHEMERAL_TREE_LOCKED)
/*
* This macro evaluates to non-zero if the given op releases state at the
* server.
*/
#define OH_IS_STATE_RELE(op) ((op) == OH_CLOSE || (op) == OH_LOCKU || \
(op) == OH_DELEGRETURN)
#ifdef _KERNEL
extern void nfs4_async_manager(struct vfs *);
extern void nfs4_async_manager_stop(struct vfs *);
extern void nfs4_async_stop(struct vfs *);
extern int nfs4_async_stop_sig(struct vfs *);
extern int nfs4_async_readahead(vnode_t *, u_offset_t, caddr_t,
struct seg *, cred_t *,
void (*)(vnode_t *, u_offset_t,
caddr_t, struct seg *, cred_t *));
extern int nfs4_async_putapage(vnode_t *, page_t *, u_offset_t, size_t,
int, cred_t *, int (*)(vnode_t *, page_t *,
u_offset_t, size_t, int, cred_t *));
extern int nfs4_async_pageio(vnode_t *, page_t *, u_offset_t, size_t,
int, cred_t *, int (*)(vnode_t *, page_t *,
u_offset_t, size_t, int, cred_t *));
extern void nfs4_async_commit(vnode_t *, page_t *, offset3, count3,
cred_t *, void (*)(vnode_t *, page_t *,
offset3, count3, cred_t *));
extern void nfs4_async_inactive(vnode_t *, cred_t *);
extern void nfs4_inactive_thread(mntinfo4_t *mi);
extern void nfs4_inactive_otw(vnode_t *, cred_t *);
extern int nfs4_putpages(vnode_t *, u_offset_t, size_t, int, cred_t *);
extern int nfs4_setopts(vnode_t *, model_t, struct nfs_args *);
extern void nfs4_mnt_kstat_init(struct vfs *);
extern void rfs4call(struct mntinfo4 *, struct COMPOUND4args_clnt *,
struct COMPOUND4res_clnt *, cred_t *, int *, int,
nfs4_error_t *);
extern void nfs4_acl_fill_cache(struct rnode4 *, vsecattr_t *);
extern int nfs4_attr_otw(vnode_t *, nfs4_tag_type_t,
nfs4_ga_res_t *, bitmap4, cred_t *);
extern void nfs4_attrcache_noinval(vnode_t *, nfs4_ga_res_t *, hrtime_t);
extern void nfs4_attr_cache(vnode_t *, nfs4_ga_res_t *,
hrtime_t, cred_t *, int,
change_info4 *);
extern void nfs4_purge_rddir_cache(vnode_t *);
extern void nfs4_invalidate_pages(vnode_t *, u_offset_t, cred_t *);
extern void nfs4_purge_caches(vnode_t *, int, cred_t *, int);
extern void nfs4_purge_stale_fh(int, vnode_t *, cred_t *);
extern void nfs4_flush_pages(vnode_t *vp, cred_t *cr);
extern void nfs4rename_update(vnode_t *, vnode_t *, nfs_fh4 *, char *);
extern void nfs4_update_paths(vnode_t *, char *, vnode_t *, char *,
vnode_t *);
extern void nfs4args_lookup_free(nfs_argop4 *, int);
extern void nfs4args_copen_free(OPEN4cargs *);
extern void nfs4_printfhandle(nfs4_fhandle_t *);
extern void nfs_free_mi4(mntinfo4_t *);
extern void sv4_free(servinfo4_t *);
extern void nfs4_mi_zonelist_add(mntinfo4_t *);
extern int nfs4_mi_zonelist_remove(mntinfo4_t *);
extern int nfs4_secinfo_recov(mntinfo4_t *, vnode_t *, vnode_t *);
extern void nfs4_secinfo_init(void);
extern void nfs4_secinfo_fini(void);
extern int nfs4_secinfo_path(mntinfo4_t *, cred_t *, int);
extern int nfs4_secinfo_vnode_otw(vnode_t *, char *, cred_t *);
extern void secinfo_free(sv_secinfo_t *);
extern void save_mnt_secinfo(servinfo4_t *);
extern void check_mnt_secinfo(servinfo4_t *, vnode_t *);
extern int vattr_to_fattr4(vattr_t *, vsecattr_t *, fattr4 *, int,
enum nfs_opnum4, bitmap4 supp_mask);
extern int nfs4_putapage(vnode_t *, page_t *, u_offset_t *, size_t *,
int, cred_t *);
extern void nfs4_write_error(vnode_t *, int, cred_t *);
extern void nfs4_lockcompletion(vnode_t *, int);
extern bool_t nfs4_map_lost_lock_conflict(vnode_t *);
extern int vtodv(vnode_t *, vnode_t **, cred_t *, bool_t);
extern int vtoname(vnode_t *, char *, ssize_t);
extern void nfs4open_confirm(vnode_t *, seqid4*, stateid4 *, cred_t *,
bool_t, bool_t *, nfs4_open_owner_t *, bool_t,
nfs4_error_t *, int *);
extern void nfs4_error_zinit(nfs4_error_t *);
extern void nfs4_error_init(nfs4_error_t *, int);
extern void nfs4_free_args(struct nfs_args *);
extern void mi_hold(mntinfo4_t *);
extern void mi_rele(mntinfo4_t *);
extern vnode_t *find_referral_stubvp(vnode_t *, char *, cred_t *);
extern int nfs4_setup_referral(vnode_t *, char *, vnode_t **, cred_t *);
extern sec_data_t *copy_sec_data(sec_data_t *);
extern gss_clntdata_t *copy_sec_data_gss(gss_clntdata_t *);
#ifdef DEBUG
extern int nfs4_consistent_type(vnode_t *);
#endif
extern void nfs4_init_dot_entries(void);
extern void nfs4_destroy_dot_entries(void);
extern struct nfs4_callback_globals *nfs4_get_callback_globals(void);
extern struct nfs4_server nfs4_server_lst;
extern clock_t nfs_write_error_interval;
#endif /* _KERNEL */
/*
* Flags for nfs4getfh_otw.
*/
#define NFS4_GETFH_PUBLIC 0x01
#define NFS4_GETFH_NEEDSOP 0x02
/*
* Found through rnodes.
*
* The os_open_ref_count keeps track the number of open file descriptor
* refernces on this data structure. It will be bumped for any successful
* OTW OPEN call and any OPEN call that determines the OTW call is not
* necessary and the open stream hasn't just been created (see
* nfs4_is_otw_open_necessary).
*
* os_mapcnt is a count of the number of mmapped pages for a particular
* open stream; this in conjunction w/ os_open_ref_count is used to
* determine when to do a close to the server. This is necessary because
* of the semantics of doing open, mmap, close; the OTW close must be wait
* until all open and mmap references have vanished.
*
* 'os_valid' tells us whether this structure is about to be freed or not,
* if it is then don't return it in find_open_stream().
*
* 'os_final_close' is set when a CLOSE OTW was attempted. This is needed
* so we can properly count the os_open_ref_count in cases where we VOP_CLOSE
* without a VOP_OPEN, and have nfs4_inactive() drive the OTW CLOSE. It
* also helps differentiate the VOP_OPEN/VN_RELE case from the VOP_CLOSE
* that tried to close OTW but failed, and left the state cleanup to
* nfs4_inactive/CLOSE_FORCE.
*
* 'os_force_close' is used to let us know if an intervening thread came
* and reopened the open stream after we decided to issue a CLOSE_FORCE,
* but before we could actually process the CLOSE_FORCE.
*
* 'os_pending_close' is set when an over-the-wire CLOSE is deferred to the
* lost state queue.
*
* 'open_stateid' is set the last open stateid returned by the server unless
* 'os_delegation' is 1, in which case 'open_stateid' refers to the
* delegation stateid returned by the server. This is used in cases where the
* client tries to OPEN a file but already has a suitable delegation, so we
* just stick the delegation stateid in the open stream.
*
* os_dc_openacc are open access bits which have been granted to the
* open stream by virtue of a delegation, but which have not been seen
* by the server. This applies even if the open stream does not have
* os_delegation set. These bits are used when setting file locks to
* determine whether an open with CLAIM_DELEGATE_CUR needs to be done
* before the lock request can be sent to the server. See
* nfs4frlock_check_deleg().
*
* 'os_mmap_read/write' keep track of the read and write access our memory
* maps require. We need to keep track of this so we can provide the proper
* access bits in the open/mmap/close/reboot/reopen case.
*
* 'os_failed_reopen' tells us that we failed to successfully reopen this
* open stream; therefore, we should not use this open stateid as it is
* not valid anymore. This flag is also used to indicate an unsuccessful
* attempt to reopen a delegation open stream with CLAIM_DELEGATE_CUR.
*
* If 'os_orig_oo_name' is different than os_open_owner's oo_name
* then this tells us that this open stream's open owner used a
* bad seqid (that is, got NFS4ERR_BAD_SEQID). If different, this open
* stream will no longer be used for future OTW state releasing calls.
*
* Lock ordering:
* rnode4_t::r_os_lock > os_sync_lock
* os_sync_lock > rnode4_t::r_statelock
* os_sync_lock > rnode4_t::r_statev4_lock
* os_sync_lock > mntinfo4_t::mi_lock (via hold over rfs4call)
*
* The 'os_sync_lock' protects:
* open_stateid
* os_dc_openacc
* os_delegation
* os_failed_reopen
* os_final_close
* os_force_close
* os_mapcnt
* os_mmap_read
* os_mmap_write
* os_open_ref_count
* os_pending_close
* os_share_acc_read
* os_share_acc_write
* os_share_deny_none
* os_share_deny_read
* os_share_deny_write
* os_ref_count
* os_valid
*
* The rnode4_t::r_os_lock protects:
* os_node
*
* These fields are set at creation time and
* read only after that:
* os_open_owner
* os_orig_oo_name
*/
typedef struct nfs4_open_stream {
uint64_t os_share_acc_read;
uint64_t os_share_acc_write;
uint64_t os_mmap_read;
uint64_t os_mmap_write;
uint32_t os_share_deny_none;
uint32_t os_share_deny_read;
uint32_t os_share_deny_write;
stateid4 open_stateid;
int os_dc_openacc;
int os_ref_count;
unsigned os_valid:1;
unsigned os_delegation:1;
unsigned os_final_close:1;
unsigned os_pending_close:1;
unsigned os_failed_reopen:1;
unsigned os_force_close:1;
int os_open_ref_count;
long os_mapcnt;
list_node_t os_node;
struct nfs4_open_owner *os_open_owner;
uint64_t os_orig_oo_name;
kmutex_t os_sync_lock;
} nfs4_open_stream_t;
/*
* This structure describes the format of the lock_owner_name
* field of the lock owner.
*/
typedef struct nfs4_lo_name {
uint64_t ln_seq_num;
pid_t ln_pid;
} nfs4_lo_name_t;
/*
* Flags for lo_flags.
*/
#define NFS4_LOCK_SEQID_INUSE 0x1
#define NFS4_BAD_SEQID_LOCK 0x2
/*
* The lo_prev_rnode and lo_next_rnode are for a circular list that hangs
* off the rnode. If the links are NULL it means this object is not on the
* list.
*
* 'lo_pending_rqsts' is non-zero if we ever tried to send a request and
* didn't get a response back. This is used to figure out if we have
* possible remote v4 locks, so that we can clean up at process exit. In
* theory, the client should be able to figure out if the server received
* the request (based on what seqid works), so maybe we can get rid of this
* flag someday.
*
* 'lo_ref_count' tells us how many processes/threads are using this data
* structure. The rnode's list accounts for one reference.
*
* 'lo_just_created' is set to NFS4_JUST_CREATED when we first create the
* data structure. It is then set to NFS4_PERM_CREATED when a lock request
* is successful using this lock owner structure. We need to keep 'temporary'
* lock owners around so we can properly keep the lock seqid synchronization
* when multiple processes/threads are trying to create the lock owner for the
* first time (especially with the DENIED error case). Once
* 'lo_just_created' is set to NFS4_PERM_CREATED, it doesn't change.
*
* 'lo_valid' tells us whether this structure is about to be freed or not,
* if it is then don't return it from find_lock_owner().
*
* Retrieving and setting of 'lock_seqid' is protected by the
* NFS4_LOCK_SEQID_INUSE flag. Waiters for NFS4_LOCK_SEQID_INUSE should
* use 'lo_cv_seqid_sync'.
*
* The setting of 'lock_stateid' is protected by the
* NFS4_LOCK_SEQID_INUSE flag and 'lo_lock'. The retrieving of the
* 'lock_stateid' is protected by 'lo_lock', with the additional
* requirement that the calling function can handle NFS4ERR_OLD_STATEID and
* NFS4ERR_BAD_STATEID as appropiate.
*
* The setting of NFS4_BAD_SEQID_LOCK to lo_flags tells us whether this lock
* owner used a bad seqid (that is, got NFS4ERR_BAD_SEQID). With this set,
* this lock owner will no longer be used for future OTW calls. Once set,
* it is never unset.
*
* Lock ordering:
* rnode4_t::r_statev4_lock > lo_lock
*/
typedef struct nfs4_lock_owner {
struct nfs4_lock_owner *lo_next_rnode;
struct nfs4_lock_owner *lo_prev_rnode;
int lo_pid;
stateid4 lock_stateid;
seqid4 lock_seqid;
/*
* Fix this to always be 12 bytes
*/
nfs4_lo_name_t lock_owner_name;
int lo_ref_count;
int lo_valid;
int lo_pending_rqsts;
int lo_just_created;
int lo_flags;
kcondvar_t lo_cv_seqid_sync;
kmutex_t lo_lock;
kthread_t *lo_seqid_holder; /* debugging aid */
} nfs4_lock_owner_t;
/* for nfs4_lock_owner_t lookups */
typedef enum {LOWN_ANY, LOWN_VALID_STATEID} lown_which_t;
/* Number of times to retry a call that fails with state independent error */
#define NFS4_NUM_RECOV_RETRIES 3
typedef enum {
NO_SID,
DEL_SID,
LOCK_SID,
OPEN_SID,
SPEC_SID
} nfs4_stateid_type_t;
typedef struct nfs4_stateid_types {
stateid4 d_sid;
stateid4 l_sid;
stateid4 o_sid;
nfs4_stateid_type_t cur_sid_type;
} nfs4_stateid_types_t;
/*
* Per-zone data for dealing with callbacks. Included here solely for the
* benefit of MDB.
*/
struct nfs4_callback_stats {
kstat_named_t delegations;
kstat_named_t cb_getattr;
kstat_named_t cb_recall;
kstat_named_t cb_null;
kstat_named_t cb_dispatch;
kstat_named_t delegaccept_r;
kstat_named_t delegaccept_rw;
kstat_named_t delegreturn;
kstat_named_t callbacks;
kstat_named_t claim_cur;
kstat_named_t claim_cur_ok;
kstat_named_t recall_trunc;
kstat_named_t recall_failed;
kstat_named_t return_limit_write;
kstat_named_t return_limit_addmap;
kstat_named_t deleg_recover;
kstat_named_t cb_illegal;
};
struct nfs4_callback_globals {
kmutex_t nfs4_cb_lock;
kmutex_t nfs4_dlist_lock;
int nfs4_program_hint;
/* this table maps the program number to the nfs4_server structure */
struct nfs4_server **nfs4prog2server;
list_t nfs4_dlist;
list_t nfs4_cb_ports;
struct nfs4_callback_stats nfs4_callback_stats;
#ifdef DEBUG
int nfs4_dlistadd_c;
int nfs4_dlistclean_c;
#endif
};
typedef enum {
CLOSE_NORM,
CLOSE_DELMAP,
CLOSE_FORCE,
CLOSE_RESEND,
CLOSE_AFTER_RESEND
} nfs4_close_type_t;
/*
* Structure to hold the bad seqid information that is passed
* to the recovery framework.
*/
typedef struct nfs4_bseqid_entry {
nfs4_open_owner_t *bs_oop;
nfs4_lock_owner_t *bs_lop;
vnode_t *bs_vp;
pid_t bs_pid;
nfs4_tag_type_t bs_tag;
seqid4 bs_seqid;
list_node_t bs_node;
} nfs4_bseqid_entry_t;
#ifdef _KERNEL
extern void nfs4close_one(vnode_t *, nfs4_open_stream_t *, cred_t *, int,
nfs4_lost_rqst_t *, nfs4_error_t *, nfs4_close_type_t,
size_t, uint_t, uint_t);
extern void nfs4close_notw(vnode_t *, nfs4_open_stream_t *, int *);
extern void nfs4_set_lock_stateid(nfs4_lock_owner_t *, stateid4);
extern void open_owner_hold(nfs4_open_owner_t *);
extern void open_owner_rele(nfs4_open_owner_t *);
extern nfs4_open_stream_t *find_or_create_open_stream(nfs4_open_owner_t *,
struct rnode4 *, int *);
extern nfs4_open_stream_t *find_open_stream(nfs4_open_owner_t *,
struct rnode4 *);
extern nfs4_open_stream_t *create_open_stream(nfs4_open_owner_t *oop,
struct rnode4 *rp);
extern void open_stream_hold(nfs4_open_stream_t *);
extern void open_stream_rele(nfs4_open_stream_t *, struct rnode4 *);
extern int nfs4close_all(vnode_t *, cred_t *);
extern void lock_owner_hold(nfs4_lock_owner_t *);
extern void lock_owner_rele(nfs4_lock_owner_t *);
extern nfs4_lock_owner_t *create_lock_owner(struct rnode4 *, pid_t);
extern nfs4_lock_owner_t *find_lock_owner(struct rnode4 *, pid_t, lown_which_t);
extern void nfs4_rnode_remove_lock_owner(struct rnode4 *,
nfs4_lock_owner_t *);
extern void nfs4_flush_lock_owners(struct rnode4 *);
extern void nfs4_setlockowner_args(lock_owner4 *, struct rnode4 *, pid_t);
extern void nfs4_set_open_seqid(seqid4, nfs4_open_owner_t *,
nfs4_tag_type_t);
extern void nfs4_set_lock_seqid(seqid4, nfs4_lock_owner_t *);
extern void nfs4_get_and_set_next_open_seqid(nfs4_open_owner_t *,
nfs4_tag_type_t);
extern void nfs4_end_open_seqid_sync(nfs4_open_owner_t *);
extern int nfs4_start_open_seqid_sync(nfs4_open_owner_t *, mntinfo4_t *);
extern void nfs4_end_lock_seqid_sync(nfs4_lock_owner_t *);
extern int nfs4_start_lock_seqid_sync(nfs4_lock_owner_t *, mntinfo4_t *);
extern void nfs4_setup_lock_args(nfs4_lock_owner_t *, nfs4_open_owner_t *,
nfs4_open_stream_t *, clientid4, locker4 *);
extern void nfs4_destroy_open_owner(nfs4_open_owner_t *);
extern void nfs4_renew_lease_thread(nfs4_server_t *);
extern nfs4_server_t *find_nfs4_server(mntinfo4_t *);
extern nfs4_server_t *find_nfs4_server_all(mntinfo4_t *, int all);
extern nfs4_server_t *new_nfs4_server(servinfo4_t *, cred_t *);
extern void nfs4_mark_srv_dead(nfs4_server_t *);
extern nfs4_server_t *servinfo4_to_nfs4_server(servinfo4_t *);
extern void nfs4_inc_state_ref_count(mntinfo4_t *);
extern void nfs4_inc_state_ref_count_nolock(nfs4_server_t *,
mntinfo4_t *);
extern void nfs4_dec_state_ref_count(mntinfo4_t *);
extern void nfs4_dec_state_ref_count_nolock(nfs4_server_t *,
mntinfo4_t *);
extern clientid4 mi2clientid(mntinfo4_t *);
extern int nfs4_server_in_recovery(nfs4_server_t *);
extern bool_t nfs4_server_vlock(nfs4_server_t *, int);
extern nfs4_open_owner_t *create_open_owner(cred_t *, mntinfo4_t *);
extern uint64_t nfs4_get_new_oo_name(void);
extern nfs4_open_owner_t *find_open_owner(cred_t *, int, mntinfo4_t *);
extern nfs4_open_owner_t *find_open_owner_nolock(cred_t *, int, mntinfo4_t *);
extern void nfs4frlock(nfs4_lock_call_type_t, vnode_t *, int, flock64_t *,
int, u_offset_t, cred_t *, nfs4_error_t *,
nfs4_lost_rqst_t *, int *);
extern void nfs4open_dg_save_lost_rqst(int, nfs4_lost_rqst_t *,
nfs4_open_owner_t *, nfs4_open_stream_t *, cred_t *,
vnode_t *, int, int);
extern void nfs4_open_downgrade(int, int, nfs4_open_owner_t *,
nfs4_open_stream_t *, vnode_t *, cred_t *,
nfs4_lost_rqst_t *, nfs4_error_t *, cred_t **, seqid4 *);
extern seqid4 nfs4_get_open_seqid(nfs4_open_owner_t *);
extern cred_t *nfs4_get_otw_cred(cred_t *, mntinfo4_t *, nfs4_open_owner_t *);
extern void nfs4_init_stateid_types(nfs4_stateid_types_t *);
extern void nfs4_save_stateid(stateid4 *, nfs4_stateid_types_t *);
extern kmutex_t nfs4_server_lst_lock;
extern void nfs4callback_destroy(nfs4_server_t *);
extern void nfs4_callback_init(void);
extern void nfs4_callback_fini(void);
extern void nfs4_cb_args(nfs4_server_t *, struct knetconfig *,
SETCLIENTID4args *);
extern void nfs4delegreturn_async(struct rnode4 *, int, bool_t);
extern enum nfs4_delegreturn_policy nfs4_delegreturn_policy;
extern void nfs4_add_mi_to_server(nfs4_server_t *, mntinfo4_t *);
extern void nfs4_remove_mi_from_server(mntinfo4_t *, nfs4_server_t *);
extern nfs4_server_t *nfs4_move_mi(mntinfo4_t *, servinfo4_t *, servinfo4_t *);
extern bool_t nfs4_fs_active(nfs4_server_t *);
extern void nfs4_server_rele(nfs4_server_t *);
extern bool_t inlease(nfs4_server_t *);
extern bool_t nfs4_has_pages(vnode_t *);
extern void nfs4_log_badowner(mntinfo4_t *, nfs_opnum4);
#endif /* _KERNEL */
/*
* Client State Recovery
*/
/*
* The following defines are used for rs_flags in
* a nfs4_recov_state_t structure.
*
* NFS4_RS_RENAME_HELD Indicates that the mi_rename_lock was held.
* NFS4_RS_GRACE_MSG Set once we have uprintf'ed a grace message.
* NFS4_RS_DELAY_MSG Set once we have uprintf'ed a delay message.
* NFS4_RS_RECALL_HELD1 r_deleg_recall_lock for vp1 was held.
* NFS4_RS_RECALL_HELD2 r_deleg_recall_lock for vp2 was held.
*/
#define NFS4_RS_RENAME_HELD 0x000000001
#define NFS4_RS_GRACE_MSG 0x000000002
#define NFS4_RS_DELAY_MSG 0x000000004
#define NFS4_RS_RECALL_HELD1 0x000000008
#define NFS4_RS_RECALL_HELD2 0x000000010
/*
* Information that is retrieved from nfs4_start_op() and that is
* passed into nfs4_end_op().
*
* rs_sp is a reference to the nfs4_server that was found, or NULL.
*
* rs_num_retry_despite_err is the number times client retried an
* OTW op despite a recovery error. It is only incremented for hints
* exempt to normal R4RECOVERR processing
* (OH_CLOSE/OH_LOCKU/OH_DELEGRETURN). (XXX this special-case code
* needs review for possible removal.)
* It is initialized wherever nfs4_recov_state_t is declared -- usually
* very near initialization of rs_flags.
*/
typedef struct {
nfs4_server_t *rs_sp;
int rs_flags;
int rs_num_retry_despite_err;
} nfs4_recov_state_t;
/*
* Flags for nfs4_check_remap, nfs4_remap_file and nfs4_remap_root.
*/
#define NFS4_REMAP_CKATTRS 1
#define NFS4_REMAP_NEEDSOP 2
#ifdef _KERNEL
extern int nfs4_is_otw_open_necessary(nfs4_open_owner_t *, int,
vnode_t *, int, int *, int, nfs4_recov_state_t *);
extern void nfs4setclientid(struct mntinfo4 *, struct cred *, bool_t,
nfs4_error_t *);
extern void nfs4_reopen(vnode_t *, nfs4_open_stream_t *, nfs4_error_t *,
open_claim_type4, bool_t, bool_t);
extern void nfs4_remap_root(struct mntinfo4 *, nfs4_error_t *, int);
extern void nfs4_check_remap(mntinfo4_t *mi, vnode_t *vp, int,
nfs4_error_t *);
extern void nfs4_remap_file(mntinfo4_t *mi, vnode_t *vp, int,
nfs4_error_t *);
extern int nfs4_make_dotdot(struct nfs4_sharedfh *, hrtime_t,
vnode_t *, cred_t *, vnode_t **, int);
extern void nfs4_fail_recov(vnode_t *, char *, int, nfsstat4);
extern int nfs4_needs_recovery(nfs4_error_t *, bool_t, vfs_t *);
extern int nfs4_recov_marks_dead(nfsstat4);
extern bool_t nfs4_start_recovery(nfs4_error_t *, struct mntinfo4 *,
vnode_t *, vnode_t *, stateid4 *,
nfs4_lost_rqst_t *, nfs_opnum4, nfs4_bseqid_entry_t *,
vnode_t *, char *);
extern int nfs4_start_op(struct mntinfo4 *, vnode_t *, vnode_t *,
nfs4_recov_state_t *);
extern void nfs4_end_op(struct mntinfo4 *, vnode_t *, vnode_t *,
nfs4_recov_state_t *, bool_t);
extern int nfs4_start_fop(struct mntinfo4 *, vnode_t *, vnode_t *,
nfs4_op_hint_t, nfs4_recov_state_t *, bool_t *);
extern void nfs4_end_fop(struct mntinfo4 *, vnode_t *, vnode_t *,
nfs4_op_hint_t, nfs4_recov_state_t *, bool_t);
extern char *nfs4_recov_action_to_str(nfs4_recov_t);
/*
* In sequence, code desiring to unmount an ephemeral tree must
* call nfs4_ephemeral_umount, nfs4_ephemeral_umount_activate,
* and nfs4_ephemeral_umount_unlock. The _unlock must also be
* called on all error paths that occur before it would naturally
* be invoked.
*
* The caller must also provde a pointer to a boolean to keep track
* of whether or not the code in _unlock is to be ran.
*/
extern void nfs4_ephemeral_umount_activate(mntinfo4_t *,
bool_t *, nfs4_ephemeral_tree_t **);
extern int nfs4_ephemeral_umount(mntinfo4_t *, int, cred_t *,
bool_t *, nfs4_ephemeral_tree_t **);
extern void nfs4_ephemeral_umount_unlock(bool_t *,
nfs4_ephemeral_tree_t **);
extern int nfs4_record_ephemeral_mount(mntinfo4_t *mi, vnode_t *mvp);
extern int nfs4_callmapid(utf8string *, struct nfs_fsl_info *);
extern int nfs4_fetch_locations(mntinfo4_t *, struct nfs4_sharedfh *,
char *, cred_t *, nfs4_ga_res_t *, COMPOUND4res_clnt *, bool_t);
extern int wait_for_recall(vnode_t *, vnode_t *, nfs4_op_hint_t,
nfs4_recov_state_t *);
extern void nfs4_end_op_recall(vnode_t *, vnode_t *, nfs4_recov_state_t *);
extern void nfs4_send_siglost(pid_t, mntinfo4_t *mi, vnode_t *vp, bool_t,
int, nfsstat4);
extern time_t nfs4err_delay_time;
extern void nfs4_set_grace_wait(mntinfo4_t *);
extern void nfs4_set_delay_wait(vnode_t *);
extern int nfs4_wait_for_grace(mntinfo4_t *, nfs4_recov_state_t *);
extern int nfs4_wait_for_delay(vnode_t *, nfs4_recov_state_t *);
extern nfs4_bseqid_entry_t *nfs4_create_bseqid_entry(nfs4_open_owner_t *,
nfs4_lock_owner_t *, vnode_t *, pid_t, nfs4_tag_type_t,
seqid4);
extern void nfs4_resend_open_otw(vnode_t **, nfs4_lost_rqst_t *,
nfs4_error_t *);
extern void nfs4_resend_delegreturn(nfs4_lost_rqst_t *, nfs4_error_t *,
nfs4_server_t *);
extern int nfs4_rpc_retry_error(int);
extern int nfs4_try_failover(nfs4_error_t *);
extern void nfs4_free_msg(nfs4_debug_msg_t *);
extern void nfs4_mnt_recov_kstat_init(vfs_t *);
extern void nfs4_mi_kstat_inc_delay(mntinfo4_t *);
extern void nfs4_mi_kstat_inc_no_grace(mntinfo4_t *);
extern char *nfs4_stat_to_str(nfsstat4);
extern char *nfs4_op_to_str(nfs_opnum4);
extern void nfs4_queue_event(nfs4_event_type_t, mntinfo4_t *, char *,
uint_t, vnode_t *, vnode_t *, nfsstat4, char *, pid_t,
nfs4_tag_type_t, nfs4_tag_type_t, seqid4, seqid4);
extern void nfs4_queue_fact(nfs4_fact_type_t, mntinfo4_t *, nfsstat4,
nfs4_recov_t, nfs_opnum4, bool_t, char *, int, vnode_t *);
#pragma rarely_called(nfs4_queue_event)
#pragma rarely_called(nfs4_queue_fact)
/* Used for preformed "." and ".." dirents */
extern char *nfs4_dot_entries;
extern char *nfs4_dot_dot_entry;
#ifdef DEBUG
extern uint_t nfs4_tsd_key;
#endif
#endif /* _KERNEL */
/*
* Filehandle management.
*
* Filehandles can change in v4, so rather than storing the filehandle
* directly in the rnode, etc., we manage the filehandle through one of
* these objects.
* Locking: sfh_fh and sfh_tree is protected by the filesystem's
* mi_fh_lock. The reference count and flags are protected by sfh_lock.
* sfh_mi is read-only.
*
* mntinfo4_t::mi_fh_lock > sfh_lock.
*/
typedef struct nfs4_sharedfh {
nfs_fh4 sfh_fh; /* key and current filehandle */
kmutex_t sfh_lock;
uint_t sfh_refcnt; /* reference count */
uint_t sfh_flags;
mntinfo4_t *sfh_mi; /* backptr to filesystem */
avl_node_t sfh_tree; /* used by avl package */
} nfs4_sharedfh_t;
#define SFH4_SAME(sfh1, sfh2) ((sfh1) == (sfh2))
/*
* Flags.
*/
#define SFH4_IN_TREE 0x1 /* currently in an AVL tree */
#ifdef _KERNEL
extern void sfh4_createtab(avl_tree_t *);
extern nfs4_sharedfh_t *sfh4_get(const nfs_fh4 *, mntinfo4_t *);
extern nfs4_sharedfh_t *sfh4_put(const nfs_fh4 *, mntinfo4_t *,
nfs4_sharedfh_t *);
extern void sfh4_update(nfs4_sharedfh_t *, const nfs_fh4 *);
extern void sfh4_copyval(const nfs4_sharedfh_t *, nfs4_fhandle_t *);
extern void sfh4_hold(nfs4_sharedfh_t *);
extern void sfh4_rele(nfs4_sharedfh_t **);
extern void sfh4_printfhandle(const nfs4_sharedfh_t *);
#endif
/*
* Path and file name management.
*
* This type stores the name of an entry in the filesystem and keeps enough
* information that it can provide a complete path. All fields are
* protected by fn_lock, except for the reference count, which is managed
* using atomic add/subtract.
*
* Additionally shared filehandle for this fname is stored.
* Normally, fn_get() when it creates this fname stores the passed in
* shared fh in fn_sfh by doing sfh_hold. Similarly the path which
* destroys this fname releases the reference on this fh by doing sfh_rele.
*
* fn_get uses the fn_sfh to refine the comparision in cases
* where we have matched the name but have differing file handles,
* this normally happens due to
*
* 1. Server side rename of a file/directory.
* 2. Another client renaming a file/directory on the server.
*
* Differing names but same filehandle is possible as in the case of hardlinks,
* but differing filehandles with same name component will later confuse
* the client and can cause various panics.
*
* Lock order: child and then parent.
*/
typedef struct nfs4_fname {
struct nfs4_fname *fn_parent; /* parent name; null if fs root */
char *fn_name; /* the actual name */
ssize_t fn_len; /* strlen(fn_name) */
uint32_t fn_refcnt; /* reference count */
kmutex_t fn_lock;
avl_node_t fn_tree;
avl_tree_t fn_children; /* children, if any */
nfs4_sharedfh_t *fn_sfh; /* The fh for this fname */
} nfs4_fname_t;
#ifdef _KERNEL
extern vnode_t nfs4_xattr_notsupp_vnode;
#define NFS4_XATTR_DIR_NOTSUPP &nfs4_xattr_notsupp_vnode
extern nfs4_fname_t *fn_get(nfs4_fname_t *, char *, nfs4_sharedfh_t *);
extern void fn_hold(nfs4_fname_t *);
extern void fn_rele(nfs4_fname_t **);
extern char *fn_name(nfs4_fname_t *);
extern char *fn_path(nfs4_fname_t *);
extern void fn_move(nfs4_fname_t *, nfs4_fname_t *, char *);
extern nfs4_fname_t *fn_parent(nfs4_fname_t *);
/* Referral Support */
extern int nfs4_process_referral(mntinfo4_t *, nfs4_sharedfh_t *, char *,
cred_t *, nfs4_ga_res_t *, COMPOUND4res_clnt *, struct nfs_fsl_info *);
#endif
/*
* Per-zone data for managing client handles, included in this file for the
* benefit of MDB.
*/
struct nfs4_clnt {
struct chhead *nfscl_chtable4;
kmutex_t nfscl_chtable4_lock;
zoneid_t nfscl_zoneid;
list_node_t nfscl_node;
struct clstat4 nfscl_stat;
};
#ifdef __cplusplus
}
#endif
#endif /* _NFS4_CLNT_H */