17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #ifndef _NFS4_H 287c478bd9Sstevel@tonic-gate #define _NFS4_H 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 317c478bd9Sstevel@tonic-gate 327c478bd9Sstevel@tonic-gate #include <sys/types.h> 337c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 347c478bd9Sstevel@tonic-gate #include <sys/fem.h> 357c478bd9Sstevel@tonic-gate #include <rpc/rpc.h> 367c478bd9Sstevel@tonic-gate #include <nfs/nfs.h> 377c478bd9Sstevel@tonic-gate 387c478bd9Sstevel@tonic-gate #ifdef _KERNEL 397c478bd9Sstevel@tonic-gate #include <nfs/nfs4_kprot.h> 407c478bd9Sstevel@tonic-gate #else 417c478bd9Sstevel@tonic-gate #include <rpcsvc/nfs4_prot.h> 427c478bd9Sstevel@tonic-gate #endif 437c478bd9Sstevel@tonic-gate #include <nfs/nfs4_attr.h> 447c478bd9Sstevel@tonic-gate #include <sys/acl.h> 457c478bd9Sstevel@tonic-gate 467c478bd9Sstevel@tonic-gate #ifdef __cplusplus 477c478bd9Sstevel@tonic-gate extern "C" { 487c478bd9Sstevel@tonic-gate #endif 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate #define NFS4_MAX_UTF8STRING 65536 517c478bd9Sstevel@tonic-gate #define NFS4_MAX_PATHNAME4 65536 527c478bd9Sstevel@tonic-gate #define NFS4_MAX_SECOID4 65536 537c478bd9Sstevel@tonic-gate 547c478bd9Sstevel@tonic-gate #ifdef _KERNEL 557c478bd9Sstevel@tonic-gate 567c478bd9Sstevel@tonic-gate typedef struct nfs4_fhandle { 577c478bd9Sstevel@tonic-gate int fh_len; 587c478bd9Sstevel@tonic-gate char fh_buf[NFS4_FHSIZE]; 597c478bd9Sstevel@tonic-gate } nfs4_fhandle_t; 607c478bd9Sstevel@tonic-gate 617c478bd9Sstevel@tonic-gate #define NFS4_MINORVERSION 0 627c478bd9Sstevel@tonic-gate #define CB4_MINORVERSION 0 637c478bd9Sstevel@tonic-gate 647c478bd9Sstevel@tonic-gate /* 657c478bd9Sstevel@tonic-gate * Set the fattr4_change variable using a time struct. Note that change 667c478bd9Sstevel@tonic-gate * is 64 bits, but timestruc_t is 128 bits in a 64-bit kernel. 677c478bd9Sstevel@tonic-gate */ 687c478bd9Sstevel@tonic-gate #define NFS4_SET_FATTR4_CHANGE(change, ts) \ 697c478bd9Sstevel@tonic-gate { \ 707c478bd9Sstevel@tonic-gate change = (ts).tv_sec; \ 717c478bd9Sstevel@tonic-gate change <<= 32; \ 727c478bd9Sstevel@tonic-gate change |= (uint32_t)((ts).tv_nsec); \ 737c478bd9Sstevel@tonic-gate } 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate /* 767c478bd9Sstevel@tonic-gate * Server lease period. Value is in seconds; Also used for grace period 777c478bd9Sstevel@tonic-gate */ 787c478bd9Sstevel@tonic-gate extern time_t rfs4_lease_time; 797c478bd9Sstevel@tonic-gate 807c478bd9Sstevel@tonic-gate /* 817c478bd9Sstevel@tonic-gate * This set of typedefs and interfaces represent the core or base set 827c478bd9Sstevel@tonic-gate * of functionality that backs the NFSv4 server's state related data 837c478bd9Sstevel@tonic-gate * structures. Since the NFSv4 server needs inter-RPC state to be 847c478bd9Sstevel@tonic-gate * available that is unrelated to the filesystem (in other words, 857c478bd9Sstevel@tonic-gate * soft-state), this functionality is needed to maintain that and is 867c478bd9Sstevel@tonic-gate * written to be somewhat flexible to adapt to the various types of 877c478bd9Sstevel@tonic-gate * data structures contained within the server. 887c478bd9Sstevel@tonic-gate * 897c478bd9Sstevel@tonic-gate * The basic structure at this level is that the server maintains a 907c478bd9Sstevel@tonic-gate * global "database" which consists of a set of tables. Each table 917c478bd9Sstevel@tonic-gate * contains a set of like data structures. Each table is indexed by 927c478bd9Sstevel@tonic-gate * at least one hash function and in most cases two hashes. Each 937c478bd9Sstevel@tonic-gate * table's characteristics is set when it is created at run-time via 947c478bd9Sstevel@tonic-gate * rfs4_table_create(). All table creation and related functions are 957c478bd9Sstevel@tonic-gate * located in nfs4_state.c. The generic database functionality is 967c478bd9Sstevel@tonic-gate * located in nfs4_db.c. 977c478bd9Sstevel@tonic-gate */ 987c478bd9Sstevel@tonic-gate 997c478bd9Sstevel@tonic-gate typedef struct rfs4_dbe rfs4_dbe_t; /* basic opaque db entry */ 1007c478bd9Sstevel@tonic-gate typedef struct rfs4_table rfs4_table_t; /* basic table type */ 1017c478bd9Sstevel@tonic-gate typedef struct rfs4_index rfs4_index_t; /* index */ 1027c478bd9Sstevel@tonic-gate typedef struct rfs4_database rfs4_database_t; /* and database */ 1037c478bd9Sstevel@tonic-gate 1047c478bd9Sstevel@tonic-gate typedef struct { /* opaque entry type for later use */ 1057c478bd9Sstevel@tonic-gate rfs4_dbe_t *dbe; 1067c478bd9Sstevel@tonic-gate } *rfs4_entry_t; 1077c478bd9Sstevel@tonic-gate 1087c478bd9Sstevel@tonic-gate extern rfs4_table_t *rfs4_client_tab; 1097c478bd9Sstevel@tonic-gate 1107c478bd9Sstevel@tonic-gate /* database, table, index creation entry points */ 1117c478bd9Sstevel@tonic-gate extern rfs4_database_t *rfs4_database_create(uint32_t); 1127c478bd9Sstevel@tonic-gate extern void rfs4_database_shutdown(rfs4_database_t *); 1137c478bd9Sstevel@tonic-gate extern void rfs4_database_destroy(rfs4_database_t *); 1147c478bd9Sstevel@tonic-gate 1157c478bd9Sstevel@tonic-gate extern void rfs4_database_destroy(rfs4_database_t *); 1167c478bd9Sstevel@tonic-gate 1177c478bd9Sstevel@tonic-gate extern rfs4_table_t *rfs4_table_create(rfs4_database_t *, char *, 1187c478bd9Sstevel@tonic-gate time_t, uint32_t, 1197c478bd9Sstevel@tonic-gate bool_t (*create)(rfs4_entry_t, void *), 1207c478bd9Sstevel@tonic-gate void (*destroy)(rfs4_entry_t), 1217c478bd9Sstevel@tonic-gate bool_t (*expiry)(rfs4_entry_t), 1227c478bd9Sstevel@tonic-gate uint32_t, uint32_t, uint32_t, id_t); 1237c478bd9Sstevel@tonic-gate extern void rfs4_table_destroy(rfs4_database_t *, rfs4_table_t *); 1247c478bd9Sstevel@tonic-gate extern rfs4_index_t *rfs4_index_create(rfs4_table_t *, char *, 1257c478bd9Sstevel@tonic-gate uint32_t (*hash)(void *), 1267c478bd9Sstevel@tonic-gate bool_t (compare)(rfs4_entry_t, void *), 1277c478bd9Sstevel@tonic-gate void *(*mkkey)(rfs4_entry_t), bool_t); 1287c478bd9Sstevel@tonic-gate extern void rfs4_index_destroy(rfs4_index_t *); 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate /* Type used to direct rfs4_dbsearch() in what types of records to inspect */ 1317c478bd9Sstevel@tonic-gate typedef enum {RFS4_DBS_VALID, RFS4_DBS_INVALID} rfs4_dbsearch_type_t; 1327c478bd9Sstevel@tonic-gate /* search and db entry manipulation entry points */ 1337c478bd9Sstevel@tonic-gate extern rfs4_entry_t rfs4_dbsearch(rfs4_index_t *, void *, 1347c478bd9Sstevel@tonic-gate bool_t *, void *, rfs4_dbsearch_type_t); 1357c478bd9Sstevel@tonic-gate extern void rfs4_dbe_lock(rfs4_dbe_t *); 1367c478bd9Sstevel@tonic-gate extern void rfs4_dbe_unlock(rfs4_dbe_t *); 1377c478bd9Sstevel@tonic-gate extern clock_t rfs4_dbe_twait(rfs4_dbe_t *, clock_t); 1387c478bd9Sstevel@tonic-gate extern void rfs4_dbe_cv_broadcast(rfs4_dbe_t *); 1397c478bd9Sstevel@tonic-gate extern void rfs4_dbe_hold(rfs4_dbe_t *); 1407c478bd9Sstevel@tonic-gate extern void rfs4_dbe_hold_nolock(rfs4_dbe_t *); 1417c478bd9Sstevel@tonic-gate extern void rfs4_dbe_rele_nolock(rfs4_dbe_t *); 1427c478bd9Sstevel@tonic-gate extern void rfs4_dbe_rele(rfs4_dbe_t *); 1437c478bd9Sstevel@tonic-gate extern uint32_t rfs4_dbe_refcnt(rfs4_dbe_t *); 1447c478bd9Sstevel@tonic-gate extern id_t rfs4_dbe_getid(rfs4_dbe_t *); 1457c478bd9Sstevel@tonic-gate extern void rfs4_dbe_invalidate(rfs4_dbe_t *); 1467c478bd9Sstevel@tonic-gate extern bool_t rfs4_dbe_is_invalid(rfs4_dbe_t *); 1477c478bd9Sstevel@tonic-gate extern time_t rfs4_dbe_get_timerele(rfs4_dbe_t *); 1487c478bd9Sstevel@tonic-gate extern void rfs4_dbe_hide(rfs4_dbe_t *); 1497c478bd9Sstevel@tonic-gate extern void rfs4_dbe_unhide(rfs4_dbe_t *); 1507c478bd9Sstevel@tonic-gate #ifdef DEBUG 1517c478bd9Sstevel@tonic-gate extern bool_t rfs4_dbe_islocked(rfs4_dbe_t *); 1527c478bd9Sstevel@tonic-gate #endif 1537c478bd9Sstevel@tonic-gate extern void rfs4_dbe_walk(rfs4_table_t *, 1547c478bd9Sstevel@tonic-gate void (*callout)(rfs4_entry_t, void *), void *); 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate /* 1577c478bd9Sstevel@tonic-gate * Minimal server stable storage. 1587c478bd9Sstevel@tonic-gate * 1597c478bd9Sstevel@tonic-gate * Currently the NFSv4 server will only save the client 1607c478bd9Sstevel@tonic-gate * ID (the long version) so that it will be able to 1617c478bd9Sstevel@tonic-gate * grant possible reclaim requests during the infamous 1627c478bd9Sstevel@tonic-gate * grace_period. 1637c478bd9Sstevel@tonic-gate */ 1647c478bd9Sstevel@tonic-gate 1657c478bd9Sstevel@tonic-gate #define RFS4_SS_DIRSIZE 64 * 1024 1667c478bd9Sstevel@tonic-gate #define NFS4_SS_VERSION 1 1677c478bd9Sstevel@tonic-gate 1687c478bd9Sstevel@tonic-gate /* handy pathname structure */ 1697c478bd9Sstevel@tonic-gate typedef struct ss_pn { 1707c478bd9Sstevel@tonic-gate char *leaf; 1717c478bd9Sstevel@tonic-gate char pn[MAXPATHLEN]; 1727c478bd9Sstevel@tonic-gate } rfs4_ss_pn_t; 1737c478bd9Sstevel@tonic-gate 1747c478bd9Sstevel@tonic-gate /* 1757c478bd9Sstevel@tonic-gate * The server will build this link list on startup. It represents the 1767c478bd9Sstevel@tonic-gate * clients that have had valid state on the server in a prior instance. 1777c478bd9Sstevel@tonic-gate * 1787c478bd9Sstevel@tonic-gate */ 1797c478bd9Sstevel@tonic-gate typedef struct rfs4_oldstate { 1807c478bd9Sstevel@tonic-gate struct rfs4_oldstate *next; 1817c478bd9Sstevel@tonic-gate struct rfs4_oldstate *prev; 1827c478bd9Sstevel@tonic-gate rfs4_ss_pn_t *ss_pn; 1837c478bd9Sstevel@tonic-gate nfs_client_id4 cl_id4; 1847c478bd9Sstevel@tonic-gate } rfs4_oldstate_t; 1857c478bd9Sstevel@tonic-gate 1867c478bd9Sstevel@tonic-gate /* 1877c478bd9Sstevel@tonic-gate * This union is used to overlay the server's internal treatment of 1887c478bd9Sstevel@tonic-gate * the protocols stateid4 datatype. Therefore, "bits" must not exceed 1897c478bd9Sstevel@tonic-gate * the size of stateid4 and more importantly should match the size of 1907c478bd9Sstevel@tonic-gate * stateid4. The chgseq field must the first entry since it overlays 1917c478bd9Sstevel@tonic-gate * stateid4.seqid. 1927c478bd9Sstevel@tonic-gate */ 1937c478bd9Sstevel@tonic-gate typedef union { 1947c478bd9Sstevel@tonic-gate stateid4 stateid; 1957c478bd9Sstevel@tonic-gate struct { 1967c478bd9Sstevel@tonic-gate uint32_t chgseq; /* State changes / protocol's seqid */ 1977c478bd9Sstevel@tonic-gate uint32_t boottime; /* boot time */ 1987c478bd9Sstevel@tonic-gate uint32_t type:2; /* stateid_type_t as define below */ 1997c478bd9Sstevel@tonic-gate uint32_t clnodeid:8; /* cluster server nodeid */ 2007c478bd9Sstevel@tonic-gate uint32_t ident:22; /* 2^22-1 openowner x fhs */ 2017c478bd9Sstevel@tonic-gate pid_t pid; /* pid of corresponding lock owner */ 2027c478bd9Sstevel@tonic-gate } bits; 2037c478bd9Sstevel@tonic-gate } stateid_t; 2047c478bd9Sstevel@tonic-gate /* 2057c478bd9Sstevel@tonic-gate * Note that the way the type field above is defined, this enum must 2067c478bd9Sstevel@tonic-gate * not have more than 4 members. 2077c478bd9Sstevel@tonic-gate */ 2087c478bd9Sstevel@tonic-gate typedef enum {OPENID, LOCKID, DELEGID} stateid_type_t; 2097c478bd9Sstevel@tonic-gate 2107c478bd9Sstevel@tonic-gate 2117c478bd9Sstevel@tonic-gate /* 2127c478bd9Sstevel@tonic-gate * Set of RPC credentials used for a particular operation. 2137c478bd9Sstevel@tonic-gate * Used for operations like SETCLIENTID_CONFIRM where the 2147c478bd9Sstevel@tonic-gate * credentials needs to match those used at SETCLIENTID. 2157c478bd9Sstevel@tonic-gate */ 2167c478bd9Sstevel@tonic-gate typedef void *cred_set_t; /* For now XXX */ 2177c478bd9Sstevel@tonic-gate 2187c478bd9Sstevel@tonic-gate /* 2197c478bd9Sstevel@tonic-gate * "wait" struct for use in the open open and lock owner state 2207c478bd9Sstevel@tonic-gate * structures to provide serialization between server threads that are 2217c478bd9Sstevel@tonic-gate * handling requests for the same open owner or lock stateid. This 2227c478bd9Sstevel@tonic-gate * way only one thread will be updating things like sequence ids, 2237c478bd9Sstevel@tonic-gate * replay cache and stateid at a time. 2247c478bd9Sstevel@tonic-gate */ 2257c478bd9Sstevel@tonic-gate typedef struct rfs4_state_wait { 2267c478bd9Sstevel@tonic-gate uint32_t sw_active; 2277c478bd9Sstevel@tonic-gate uint32_t sw_wait_count; 2287c478bd9Sstevel@tonic-gate kmutex_t sw_cv_lock[1]; 2297c478bd9Sstevel@tonic-gate kcondvar_t sw_cv[1]; 2307c478bd9Sstevel@tonic-gate } rfs4_state_wait_t; 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate extern void rfs4_sw_enter(rfs4_state_wait_t *); 2337c478bd9Sstevel@tonic-gate extern void rfs4_sw_exit(rfs4_state_wait_t *); 2347c478bd9Sstevel@tonic-gate 2357c478bd9Sstevel@tonic-gate /* 2367c478bd9Sstevel@tonic-gate * This enum and the following rfs4_cbinfo_t struct are used to 2377c478bd9Sstevel@tonic-gate * maintain information about the callback path used from the server 2387c478bd9Sstevel@tonic-gate * to client for operations like CB_GETATTR and CB_RECALL. The 2397c478bd9Sstevel@tonic-gate * rfs4_cbinfo_t struct is meant to be encompassed in the client 2407c478bd9Sstevel@tonic-gate * struct and managed within that structure's locking scheme. 2417c478bd9Sstevel@tonic-gate * 2427c478bd9Sstevel@tonic-gate * The various states of the callback path are used by the server to 2437c478bd9Sstevel@tonic-gate * determine if delegations should initially be provided to a client 2447c478bd9Sstevel@tonic-gate * and then later on if connectivity has been lost and delegations 2457c478bd9Sstevel@tonic-gate * should be revoked. 2467c478bd9Sstevel@tonic-gate */ 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate /* 2497c478bd9Sstevel@tonic-gate * CB_NOCHANGE - Special value used for interfaces within the delegation 2507c478bd9Sstevel@tonic-gate * code to signify that "no change" has occurred to the 2517c478bd9Sstevel@tonic-gate * callback path 2527c478bd9Sstevel@tonic-gate * CB_UNINIT - No callback info provided by the client 2537c478bd9Sstevel@tonic-gate * CB_NONE - Callback info provided but CB_NULL call 2547c478bd9Sstevel@tonic-gate * has yet to be attempted 2557c478bd9Sstevel@tonic-gate * CB_OK - Callback path tested with CB_NULL with success 2567c478bd9Sstevel@tonic-gate * CB_INPROG - Callback path currently being tested with CB_NULL 2577c478bd9Sstevel@tonic-gate * CB_FAILED - Callback path was == CB_OK but has failed 2587c478bd9Sstevel@tonic-gate * with timeout/rpc error 2597c478bd9Sstevel@tonic-gate * CB_BAD - Callback info provided but CB_NULL failed 2607c478bd9Sstevel@tonic-gate */ 2617c478bd9Sstevel@tonic-gate typedef enum { 2627c478bd9Sstevel@tonic-gate CB_NOCHANGE = 0, 2637c478bd9Sstevel@tonic-gate CB_UNINIT = 1, 2647c478bd9Sstevel@tonic-gate CB_NONE = 2, 2657c478bd9Sstevel@tonic-gate CB_OK = 3, 2667c478bd9Sstevel@tonic-gate CB_INPROG = 4, 2677c478bd9Sstevel@tonic-gate CB_FAILED = 5, 2687c478bd9Sstevel@tonic-gate CB_BAD = 6 2697c478bd9Sstevel@tonic-gate } rfs4_cbstate_t; 2707c478bd9Sstevel@tonic-gate 2717c478bd9Sstevel@tonic-gate #define RFS4_CBCH_MAX 10 /* size callback client handle cache */ 2727c478bd9Sstevel@tonic-gate /* 2737c478bd9Sstevel@tonic-gate * Callback info for a client. 2747c478bd9Sstevel@tonic-gate * Client only provides: cb_client4 and cb_ident 2757c478bd9Sstevel@tonic-gate * The rest of the information is used to track callback path status 2767c478bd9Sstevel@tonic-gate * and usage. 2777c478bd9Sstevel@tonic-gate * 2787c478bd9Sstevel@tonic-gate * cb_state - used as comments for the rfs4_cbstate_t enum indicate 2797c478bd9Sstevel@tonic-gate * cb_notified_of_cb_path_down - if the callback path was once CB_OK and 2807c478bd9Sstevel@tonic-gate * has hence CB_FAILED, the client needs to be notified via RENEW. 2817c478bd9Sstevel@tonic-gate * cb_timefailed - current time when cb_state transitioned from 2827c478bd9Sstevel@tonic-gate * CB_OK -> CB_FAILED. Meant for observability. When did that happen? 2837c478bd9Sstevel@tonic-gate * cb_chc_free/cb_chc - cache of client handles for the callback path 2847c478bd9Sstevel@tonic-gate * cb_ident - SETCLIENTID provided callback_ident value 2857c478bd9Sstevel@tonic-gate * callback - SETCLIENTID provided cb_client4 value 2867c478bd9Sstevel@tonic-gate * cb_refcnt - current number of users of this structure's content 2877c478bd9Sstevel@tonic-gate * protected by cb_lock 2887c478bd9Sstevel@tonic-gate * cb_badbehavior - how many times did a client do something we didn't like? 2897c478bd9Sstevel@tonic-gate * cb_lock - lock for contents of cbinfo 2907c478bd9Sstevel@tonic-gate * cb_cv - used to allow threads to wait on CB_NULL completion 2917c478bd9Sstevel@tonic-gate * cb_nullcaller - is there a thread currently taking care of 2927c478bd9Sstevel@tonic-gate * new callback information? 2937c478bd9Sstevel@tonic-gate * cb_cv_nullcaller - used by the thread doing CB_NULL to wait on 2947c478bd9Sstevel@tonic-gate * threads that may be using client handles of the current 2957c478bd9Sstevel@tonic-gate * client handle cache. 2967c478bd9Sstevel@tonic-gate * newer - new callback info provided by a client and awaiting 2977c478bd9Sstevel@tonic-gate * CB_NULL testing and move to regular cbinfo. 2987c478bd9Sstevel@tonic-gate */ 2997c478bd9Sstevel@tonic-gate typedef struct { 3007c478bd9Sstevel@tonic-gate rfs4_cbstate_t cb_state; 3017c478bd9Sstevel@tonic-gate unsigned cb_notified_of_cb_path_down:1; 3027c478bd9Sstevel@tonic-gate time_t cb_timefailed; 3037c478bd9Sstevel@tonic-gate int cb_chc_free; 3047c478bd9Sstevel@tonic-gate CLIENT *cb_chc[RFS4_CBCH_MAX]; 3057c478bd9Sstevel@tonic-gate uint32_t cb_ident; 3067c478bd9Sstevel@tonic-gate cb_client4 cb_callback; 3077c478bd9Sstevel@tonic-gate uint32_t cb_refcnt; 3087c478bd9Sstevel@tonic-gate uint32_t cb_badbehavior; 3097c478bd9Sstevel@tonic-gate kmutex_t cb_lock[1]; 3107c478bd9Sstevel@tonic-gate kcondvar_t cb_cv[1]; 3117c478bd9Sstevel@tonic-gate bool_t cb_nullcaller; 3127c478bd9Sstevel@tonic-gate kcondvar_t cb_cv_nullcaller[1]; 3137c478bd9Sstevel@tonic-gate struct { 3147c478bd9Sstevel@tonic-gate bool_t cb_new; 3157c478bd9Sstevel@tonic-gate bool_t cb_confirmed; 3167c478bd9Sstevel@tonic-gate uint32_t cb_ident; 3177c478bd9Sstevel@tonic-gate cb_client4 cb_callback; 3187c478bd9Sstevel@tonic-gate } cb_newer; 3197c478bd9Sstevel@tonic-gate } rfs4_cbinfo_t; 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate /* 3227c478bd9Sstevel@tonic-gate * A server instance. We can associate sets of clients - via a pointer in 3237c478bd9Sstevel@tonic-gate * rfs4_client_t - with a given server instance, allowing us to treat clients 3247c478bd9Sstevel@tonic-gate * in the set differently to clients in other sets. 3257c478bd9Sstevel@tonic-gate * 3267c478bd9Sstevel@tonic-gate * Currently used only for Sun Cluster HA-NFS support, to group clients 3277c478bd9Sstevel@tonic-gate * on NFS resource failover so each set of clients gets its own dedicated 3287c478bd9Sstevel@tonic-gate * grace period. 3297c478bd9Sstevel@tonic-gate */ 3307c478bd9Sstevel@tonic-gate typedef struct rfs4_servinst { 3317c478bd9Sstevel@tonic-gate krwlock_t rwlock; 3327c478bd9Sstevel@tonic-gate time_t start_time; 3337c478bd9Sstevel@tonic-gate time_t grace_period; 3347c478bd9Sstevel@tonic-gate struct rfs4_servinst *next; 3357c478bd9Sstevel@tonic-gate struct rfs4_servinst *prev; 3367c478bd9Sstevel@tonic-gate } rfs4_servinst_t; 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate /* 3397c478bd9Sstevel@tonic-gate * List declarations (suitable for insque/remque) used to link the 3407c478bd9Sstevel@tonic-gate * various datastructs listed below. 3417c478bd9Sstevel@tonic-gate */ 3427c478bd9Sstevel@tonic-gate typedef struct rfs4_state_list { 3437c478bd9Sstevel@tonic-gate struct rfs4_state_list *next; 3447c478bd9Sstevel@tonic-gate struct rfs4_state_list *prev; 3457c478bd9Sstevel@tonic-gate struct rfs4_state *sp; 3467c478bd9Sstevel@tonic-gate } rfs4_state_list_t; 3477c478bd9Sstevel@tonic-gate 3487c478bd9Sstevel@tonic-gate typedef struct rfs4_lo_state_list { 3497c478bd9Sstevel@tonic-gate struct rfs4_lo_state_list *next; 3507c478bd9Sstevel@tonic-gate struct rfs4_lo_state_list *prev; 3517c478bd9Sstevel@tonic-gate struct rfs4_lo_state *lsp; 3527c478bd9Sstevel@tonic-gate } rfs4_lo_state_list_t; 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate typedef struct rfs4_openowner_list { 3557c478bd9Sstevel@tonic-gate struct rfs4_openowner_list *next; 3567c478bd9Sstevel@tonic-gate struct rfs4_openowner_list *prev; 3577c478bd9Sstevel@tonic-gate struct rfs4_openowner *oop; 3587c478bd9Sstevel@tonic-gate } rfs4_openowner_list_t; 3597c478bd9Sstevel@tonic-gate 3607c478bd9Sstevel@tonic-gate typedef struct rfs4_deleg_list { 3617c478bd9Sstevel@tonic-gate struct rfs4_deleg_list *next; 3627c478bd9Sstevel@tonic-gate struct rfs4_deleg_list *prev; 3637c478bd9Sstevel@tonic-gate struct rfs4_deleg_state *dsp; 3647c478bd9Sstevel@tonic-gate } rfs4_deleg_list_t; 3657c478bd9Sstevel@tonic-gate 3667c478bd9Sstevel@tonic-gate /* 3677c478bd9Sstevel@tonic-gate * The server maintains a set of state on a per client basis that 3687c478bd9Sstevel@tonic-gate * matches that of the protocol requirements. A client's state is 3697c478bd9Sstevel@tonic-gate * rooted with the rfs4_client_t struct of which there is one per 3707c478bd9Sstevel@tonic-gate * client and is created when SETCLIENTID/SETCLIENTID_CONFIRM are 3717c478bd9Sstevel@tonic-gate * received. From there, the server then creates rfs4_openowner_t 3727c478bd9Sstevel@tonic-gate * structs for each new open owner from that client and are initiated 3737c478bd9Sstevel@tonic-gate * at OPEN/OPEN_CONFIRM (when the open owner is new to the server). 3747c478bd9Sstevel@tonic-gate * At OPEN, at least two other structures are created, and potentially a 3757c478bd9Sstevel@tonic-gate * third. rfs4_state_t is created to track the association between an 3767c478bd9Sstevel@tonic-gate * open owner and a particular file. An rfs4_file_t struct may be 3777c478bd9Sstevel@tonic-gate * created (if the file is not already open) at OPEN as well. The 3787c478bd9Sstevel@tonic-gate * rfs4_file_t struct is the only one that is per server and not per 3797c478bd9Sstevel@tonic-gate * client. The rfs4_deleg_state_t struct is created in the 3807c478bd9Sstevel@tonic-gate * instance that the server is going to provide a delegation for the 3817c478bd9Sstevel@tonic-gate * file being OPENed. Finally, the rfs4_lockowner_t is created at the 3827c478bd9Sstevel@tonic-gate * first use of a lock owner at the server and is a result of the LOCK 3837c478bd9Sstevel@tonic-gate * operation. The rfs4_lo_state_t struct is then created to represent 3847c478bd9Sstevel@tonic-gate * the relation between the lock owner and the file. 3857c478bd9Sstevel@tonic-gate * 3867c478bd9Sstevel@tonic-gate */ 3877c478bd9Sstevel@tonic-gate /* 3887c478bd9Sstevel@tonic-gate * The following ascii art represents each of these data structs and 3897c478bd9Sstevel@tonic-gate * their references to each other. Note: "<-(x)->" represents the 3907c478bd9Sstevel@tonic-gate * doubly link lists defined above. 3917c478bd9Sstevel@tonic-gate * 3927c478bd9Sstevel@tonic-gate * ____________________ 3937c478bd9Sstevel@tonic-gate * | | 3947c478bd9Sstevel@tonic-gate * | rfs4_client_t | 3957c478bd9Sstevel@tonic-gate * ->| (1),(2) |<- 3967c478bd9Sstevel@tonic-gate * / |____________________| \ 3977c478bd9Sstevel@tonic-gate * / ^ \ 3987c478bd9Sstevel@tonic-gate * / | \ 3997c478bd9Sstevel@tonic-gate * ____________________ ____________________ ____________________ 4007c478bd9Sstevel@tonic-gate * | | | | | | 4017c478bd9Sstevel@tonic-gate * | rfs4_lockowner_t | | rfs4_openowner_t | | rfs4_deleg_state_t | 4027c478bd9Sstevel@tonic-gate * | | | (3) <-(1)-> | | <-(2)-> | 4037c478bd9Sstevel@tonic-gate * |____________________| |____________________| |____________________| 4047c478bd9Sstevel@tonic-gate * ^ ^ | 4057c478bd9Sstevel@tonic-gate * | | V 4067c478bd9Sstevel@tonic-gate * ____________________ ____________________ ____________________ 4077c478bd9Sstevel@tonic-gate * | | | | | | 4087c478bd9Sstevel@tonic-gate * | rfs4_lo_state_t |->| rfs4_state_t |->| rfs4_file_t | 4097c478bd9Sstevel@tonic-gate * | <-(4)-> | | (4) <-(3)-> | | | 4107c478bd9Sstevel@tonic-gate * |____________________| |____________________| |____________________| 4117c478bd9Sstevel@tonic-gate */ 4127c478bd9Sstevel@tonic-gate /* 4137c478bd9Sstevel@tonic-gate * Each of these data types are kept in a separate rfs4_table_t and is 4147c478bd9Sstevel@tonic-gate * actually encapsulated within a rfs4_dbe_t struct. The various 4157c478bd9Sstevel@tonic-gate * tables and their construction is done in nfs4_state.c but 4167c478bd9Sstevel@tonic-gate * documented here to completeness. 4177c478bd9Sstevel@tonic-gate * 4187c478bd9Sstevel@tonic-gate * Table Data struct stored Indexed by 4197c478bd9Sstevel@tonic-gate * ----- ------------------ ---------- 4207c478bd9Sstevel@tonic-gate * rfs4_client_tab rfs4_client_t nfs_client_id4 4217c478bd9Sstevel@tonic-gate * clientid4 4227c478bd9Sstevel@tonic-gate * 4237c478bd9Sstevel@tonic-gate * rfs4_openowner_tab rfs4_openowner_t open_owner4 4247c478bd9Sstevel@tonic-gate * 4257c478bd9Sstevel@tonic-gate * rfs4_state_tab rfs4_state_t open_owner4 | file 4267c478bd9Sstevel@tonic-gate * stateid 4277c478bd9Sstevel@tonic-gate * 4287c478bd9Sstevel@tonic-gate * rfs4_lo_state_tab rfs4_lo_state_t lockowner | stateid 4297c478bd9Sstevel@tonic-gate * lock_stateid 4307c478bd9Sstevel@tonic-gate * 4317c478bd9Sstevel@tonic-gate * rfs4_lockowner_tab rfs4_lockowner_t lockowner 4327c478bd9Sstevel@tonic-gate * pid 4337c478bd9Sstevel@tonic-gate * 4347c478bd9Sstevel@tonic-gate * rfs4_file_tab rfs4_file_t filehandle 4357c478bd9Sstevel@tonic-gate * 4367c478bd9Sstevel@tonic-gate * rfs4_deleg_state_tab rfs4_deleg_state_t clientid4 | file 4377c478bd9Sstevel@tonic-gate * deleg_stateid 4387c478bd9Sstevel@tonic-gate */ 4397c478bd9Sstevel@tonic-gate 4407c478bd9Sstevel@tonic-gate /* 4417c478bd9Sstevel@tonic-gate * The client struct, it is the root of all state for a particular 4427c478bd9Sstevel@tonic-gate * client. The client is identified by the nfs_client_id4 via 4437c478bd9Sstevel@tonic-gate * SETCLIENTID and the server returns the clientid4 as short hand reference 4447c478bd9Sstevel@tonic-gate */ 4457c478bd9Sstevel@tonic-gate /* 4467c478bd9Sstevel@tonic-gate * Client struct - as mentioned above it is the root of all state for 4477c478bd9Sstevel@tonic-gate * a single client as identified by the client supplied nfs_client_id4 4487c478bd9Sstevel@tonic-gate * 4497c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 4507c478bd9Sstevel@tonic-gate * clientid - server assigned short hand reference to client 4517c478bd9Sstevel@tonic-gate * nfs_client - client supplied identifier for itself 4527c478bd9Sstevel@tonic-gate * confirm_verf - the value provided to the client for SETCLIENTID_CONFIRM 4537c478bd9Sstevel@tonic-gate * need_confirm - does this client need to be SETCLIENTID_CONFIRMed? 4547c478bd9Sstevel@tonic-gate * 4557c478bd9Sstevel@tonic-gate * unlksys_completed - has an F_UNLKSYS been done for this client which 4567c478bd9Sstevel@tonic-gate * says that the use of cleanlocks() on individual files 4577c478bd9Sstevel@tonic-gate * is not required? 4587c478bd9Sstevel@tonic-gate * can_reclaim - indicates if client is allowed to reclaim after server 4597c478bd9Sstevel@tonic-gate * start-up (client had previous state at server) 4607c478bd9Sstevel@tonic-gate * ss_remove - indicates that the rfs4_client_destroy function should 4617c478bd9Sstevel@tonic-gate * clean up stable storage file. 4627c478bd9Sstevel@tonic-gate * forced_expire - set if the sysadmin has used clear_locks for this client. 4637c478bd9Sstevel@tonic-gate * deleg_revoked - how many delegations have been revoked for this client? 4647c478bd9Sstevel@tonic-gate * 4657c478bd9Sstevel@tonic-gate * cp_confirmed - this refers to a confirmed client struct that has 4667c478bd9Sstevel@tonic-gate * the same nfs_client_id4 as this client struct. When/if this client 4677c478bd9Sstevel@tonic-gate * struct is confirmed via SETCLINETID_CONFIRM, the previously 4687c478bd9Sstevel@tonic-gate * confirmed client struct will be "closed" and hence this reference. 4697c478bd9Sstevel@tonic-gate * 4707c478bd9Sstevel@tonic-gate * last_access - used to determine if the client has let its lease expire 4717c478bd9Sstevel@tonic-gate * cbinfo - struct containing all callback related information 4727c478bd9Sstevel@tonic-gate * cr_set - credentials used for the SETCLIENTID/SETCLIENTID_CONFIRM pair 4737c478bd9Sstevel@tonic-gate * sysid - the lock manager sysid allocated for this client's file locks 4747c478bd9Sstevel@tonic-gate * openownerlist - root of openowners list associated with this client 4757c478bd9Sstevel@tonic-gate * clientdeleglist - root of delegations list provided to this client 4767c478bd9Sstevel@tonic-gate * ss_pn - Pathname to the stable storage file. 4777c478bd9Sstevel@tonic-gate * cl_addr - Clients network address. 4787c478bd9Sstevel@tonic-gate * server_instance - pointer to the currently associated server instance 4797c478bd9Sstevel@tonic-gate */ 4807c478bd9Sstevel@tonic-gate typedef struct rfs4_client { 4817c478bd9Sstevel@tonic-gate rfs4_dbe_t *dbe; 4827c478bd9Sstevel@tonic-gate clientid4 clientid; 4837c478bd9Sstevel@tonic-gate nfs_client_id4 nfs_client; 4847c478bd9Sstevel@tonic-gate verifier4 confirm_verf; 4857c478bd9Sstevel@tonic-gate unsigned need_confirm:1; 4867c478bd9Sstevel@tonic-gate unsigned unlksys_completed:1; 4877c478bd9Sstevel@tonic-gate unsigned can_reclaim:1; 4887c478bd9Sstevel@tonic-gate unsigned ss_remove:1; 4897c478bd9Sstevel@tonic-gate unsigned forced_expire:1; 4907c478bd9Sstevel@tonic-gate uint_t deleg_revoked; 4917c478bd9Sstevel@tonic-gate struct rfs4_client *cp_confirmed; 4927c478bd9Sstevel@tonic-gate time_t last_access; 4937c478bd9Sstevel@tonic-gate rfs4_cbinfo_t cbinfo; 4947c478bd9Sstevel@tonic-gate cred_set_t cr_set; 4957c478bd9Sstevel@tonic-gate sysid_t sysidt; 4967c478bd9Sstevel@tonic-gate rfs4_openowner_list_t openownerlist; 4977c478bd9Sstevel@tonic-gate rfs4_deleg_list_t clientdeleglist; 4987c478bd9Sstevel@tonic-gate rfs4_ss_pn_t *ss_pn; 4997c478bd9Sstevel@tonic-gate struct sockaddr_storage cl_addr; 5007c478bd9Sstevel@tonic-gate rfs4_servinst_t *server_instance; 5017c478bd9Sstevel@tonic-gate } rfs4_client_t; 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate /* 5047c478bd9Sstevel@tonic-gate * The openowner contains the client supplied open_owner4 as well as 5057c478bd9Sstevel@tonic-gate * the matching sequence id and is used to track the client's usage of 5067c478bd9Sstevel@tonic-gate * the open_owner4. Note that a reply is saved here as well for 5077c478bd9Sstevel@tonic-gate * processing of retransmissions. 5087c478bd9Sstevel@tonic-gate * 5097c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 5107c478bd9Sstevel@tonic-gate * client - reference to rfs4_client_t for this openowner 5117c478bd9Sstevel@tonic-gate * owner - actual client supplied open_owner4 5127c478bd9Sstevel@tonic-gate * need_confirm - does this openowner need to be OPEN_CONFIRMed 5137c478bd9Sstevel@tonic-gate * postpone_confirm - set if error received on first use of open_owner 5147c478bd9Sstevel@tonic-gate * state2confirm - what stateid4 should be used on the OPEN_CONFIRM 5157c478bd9Sstevel@tonic-gate * open_seqid - what is the next open_seqid expected for this openowner 5167c478bd9Sstevel@tonic-gate * oo_sw - used to serialize access to the open seqid/reply handling 5177c478bd9Sstevel@tonic-gate * cr_set - credential used for the OPEN 5187c478bd9Sstevel@tonic-gate * ownerstateids - root of state struct list associated with this openowner 5197c478bd9Sstevel@tonic-gate * openownerlist - list of openowners for a client struct 5207c478bd9Sstevel@tonic-gate * reply_fh - open replay processing needs the filehandle so that it is 5217c478bd9Sstevel@tonic-gate * able to reset the current filehandle for appropriate compound 5227c478bd9Sstevel@tonic-gate * processing and reply. 5237c478bd9Sstevel@tonic-gate * reply - last reply sent in relation to this openowner 5247c478bd9Sstevel@tonic-gate */ 5257c478bd9Sstevel@tonic-gate typedef struct rfs4_openowner { 5267c478bd9Sstevel@tonic-gate rfs4_dbe_t *dbe; 5277c478bd9Sstevel@tonic-gate rfs4_client_t *client; 5287c478bd9Sstevel@tonic-gate open_owner4 owner; 5297c478bd9Sstevel@tonic-gate unsigned need_confirm:1; 5307c478bd9Sstevel@tonic-gate unsigned postpone_confirm:1; 5317c478bd9Sstevel@tonic-gate seqid4 open_seqid; 5327c478bd9Sstevel@tonic-gate rfs4_state_wait_t oo_sw; 5337c478bd9Sstevel@tonic-gate cred_set_t cr_set; 5347c478bd9Sstevel@tonic-gate rfs4_state_list_t ownerstateids; 5357c478bd9Sstevel@tonic-gate rfs4_openowner_list_t openownerlist; 5367c478bd9Sstevel@tonic-gate nfs_fh4 reply_fh; 5377c478bd9Sstevel@tonic-gate nfs_resop4 reply[1]; 5387c478bd9Sstevel@tonic-gate } rfs4_openowner_t; 5397c478bd9Sstevel@tonic-gate 5407c478bd9Sstevel@tonic-gate /* 5417c478bd9Sstevel@tonic-gate * This state struct represents the association between an openowner 5427c478bd9Sstevel@tonic-gate * and a file that has been OPENed by that openowner. 5437c478bd9Sstevel@tonic-gate * 5447c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 5457c478bd9Sstevel@tonic-gate * stateid - server provided stateid 5467c478bd9Sstevel@tonic-gate * owner - reference back to the openowner for this state 5477c478bd9Sstevel@tonic-gate * finfo - reference to the open file for this state 5487c478bd9Sstevel@tonic-gate * share_access - how did the openowner OPEN the file (access) 5497c478bd9Sstevel@tonic-gate * share_deny - how did the openowner OPEN the file (deny) 5507c478bd9Sstevel@tonic-gate * closed - has this file been closed? 5517c478bd9Sstevel@tonic-gate * lockownerlist - root of list of lockowners associated with this state/file 5527c478bd9Sstevel@tonic-gate * ownerstateids - list of state structs for an openowner 5537c478bd9Sstevel@tonic-gate */ 5547c478bd9Sstevel@tonic-gate typedef struct rfs4_state { 5557c478bd9Sstevel@tonic-gate rfs4_dbe_t *dbe; 5567c478bd9Sstevel@tonic-gate stateid_t stateid; 5577c478bd9Sstevel@tonic-gate rfs4_openowner_t *owner; 5587c478bd9Sstevel@tonic-gate struct rfs4_file *finfo; 5597c478bd9Sstevel@tonic-gate uint32_t share_access; 5607c478bd9Sstevel@tonic-gate uint32_t share_deny; 5617c478bd9Sstevel@tonic-gate unsigned closed:1; 5627c478bd9Sstevel@tonic-gate rfs4_lo_state_list_t lockownerlist; 5637c478bd9Sstevel@tonic-gate rfs4_state_list_t ownerstateids; 5647c478bd9Sstevel@tonic-gate } rfs4_state_t; 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate /* 5677c478bd9Sstevel@tonic-gate * Lockowner - track the lockowner and its related info 5687c478bd9Sstevel@tonic-gate * 5697c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 5707c478bd9Sstevel@tonic-gate * client - reference to the client 5717c478bd9Sstevel@tonic-gate * owner - lockowner supplied by the client 5727c478bd9Sstevel@tonic-gate * pid - local identifier used for file locking 5737c478bd9Sstevel@tonic-gate */ 5747c478bd9Sstevel@tonic-gate typedef struct rfs4_lockowner { 5757c478bd9Sstevel@tonic-gate rfs4_dbe_t *dbe; 5767c478bd9Sstevel@tonic-gate rfs4_client_t *client; 5777c478bd9Sstevel@tonic-gate lock_owner4 owner; 5787c478bd9Sstevel@tonic-gate pid_t pid; 5797c478bd9Sstevel@tonic-gate } rfs4_lockowner_t; 5807c478bd9Sstevel@tonic-gate 5817c478bd9Sstevel@tonic-gate /* 5827c478bd9Sstevel@tonic-gate * Lockowner_state associated with a state struct and lockowner 5837c478bd9Sstevel@tonic-gate * 5847c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 5857c478bd9Sstevel@tonic-gate * state - reference back to state struct for open file 5867c478bd9Sstevel@tonic-gate * lockid - stateid for this lockowner/state 5877c478bd9Sstevel@tonic-gate * locker - reference to lockowner 5887c478bd9Sstevel@tonic-gate * seqid - sequence id for this lockowner/state 5897c478bd9Sstevel@tonic-gate * skip_seqid_check - used on initialization of struct 5907c478bd9Sstevel@tonic-gate * locks_cleaned - have all locks been released for this lockowner/file? 5917c478bd9Sstevel@tonic-gate * lock_completed - successful LOCK with lockowner/file? 5927c478bd9Sstevel@tonic-gate * ls_sw - used to serialize update seqid/reply/stateid handling 5937c478bd9Sstevel@tonic-gate * lockownerlist - list of lockowners for a state struct 5947c478bd9Sstevel@tonic-gate * reply - last reply sent in relation to this lockowner/state 5957c478bd9Sstevel@tonic-gate */ 5967c478bd9Sstevel@tonic-gate typedef struct rfs4_lo_state { 5977c478bd9Sstevel@tonic-gate rfs4_dbe_t *dbe; 5987c478bd9Sstevel@tonic-gate rfs4_state_t *state; 5997c478bd9Sstevel@tonic-gate stateid_t lockid; 6007c478bd9Sstevel@tonic-gate rfs4_lockowner_t *locker; 6017c478bd9Sstevel@tonic-gate seqid4 seqid; 6027c478bd9Sstevel@tonic-gate unsigned skip_seqid_check:1; 6037c478bd9Sstevel@tonic-gate unsigned locks_cleaned:1; 6047c478bd9Sstevel@tonic-gate unsigned lock_completed:1; 6057c478bd9Sstevel@tonic-gate rfs4_state_wait_t ls_sw; 6067c478bd9Sstevel@tonic-gate rfs4_lo_state_list_t lockownerlist; 6077c478bd9Sstevel@tonic-gate nfs_resop4 reply[1]; 6087c478bd9Sstevel@tonic-gate } rfs4_lo_state_t; 6097c478bd9Sstevel@tonic-gate 6107c478bd9Sstevel@tonic-gate /* 6117c478bd9Sstevel@tonic-gate * Delegation state - per client 6127c478bd9Sstevel@tonic-gate * 6137c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 6147c478bd9Sstevel@tonic-gate * dtype - type of delegation (NONE, READ, WRITE) 6157c478bd9Sstevel@tonic-gate * delegid - stateid for this delegation 6167c478bd9Sstevel@tonic-gate * time_granted - time this delegation was assigned to client 6177c478bd9Sstevel@tonic-gate * time_recalled - time when the server started recall process 6187c478bd9Sstevel@tonic-gate * time_revoked - if revoked, time that the revoke occurred 6197c478bd9Sstevel@tonic-gate * finfo - reference to the file associated with this delegation 6207c478bd9Sstevel@tonic-gate * client - reference to client for which this delegation is associated 6217c478bd9Sstevel@tonic-gate * delegationlist - list of delegations for the file (WRITE == 1, READ == ) 6227c478bd9Sstevel@tonic-gate * clientdeleglist - list of delegations for the client 6237c478bd9Sstevel@tonic-gate */ 6247c478bd9Sstevel@tonic-gate typedef struct rfs4_deleg_state { 6257c478bd9Sstevel@tonic-gate rfs4_dbe_t *dbe; 6267c478bd9Sstevel@tonic-gate open_delegation_type4 dtype; 6277c478bd9Sstevel@tonic-gate stateid_t delegid; 6287c478bd9Sstevel@tonic-gate time_t time_granted; 6297c478bd9Sstevel@tonic-gate time_t time_recalled; 6307c478bd9Sstevel@tonic-gate time_t time_revoked; 6317c478bd9Sstevel@tonic-gate struct rfs4_file *finfo; 6327c478bd9Sstevel@tonic-gate rfs4_client_t *client; 6337c478bd9Sstevel@tonic-gate rfs4_deleg_list_t delegationlist; 6347c478bd9Sstevel@tonic-gate rfs4_deleg_list_t clientdeleglist; 6357c478bd9Sstevel@tonic-gate } rfs4_deleg_state_t; 6367c478bd9Sstevel@tonic-gate 6377c478bd9Sstevel@tonic-gate /* 6387c478bd9Sstevel@tonic-gate * Delegation info associated with the file 6397c478bd9Sstevel@tonic-gate * 6407c478bd9Sstevel@tonic-gate * dtype - type of delegation for file (NONE, READ, WRITE) 6417c478bd9Sstevel@tonic-gate * time_returned - time that last delegation was returned for file 6427c478bd9Sstevel@tonic-gate * time_recalled - time that recall sequence started 6437c478bd9Sstevel@tonic-gate * time_lastgrant - time that last delegation was provided to a client 6447c478bd9Sstevel@tonic-gate * time_lastwrite - time of last write to use the delegation stateid 6457c478bd9Sstevel@tonic-gate * time_rm_delayed - time of last remove/rename which was DELAYed 6467c478bd9Sstevel@tonic-gate * rdgrants - how many read delegations have been provided for this file 6477c478bd9Sstevel@tonic-gate * wrgrants - how many write delegations provided (can only be one) 6487c478bd9Sstevel@tonic-gate * recall_count - how many recall threads are outstanding 6497c478bd9Sstevel@tonic-gate * recall_lock - lock to protect contents of this struct 6507c478bd9Sstevel@tonic-gate * recall_cv - condition var for the "parent" thread to wait upon 6517c478bd9Sstevel@tonic-gate * deleg_change_grant - value for change attribute at time of write grant 6527c478bd9Sstevel@tonic-gate * deleg_change - most recent value of change obtained from client 6537c478bd9Sstevel@tonic-gate * deleg_change_ts - time of last deleg_change update 6547c478bd9Sstevel@tonic-gate * ever_recalled - has this particular delegation ever been recalled? 6557c478bd9Sstevel@tonic-gate * dont_grant - file deletion is impending, don't grant a delegation 6567c478bd9Sstevel@tonic-gate * conflicted_client - clientid of the client that caused a CB_RECALL 6577c478bd9Sstevel@tonic-gate * to occur. This is used for delegation policy (should a delegation 6587c478bd9Sstevel@tonic-gate * be granted shortly after it has been returned?) 6597c478bd9Sstevel@tonic-gate */ 6607c478bd9Sstevel@tonic-gate typedef struct rfs4_dinfo { 6617c478bd9Sstevel@tonic-gate open_delegation_type4 dtype; 6627c478bd9Sstevel@tonic-gate time_t time_returned; 6637c478bd9Sstevel@tonic-gate time_t time_recalled; 6647c478bd9Sstevel@tonic-gate time_t time_lastgrant; 6657c478bd9Sstevel@tonic-gate time_t time_lastwrite; 6667c478bd9Sstevel@tonic-gate time_t time_rm_delayed; 6677c478bd9Sstevel@tonic-gate uint32_t rdgrants; 6687c478bd9Sstevel@tonic-gate uint32_t wrgrants; 6697c478bd9Sstevel@tonic-gate int32_t recall_count; 6707c478bd9Sstevel@tonic-gate kmutex_t recall_lock[1]; 6717c478bd9Sstevel@tonic-gate kcondvar_t recall_cv[1]; 6727c478bd9Sstevel@tonic-gate bool_t ever_recalled; 6737c478bd9Sstevel@tonic-gate uint32_t hold_grant; 6747c478bd9Sstevel@tonic-gate clientid4 conflicted_client; 6757c478bd9Sstevel@tonic-gate } rfs4_dinfo_t; 6767c478bd9Sstevel@tonic-gate 6777c478bd9Sstevel@tonic-gate /* 6787c478bd9Sstevel@tonic-gate * File 6797c478bd9Sstevel@tonic-gate * 6807c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 6817c478bd9Sstevel@tonic-gate * vp - vnode for the file that is open or has a delegation 6827c478bd9Sstevel@tonic-gate * filehandle - the filehandle generated by the server for this file 6837c478bd9Sstevel@tonic-gate * delegationlist - root of delegation list for this file 6847c478bd9Sstevel@tonic-gate * dinfo - see struct definition above 6857c478bd9Sstevel@tonic-gate * share_deny - union of all deny modes on file 6867c478bd9Sstevel@tonic-gate * share_access - union of all access modes on file 6877c478bd9Sstevel@tonic-gate * access_read - count of read access 6887c478bd9Sstevel@tonic-gate * access_write - count of write access 6897c478bd9Sstevel@tonic-gate * deny_read - count of deny reads 6907c478bd9Sstevel@tonic-gate * deny_write - count of deny writes 6917c478bd9Sstevel@tonic-gate * file_rwlock - lock for serializing the removal of a file while 6927c478bd9Sstevel@tonic-gate * the state structures are active within the server 6937c478bd9Sstevel@tonic-gate * 6947c478bd9Sstevel@tonic-gate * The only requirement for locking file_rwlock is that the 6957c478bd9Sstevel@tonic-gate * caller have a reference to the containing rfs4_file. The dbe 6967c478bd9Sstevel@tonic-gate * lock may or may not be held for lock/unlock of file_rwlock. 6977c478bd9Sstevel@tonic-gate * As mentioned above, the file_rwlock is used for serialization 6987c478bd9Sstevel@tonic-gate * of file removal and more specifically reference to the held 6997c478bd9Sstevel@tonic-gate * vnode (e.g. vp). 7007c478bd9Sstevel@tonic-gate */ 7017c478bd9Sstevel@tonic-gate typedef struct rfs4_file { 7027c478bd9Sstevel@tonic-gate rfs4_dbe_t *dbe; 7037c478bd9Sstevel@tonic-gate vnode_t *vp; 7047c478bd9Sstevel@tonic-gate nfs_fh4 filehandle; 7057c478bd9Sstevel@tonic-gate rfs4_deleg_list_t delegationlist; 7067c478bd9Sstevel@tonic-gate rfs4_dinfo_t dinfo[1]; 7077c478bd9Sstevel@tonic-gate uint32_t share_deny; 7087c478bd9Sstevel@tonic-gate uint32_t share_access; 7097c478bd9Sstevel@tonic-gate uint32_t access_read; 7107c478bd9Sstevel@tonic-gate uint32_t access_write; 7117c478bd9Sstevel@tonic-gate uint32_t deny_read; 7127c478bd9Sstevel@tonic-gate uint32_t deny_write; 7137c478bd9Sstevel@tonic-gate krwlock_t file_rwlock; 7147c478bd9Sstevel@tonic-gate } rfs4_file_t; 7157c478bd9Sstevel@tonic-gate 7167c478bd9Sstevel@tonic-gate extern int rfs4_servinst_debug; 7177c478bd9Sstevel@tonic-gate extern int rfs4_seen_first_compound; /* set first time we see one */ 7187c478bd9Sstevel@tonic-gate 7197c478bd9Sstevel@tonic-gate extern rfs4_servinst_t *rfs4_cur_servinst; /* current server instance */ 7207c478bd9Sstevel@tonic-gate extern kmutex_t rfs4_servinst_lock; /* protects linked list */ 7217c478bd9Sstevel@tonic-gate extern void rfs4_servinst_create(int); 7227c478bd9Sstevel@tonic-gate extern void rfs4_servinst_destroy_all(void); 7237c478bd9Sstevel@tonic-gate extern void rfs4_servinst_assign(rfs4_client_t *, 7247c478bd9Sstevel@tonic-gate rfs4_servinst_t *); 7257c478bd9Sstevel@tonic-gate extern rfs4_servinst_t *rfs4_servinst(rfs4_client_t *); 7267c478bd9Sstevel@tonic-gate extern int rfs4_clnt_in_grace(rfs4_client_t *); 7277c478bd9Sstevel@tonic-gate extern int rfs4_servinst_in_grace(rfs4_servinst_t *); 7287c478bd9Sstevel@tonic-gate extern int rfs4_servinst_grace_new(rfs4_servinst_t *); 7297c478bd9Sstevel@tonic-gate extern void rfs4_grace_start(rfs4_servinst_t *); 7307c478bd9Sstevel@tonic-gate extern void rfs4_grace_start_new(void); 7317c478bd9Sstevel@tonic-gate extern void rfs4_grace_reset_all(void); 7327c478bd9Sstevel@tonic-gate 7337c478bd9Sstevel@tonic-gate /* 7347c478bd9Sstevel@tonic-gate * rfs4_deleg_policy is used to signify the server's global delegation 7357c478bd9Sstevel@tonic-gate * policy. The default is to NEVER delegate files and the 7367c478bd9Sstevel@tonic-gate * administrator must configure the server to enable delegations. 7377c478bd9Sstevel@tonic-gate * 7387c478bd9Sstevel@tonic-gate * The disable/enable delegation functions are used to eliminate a 7397c478bd9Sstevel@tonic-gate * race with exclusive creates. 7407c478bd9Sstevel@tonic-gate */ 7417c478bd9Sstevel@tonic-gate typedef enum { 7427c478bd9Sstevel@tonic-gate SRV_NEVER_DELEGATE = 0, 7437c478bd9Sstevel@tonic-gate SRV_NORMAL_DELEGATE = 1 7447c478bd9Sstevel@tonic-gate } srv_deleg_policy_t; 7457c478bd9Sstevel@tonic-gate 7467c478bd9Sstevel@tonic-gate extern srv_deleg_policy_t rfs4_deleg_policy; 7477c478bd9Sstevel@tonic-gate extern kmutex_t rfs4_deleg_lock; 7487c478bd9Sstevel@tonic-gate extern void rfs4_disable_delegation(void), rfs4_enable_delegation(void); 7497c478bd9Sstevel@tonic-gate 7507c478bd9Sstevel@tonic-gate /* 7517c478bd9Sstevel@tonic-gate * Request types for delegation. These correspond with 7527c478bd9Sstevel@tonic-gate * open_delegation_type4 with the addition of a new value, DELEG_ANY, 7537c478bd9Sstevel@tonic-gate * to reqequest any delegation. 7547c478bd9Sstevel@tonic-gate */ 7557c478bd9Sstevel@tonic-gate typedef enum { 7567c478bd9Sstevel@tonic-gate DELEG_NONE = 0, /* Corresponds to OPEN_DELEG_NONE */ 7577c478bd9Sstevel@tonic-gate DELEG_READ = 1, /* Corresponds to OPEN_DELEG_READ */ 7587c478bd9Sstevel@tonic-gate DELEG_WRITE = 2, /* Corresponds to OPEN_DELEG_WRITE */ 7597c478bd9Sstevel@tonic-gate DELEG_ANY = -1 /* New value to request any delegation type */ 7607c478bd9Sstevel@tonic-gate } delegreq_t; 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate #define NFS4_DELEG4TYPE2REQTYPE(x) (delegreq_t)(x) 7637c478bd9Sstevel@tonic-gate 7647c478bd9Sstevel@tonic-gate /* 7657c478bd9Sstevel@tonic-gate * Various interfaces to manipulate the state structures introduced 7667c478bd9Sstevel@tonic-gate * above 7677c478bd9Sstevel@tonic-gate */ 7687c478bd9Sstevel@tonic-gate extern kmutex_t rfs4_state_lock; 7697c478bd9Sstevel@tonic-gate extern void rfs4_clean_state_exi(struct exportinfo *exi); 7707c478bd9Sstevel@tonic-gate extern void rfs4_free_reply(nfs_resop4 *); 7717c478bd9Sstevel@tonic-gate extern void rfs4_copy_reply(nfs_resop4 *, nfs_resop4 *); 7727c478bd9Sstevel@tonic-gate 7737c478bd9Sstevel@tonic-gate /* rfs4_client_t handling */ 7747c478bd9Sstevel@tonic-gate extern rfs4_client_t *rfs4_findclient(nfs_client_id4 *, 7757c478bd9Sstevel@tonic-gate bool_t *, rfs4_client_t *); 7767c478bd9Sstevel@tonic-gate extern rfs4_client_t *rfs4_findclient_by_id(clientid4, bool_t); 7777c478bd9Sstevel@tonic-gate extern void rfs4_client_rele(rfs4_client_t *); 7787c478bd9Sstevel@tonic-gate extern void rfs4_client_close(rfs4_client_t *); 7797c478bd9Sstevel@tonic-gate extern void rfs4_client_state_remove(rfs4_client_t *); 7807c478bd9Sstevel@tonic-gate extern void rfs4_client_scv_next(rfs4_client_t *); 7817c478bd9Sstevel@tonic-gate extern void rfs4_update_lease(rfs4_client_t *); 7827c478bd9Sstevel@tonic-gate extern bool_t rfs4_lease_expired(rfs4_client_t *); 7837c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_check_clientid(clientid4 *, int); 7847c478bd9Sstevel@tonic-gate 7857c478bd9Sstevel@tonic-gate /* rfs4_openowner_t handling */ 7867c478bd9Sstevel@tonic-gate extern rfs4_openowner_t *rfs4_findopenowner(open_owner4 *, bool_t *, seqid4); 7877c478bd9Sstevel@tonic-gate extern void rfs4_update_open_sequence(rfs4_openowner_t *); 7887c478bd9Sstevel@tonic-gate extern void rfs4_update_open_resp(rfs4_openowner_t *, 7897c478bd9Sstevel@tonic-gate nfs_resop4 *, nfs_fh4 *); 7907c478bd9Sstevel@tonic-gate extern void rfs4_openowner_rele(rfs4_openowner_t *); 7917c478bd9Sstevel@tonic-gate extern void rfs4_free_opens(rfs4_openowner_t *, bool_t, bool_t); 7927c478bd9Sstevel@tonic-gate 7937c478bd9Sstevel@tonic-gate /* rfs4_lockowner_t handling */ 7947c478bd9Sstevel@tonic-gate extern rfs4_lockowner_t *rfs4_findlockowner(lock_owner4 *, bool_t *); 7957c478bd9Sstevel@tonic-gate extern rfs4_lockowner_t *rfs4_findlockowner_by_pid(pid_t); 7967c478bd9Sstevel@tonic-gate extern void rfs4_lockowner_rele(rfs4_lockowner_t *); 7977c478bd9Sstevel@tonic-gate 7987c478bd9Sstevel@tonic-gate /* rfs4_state_t handling */ 7997c478bd9Sstevel@tonic-gate extern rfs4_state_t *rfs4_findstate_by_owner_file(rfs4_openowner_t *, 8007c478bd9Sstevel@tonic-gate rfs4_file_t *, bool_t *); 8017c478bd9Sstevel@tonic-gate extern void rfs4_state_rele(rfs4_state_t *); 8027c478bd9Sstevel@tonic-gate extern void rfs4_state_close(rfs4_state_t *, bool_t, 8037c478bd9Sstevel@tonic-gate bool_t, cred_t *); 8047c478bd9Sstevel@tonic-gate extern void rfs4_release_share_lock_state(rfs4_state_t *, 8057c478bd9Sstevel@tonic-gate cred_t *, bool_t); 8067c478bd9Sstevel@tonic-gate extern void rfs4_close_all_state(rfs4_file_t *); 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate /* rfs4_lo_state_t handling */ 8097c478bd9Sstevel@tonic-gate extern rfs4_lo_state_t *rfs4_findlo_state_by_owner(rfs4_lockowner_t *, 8107c478bd9Sstevel@tonic-gate rfs4_state_t *, bool_t *); 8117c478bd9Sstevel@tonic-gate extern void rfs4_lo_state_rele(rfs4_lo_state_t *, bool_t); 8127c478bd9Sstevel@tonic-gate extern void rfs4_update_lock_sequence(rfs4_lo_state_t *); 8137c478bd9Sstevel@tonic-gate extern void rfs4_update_lock_resp(rfs4_lo_state_t *, 8147c478bd9Sstevel@tonic-gate nfs_resop4 *); 8157c478bd9Sstevel@tonic-gate 8167c478bd9Sstevel@tonic-gate /* rfs4_file_t handling */ 8177c478bd9Sstevel@tonic-gate extern rfs4_file_t *rfs4_findfile(vnode_t *, nfs_fh4 *, bool_t *); 8187c478bd9Sstevel@tonic-gate extern rfs4_file_t *rfs4_findfile_withlock(vnode_t *, nfs_fh4 *, 8197c478bd9Sstevel@tonic-gate bool_t *); 8207c478bd9Sstevel@tonic-gate extern void rfs4_file_rele(rfs4_file_t *); 8217c478bd9Sstevel@tonic-gate extern void rfs4_file_rele_withunlock(rfs4_file_t *); 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate /* General collection of "get state" functions */ 8247c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_get_state(stateid4 *, rfs4_state_t **, 8257c478bd9Sstevel@tonic-gate rfs4_dbsearch_type_t); 8267c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_get_deleg_state(stateid4 *, 8277c478bd9Sstevel@tonic-gate rfs4_deleg_state_t **); 8287c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_get_lo_state(stateid4 *, rfs4_lo_state_t **, 8297c478bd9Sstevel@tonic-gate bool_t); 8307c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_check_stateid(int, vnode_t *, stateid4 *, 8317c478bd9Sstevel@tonic-gate bool_t, bool_t *, bool_t); 8327c478bd9Sstevel@tonic-gate extern int rfs4_check_stateid_seqid(rfs4_state_t *, stateid4 *); 8337c478bd9Sstevel@tonic-gate extern int rfs4_check_lo_stateid_seqid(rfs4_lo_state_t *, 8347c478bd9Sstevel@tonic-gate stateid4 *); 8357c478bd9Sstevel@tonic-gate 8367c478bd9Sstevel@tonic-gate /* return values for rfs4_check_stateid_seqid() */ 8377c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_OKAY 1 8387c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_OLD 2 8397c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_BAD 3 8407c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_EXPIRED 4 8417c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_REPLAY 5 8427c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_CLOSED 6 8437c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_UNCONFIRMED 7 8447c478bd9Sstevel@tonic-gate 8457c478bd9Sstevel@tonic-gate /* delay() time that server is willing to briefly wait for a delegreturn */ 8467c478bd9Sstevel@tonic-gate #define NFS4_DELEGATION_CONFLICT_DELAY (hz/10) 8477c478bd9Sstevel@tonic-gate 8487c478bd9Sstevel@tonic-gate /* 8497c478bd9Sstevel@tonic-gate * Interfaces for handling of callback's client handle cache and 8507c478bd9Sstevel@tonic-gate * callback interfaces themselves. 8517c478bd9Sstevel@tonic-gate */ 8527c478bd9Sstevel@tonic-gate extern void rfs4_cbinfo_free(rfs4_cbinfo_t *); 8537c478bd9Sstevel@tonic-gate extern void rfs4_client_setcb(rfs4_client_t *, cb_client4 *, 8547c478bd9Sstevel@tonic-gate uint32_t); 8557c478bd9Sstevel@tonic-gate extern void rfs4_deleg_cb_check(rfs4_client_t *); 8567c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_vop_getattr(vnode_t *, vattr_t *, int, cred_t *); 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate /* rfs4_deleg_state_t handling and other delegation interfaces */ 8597c478bd9Sstevel@tonic-gate extern rfs4_deleg_state_t *rfs4_finddeleg(rfs4_state_t *, bool_t *); 8607c478bd9Sstevel@tonic-gate extern rfs4_deleg_state_t *rfs4_finddelegstate(stateid_t *); 8617c478bd9Sstevel@tonic-gate extern bool_t rfs4_check_recall(rfs4_state_t *, uint32_t); 8627c478bd9Sstevel@tonic-gate extern void rfs4_recall_deleg(rfs4_file_t *, 8637c478bd9Sstevel@tonic-gate bool_t, rfs4_client_t *); 8647c478bd9Sstevel@tonic-gate extern int rfs4_get_deleg(rfs4_state_t *, open_delegation_type4, 8657c478bd9Sstevel@tonic-gate open_delegation_type4 (*policy)(rfs4_state_t *, 8667c478bd9Sstevel@tonic-gate open_delegation_type4 dtype)); 8677c478bd9Sstevel@tonic-gate extern rfs4_deleg_state_t *rfs4_grant_delegation(delegreq_t, rfs4_state_t *, 8687c478bd9Sstevel@tonic-gate int *); 8697c478bd9Sstevel@tonic-gate extern void rfs4_set_deleg_response(rfs4_deleg_state_t *, 8707c478bd9Sstevel@tonic-gate open_delegation4 *, nfsace4 *, int); 8717c478bd9Sstevel@tonic-gate extern void rfs4_return_deleg(rfs4_deleg_state_t *, bool_t); 8727c478bd9Sstevel@tonic-gate extern bool_t rfs4_is_deleg(rfs4_state_t *); 8737c478bd9Sstevel@tonic-gate extern void rfs4_deleg_state_rele(rfs4_deleg_state_t *); 8747c478bd9Sstevel@tonic-gate extern bool_t rfs4_check_delegated_byfp(int, rfs4_file_t *, 8757c478bd9Sstevel@tonic-gate bool_t, bool_t, bool_t, clientid4 *); 8767c478bd9Sstevel@tonic-gate extern void rfs4_clear_dont_grant(rfs4_file_t *); 8777c478bd9Sstevel@tonic-gate 8787c478bd9Sstevel@tonic-gate /* 8797c478bd9Sstevel@tonic-gate * nfs4 monitored operations. 8807c478bd9Sstevel@tonic-gate */ 8817c478bd9Sstevel@tonic-gate extern int deleg_rdopen(femarg_t *, int, cred_t *); 8827c478bd9Sstevel@tonic-gate extern int deleg_wropen(femarg_t *, int, cred_t *); 8837c478bd9Sstevel@tonic-gate extern int deleg_rd_rwlock(femarg_t *, int, caller_context_t *); 8847c478bd9Sstevel@tonic-gate extern int deleg_wr_rwlock(femarg_t *, int, caller_context_t *); 8857c478bd9Sstevel@tonic-gate extern int deleg_read(femarg_t *, uio_t *, int, cred_t *, caller_context_t *); 8867c478bd9Sstevel@tonic-gate extern int deleg_write(femarg_t *, uio_t *, int, cred_t *, caller_context_t *); 8877c478bd9Sstevel@tonic-gate extern int deleg_setattr(femarg_t *, vattr_t *, int, cred_t *, 8887c478bd9Sstevel@tonic-gate caller_context_t *); 8897c478bd9Sstevel@tonic-gate extern int deleg_space(femarg_t *, int, flock64_t *, int, offset_t, cred_t *, 8907c478bd9Sstevel@tonic-gate caller_context_t *); 8917c478bd9Sstevel@tonic-gate extern int deleg_setsecattr(femarg_t *, vsecattr_t *, int, cred_t *); 8927c478bd9Sstevel@tonic-gate extern int deleg_vnevent(femarg_t *, vnevent_t); 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate extern void rfs4_mon_hold(void *); 8957c478bd9Sstevel@tonic-gate extern void rfs4_mon_rele(void *); 8967c478bd9Sstevel@tonic-gate 8977c478bd9Sstevel@tonic-gate extern fem_t *deleg_rdops; 8987c478bd9Sstevel@tonic-gate extern fem_t *deleg_wrops; 8997c478bd9Sstevel@tonic-gate 9007c478bd9Sstevel@tonic-gate extern void rfs4_unshare(rfs4_state_t *); 9017c478bd9Sstevel@tonic-gate extern void rfs4_set_deleg_policy(srv_deleg_policy_t); 9027c478bd9Sstevel@tonic-gate #ifdef DEBUG 9037c478bd9Sstevel@tonic-gate #define NFS4_DEBUG(var, args) if (var) cmn_err args 9047c478bd9Sstevel@tonic-gate 9057c478bd9Sstevel@tonic-gate extern int rfs4_debug; 9067c478bd9Sstevel@tonic-gate extern int nfs4_client_attr_debug; 9077c478bd9Sstevel@tonic-gate extern int nfs4_client_state_debug; 9087c478bd9Sstevel@tonic-gate extern int nfs4_client_shadow_debug; 9097c478bd9Sstevel@tonic-gate extern int nfs4_client_lock_debug; 9107c478bd9Sstevel@tonic-gate extern int nfs4_client_lease_debug; 9117c478bd9Sstevel@tonic-gate extern int nfs4_seqid_sync; 9127c478bd9Sstevel@tonic-gate extern int nfs4_client_map_debug; 9137c478bd9Sstevel@tonic-gate extern int nfs4_client_inactive_debug; 9147c478bd9Sstevel@tonic-gate extern int nfs4_client_recov_debug; 9157c478bd9Sstevel@tonic-gate extern int nfs4_client_recov_stub_debug; 9167c478bd9Sstevel@tonic-gate extern int nfs4_client_failover_debug; 9177c478bd9Sstevel@tonic-gate extern int nfs4_client_call_debug; 9187c478bd9Sstevel@tonic-gate extern int nfs4_client_foo_debug; 9197c478bd9Sstevel@tonic-gate extern int nfs4_client_zone_debug; 9207c478bd9Sstevel@tonic-gate extern int nfs4_lost_rqst_debug; 9217c478bd9Sstevel@tonic-gate extern int nfs4_open_stream_debug; 9227c478bd9Sstevel@tonic-gate extern int nfs4_client_open_dg; 9237c478bd9Sstevel@tonic-gate extern int nfs4_srvmnt_debug; 9247c478bd9Sstevel@tonic-gate extern int nfs4_utf8_debug; 9257c478bd9Sstevel@tonic-gate 9267c478bd9Sstevel@tonic-gate void rfs4_dbe_debug(rfs4_dbe_t *e); 9277c478bd9Sstevel@tonic-gate 9287c478bd9Sstevel@tonic-gate #ifdef NFS4_DEBUG_MUTEX 9297c478bd9Sstevel@tonic-gate void nfs4_debug_mutex_enter(kmutex_t *, char *, int); 9307c478bd9Sstevel@tonic-gate void nfs4_debug_mutex_exit(kmutex_t *, char *, int); 9317c478bd9Sstevel@tonic-gate 9327c478bd9Sstevel@tonic-gate #define mutex_enter(m) nfs4_debug_mutex_enter((m), __FILE__, __LINE__) 9337c478bd9Sstevel@tonic-gate #define mutex_exit(m) nfs4_debug_mutex_exit((m), __FILE__, __LINE__) 9347c478bd9Sstevel@tonic-gate #endif /* NFS4_DEBUG_MUTEX */ 9357c478bd9Sstevel@tonic-gate 9367c478bd9Sstevel@tonic-gate #else /* ! DEBUG */ 9377c478bd9Sstevel@tonic-gate #define NFS4_DEBUG(var, args) 9387c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 9397c478bd9Sstevel@tonic-gate 9407c478bd9Sstevel@tonic-gate /* 9417c478bd9Sstevel@tonic-gate * XXX - temporary for testing of volatile fh 9427c478bd9Sstevel@tonic-gate */ 9437c478bd9Sstevel@tonic-gate 9447c478bd9Sstevel@tonic-gate #ifdef VOLATILE_FH_TEST 9457c478bd9Sstevel@tonic-gate 9467c478bd9Sstevel@tonic-gate struct nfs_fh4_fmt { 9477c478bd9Sstevel@tonic-gate fhandle_t fh4_i; 9487c478bd9Sstevel@tonic-gate uint32_t fh4_flag; 9497c478bd9Sstevel@tonic-gate uint32_t fh4_volatile_id; 9507c478bd9Sstevel@tonic-gate }; 9517c478bd9Sstevel@tonic-gate 9527c478bd9Sstevel@tonic-gate #else /* VOLATILE_FH_TEST */ 9537c478bd9Sstevel@tonic-gate 9547c478bd9Sstevel@tonic-gate struct nfs_fh4_fmt { 9557c478bd9Sstevel@tonic-gate fhandle_t fh4_i; 9567c478bd9Sstevel@tonic-gate uint32_t fh4_flag; 9577c478bd9Sstevel@tonic-gate }; 9587c478bd9Sstevel@tonic-gate 9597c478bd9Sstevel@tonic-gate #endif /* VOLATILE_FH_TEST */ 9607c478bd9Sstevel@tonic-gate 9617c478bd9Sstevel@tonic-gate #define FH4_NAMEDATTR 1 9627c478bd9Sstevel@tonic-gate #define FH4_ATTRDIR 2 9637c478bd9Sstevel@tonic-gate 9647c478bd9Sstevel@tonic-gate #define fh4_fsid fh4_i.fh_fsid 9657c478bd9Sstevel@tonic-gate #define fh4_len fh4_i.fh_len /* fid length */ 9667c478bd9Sstevel@tonic-gate #define fh4_data fh4_i.fh_data /* fid bytes */ 9677c478bd9Sstevel@tonic-gate #define fh4_xlen fh4_i.fh_xlen 9687c478bd9Sstevel@tonic-gate #define fh4_xdata fh4_i.fh_xdata 9697c478bd9Sstevel@tonic-gate typedef struct nfs_fh4_fmt nfs_fh4_fmt_t; 9707c478bd9Sstevel@tonic-gate 9717c478bd9Sstevel@tonic-gate #define fh4_to_fmt4(fh4p) ((nfs_fh4_fmt_t *)(fh4p)->nfs_fh4_val) 9727c478bd9Sstevel@tonic-gate #define get_fh4_flag(fh4p, flag) ((fh4_to_fmt4(fh4p)->fh4_flag) & (flag)) 9737c478bd9Sstevel@tonic-gate #define set_fh4_flag(fh4p, flag) ((fh4_to_fmt4(fh4p)->fh4_flag) |= (flag)) 9747c478bd9Sstevel@tonic-gate #define clr_fh4_flag(fh4p, flag) ((fh4_to_fmt4(fh4p)->fh4_flag) &= ~(flag)) 9757c478bd9Sstevel@tonic-gate 9767c478bd9Sstevel@tonic-gate #define NFS_FH4_LEN sizeof (nfs_fh4_fmt_t) 9777c478bd9Sstevel@tonic-gate 9787c478bd9Sstevel@tonic-gate 9797c478bd9Sstevel@tonic-gate /* 9807c478bd9Sstevel@tonic-gate * A few definitions of repeatedly used constructs for nfsv4 9817c478bd9Sstevel@tonic-gate */ 9827c478bd9Sstevel@tonic-gate #define UTF8STRING_FREE(str) \ 9837c478bd9Sstevel@tonic-gate kmem_free((str).utf8string_val, (str).utf8string_len); \ 9847c478bd9Sstevel@tonic-gate (str).utf8string_val = NULL; \ 9857c478bd9Sstevel@tonic-gate (str).utf8string_len = 0; 9867c478bd9Sstevel@tonic-gate 9877c478bd9Sstevel@tonic-gate /* 9887c478bd9Sstevel@tonic-gate * NFS4_VOLATILE_FH yields non-zero if the filesystem uses non-persistent 9897c478bd9Sstevel@tonic-gate * filehandles. 9907c478bd9Sstevel@tonic-gate */ 9917c478bd9Sstevel@tonic-gate #define NFS4_VOLATILE_FH(mi) \ 9927c478bd9Sstevel@tonic-gate ((mi)->mi_fh_expire_type & \ 9937c478bd9Sstevel@tonic-gate (FH4_VOLATILE_ANY | FH4_VOL_MIGRATION | FH4_VOL_RENAME)) 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate /* 9967c478bd9Sstevel@tonic-gate * NFS_IS_DOTNAME checks if the name given represents a dot or dotdot entry 9977c478bd9Sstevel@tonic-gate */ 9987c478bd9Sstevel@tonic-gate #define NFS_IS_DOTNAME(name) \ 9997c478bd9Sstevel@tonic-gate (((name)[0] == '.') && \ 10007c478bd9Sstevel@tonic-gate (((name)[1] == '\0') || (((name)[1] == '.') && ((name)[2] == '\0')))) 10017c478bd9Sstevel@tonic-gate 10027c478bd9Sstevel@tonic-gate /* 10037c478bd9Sstevel@tonic-gate * Define the number of bits in a bitmap word (uint32) 10047c478bd9Sstevel@tonic-gate */ 10057c478bd9Sstevel@tonic-gate #define NFS4_BITMAP4_BITSPERWORD (sizeof (uint32_t) * 8) 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate /* 10087c478bd9Sstevel@tonic-gate * Define the value for the access field of the compound_state structure 10097c478bd9Sstevel@tonic-gate * based on the result of nfsauth access checking. 10107c478bd9Sstevel@tonic-gate */ 10117c478bd9Sstevel@tonic-gate #define CS_ACCESS_OK 0x1 10127c478bd9Sstevel@tonic-gate #define CS_ACCESS_DENIED 0x2 10137c478bd9Sstevel@tonic-gate #define CS_ACCESS_LIMITED 0x4 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate /* 10167c478bd9Sstevel@tonic-gate * compound state in nfsv4 server 10177c478bd9Sstevel@tonic-gate */ 10187c478bd9Sstevel@tonic-gate struct compound_state { 10197c478bd9Sstevel@tonic-gate struct exportinfo *exi; 10207c478bd9Sstevel@tonic-gate struct exportinfo *saved_exi; /* export struct for saved_vp */ 10217c478bd9Sstevel@tonic-gate cred_t *basecr; /* UNIX cred: only RPC request */ 10227c478bd9Sstevel@tonic-gate caddr_t principal; 10237c478bd9Sstevel@tonic-gate int nfsflavor; 10247c478bd9Sstevel@tonic-gate cred_t *cr; /* UNIX cred: RPC request and */ 10257c478bd9Sstevel@tonic-gate /* target export */ 10267c478bd9Sstevel@tonic-gate bool_t cont; 10277c478bd9Sstevel@tonic-gate uint_t access; /* access perm on vp per request */ 10287c478bd9Sstevel@tonic-gate bool_t deleg; /* TRUE if current fh has */ 10297c478bd9Sstevel@tonic-gate /* write delegated */ 10307c478bd9Sstevel@tonic-gate vnode_t *vp; /* modified by PUTFH, and by ops that */ 10317c478bd9Sstevel@tonic-gate /* input to GETFH */ 10327c478bd9Sstevel@tonic-gate bool_t mandlock; /* Is mandatory locking in effect */ 10337c478bd9Sstevel@tonic-gate /* for vp */ 10347c478bd9Sstevel@tonic-gate vnode_t *saved_vp; /* modified by SAVEFH, copied to */ 10357c478bd9Sstevel@tonic-gate /* vp by RESTOREFH */ 10367c478bd9Sstevel@tonic-gate nfsstat4 *statusp; 10377c478bd9Sstevel@tonic-gate nfs_fh4 fh; /* ditto. valid only if vp != NULL */ 10387c478bd9Sstevel@tonic-gate nfs_fh4 saved_fh; /* ditto. valid only if */ 10397c478bd9Sstevel@tonic-gate /* saved_vp != NULL */ 10407c478bd9Sstevel@tonic-gate struct svc_req *req; 10417c478bd9Sstevel@tonic-gate char fhbuf[NFS4_FHSIZE]; 10427c478bd9Sstevel@tonic-gate }; 10437c478bd9Sstevel@tonic-gate 10447c478bd9Sstevel@tonic-gate /* 10457c478bd9Sstevel@tonic-gate * Conversion commands for nfsv4 server attr checking 10467c478bd9Sstevel@tonic-gate */ 10477c478bd9Sstevel@tonic-gate enum nfs4_attr_cmd { 10487c478bd9Sstevel@tonic-gate NFS4ATTR_SUPPORTED = 0, /* check which attrs supported */ 10497c478bd9Sstevel@tonic-gate NFS4ATTR_GETIT = 1, /* getattr - sys to fattr4 (r) */ 10507c478bd9Sstevel@tonic-gate NFS4ATTR_SETIT = 2, /* setattr - fattr4 to sys (w) */ 10517c478bd9Sstevel@tonic-gate NFS4ATTR_VERIT = 3, /* verify - fattr4 to sys (r) */ 10527c478bd9Sstevel@tonic-gate NFS4ATTR_FREEIT = 4 /* free any alloc'd space for attr */ 10537c478bd9Sstevel@tonic-gate }; 10547c478bd9Sstevel@tonic-gate 10557c478bd9Sstevel@tonic-gate typedef enum nfs4_attr_cmd nfs4_attr_cmd_t; 10567c478bd9Sstevel@tonic-gate 10577c478bd9Sstevel@tonic-gate struct nfs4_svgetit_arg { 10587c478bd9Sstevel@tonic-gate nfs4_attr_cmd_t op; /* getit or setit */ 10597c478bd9Sstevel@tonic-gate struct compound_state *cs; 10607c478bd9Sstevel@tonic-gate struct statvfs64 *sbp; 10617c478bd9Sstevel@tonic-gate uint_t flag; /* VOP_GETATTR/VOP_SETATTR flag */ 10627c478bd9Sstevel@tonic-gate uint_t xattr; /* object is xattr */ 10637c478bd9Sstevel@tonic-gate bool_t rdattr_error_req; /* if readdir & client wants */ 10647c478bd9Sstevel@tonic-gate /* rdattr_error */ 10657c478bd9Sstevel@tonic-gate nfsstat4 rdattr_error; /* used for per-entry status */ 10667c478bd9Sstevel@tonic-gate /* (if rdattr_err) */ 10677c478bd9Sstevel@tonic-gate bool_t mntdfid_set; 10687c478bd9Sstevel@tonic-gate fattr4_mounted_on_fileid 10697c478bd9Sstevel@tonic-gate mounted_on_fileid; 10707c478bd9Sstevel@tonic-gate /* readdir op can always return */ 10717c478bd9Sstevel@tonic-gate /* d_ino from server fs dirent */ 10727c478bd9Sstevel@tonic-gate /* for mounted_on_fileid attr. */ 10737c478bd9Sstevel@tonic-gate /* This field holds d_ino so */ 10747c478bd9Sstevel@tonic-gate /* srv attr conv code can avoid */ 10757c478bd9Sstevel@tonic-gate /* doing an untraverse. */ 10767c478bd9Sstevel@tonic-gate vattr_t vap[1]; 10777c478bd9Sstevel@tonic-gate }; 10787c478bd9Sstevel@tonic-gate 10797c478bd9Sstevel@tonic-gate struct nfs4_ntov_map { 10807c478bd9Sstevel@tonic-gate bitmap4 fbit; /* FATTR4_XXX_MASKY */ 10817c478bd9Sstevel@tonic-gate uint_t vbit; /* AT_XXX */ 10827c478bd9Sstevel@tonic-gate bool_t vfsstat; 10837c478bd9Sstevel@tonic-gate bool_t mandatory; /* attribute mandatory to implement? */ 10847c478bd9Sstevel@tonic-gate uint_t nval; 10857c478bd9Sstevel@tonic-gate int xdr_size; /* Size of XDR'd attr */ 10867c478bd9Sstevel@tonic-gate xdrproc_t xfunc; 10877c478bd9Sstevel@tonic-gate int (*sv_getit)(nfs4_attr_cmd_t, struct nfs4_svgetit_arg *, 10887c478bd9Sstevel@tonic-gate union nfs4_attr_u *); /* subroutine for getting attr. */ 10897c478bd9Sstevel@tonic-gate char *prtstr; /* string attr for printing */ 10907c478bd9Sstevel@tonic-gate }; 10917c478bd9Sstevel@tonic-gate 10927c478bd9Sstevel@tonic-gate struct nfs4attr_to_vattr { 10937c478bd9Sstevel@tonic-gate vnode_t *vp; 10947c478bd9Sstevel@tonic-gate vattr_t *vap; 10957c478bd9Sstevel@tonic-gate nfs_fh4 *fhp; 10967c478bd9Sstevel@tonic-gate nfsstat4 rdattr_error; 10977c478bd9Sstevel@tonic-gate uint32_t flag; 10987c478bd9Sstevel@tonic-gate fattr4_change change; 10997c478bd9Sstevel@tonic-gate fattr4_fsid srv_fsid; 11007c478bd9Sstevel@tonic-gate fattr4_mounted_on_fileid mntd_fid; 11017c478bd9Sstevel@tonic-gate }; 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate typedef struct nfs4attr_to_vattr ntov4_t; 11047c478bd9Sstevel@tonic-gate 11057c478bd9Sstevel@tonic-gate /* 11067c478bd9Sstevel@tonic-gate * nfs4attr_to_vattr flags 11077c478bd9Sstevel@tonic-gate */ 11087c478bd9Sstevel@tonic-gate #define NTOV_FHP_VALID 0x01 11097c478bd9Sstevel@tonic-gate #define NTOV_RDATTR_ERROR_VALID 0x02 11107c478bd9Sstevel@tonic-gate #define NTOV_CHANGE_VALID 0x04 11117c478bd9Sstevel@tonic-gate #define NTOV_SUPP_VALID 0x08 11127c478bd9Sstevel@tonic-gate #define NTOV_SRV_FSID_VALID 0x10 11137c478bd9Sstevel@tonic-gate #define NTOV_MOUNTED_ON_FILEID_VALID 0x20 11147c478bd9Sstevel@tonic-gate 11157c478bd9Sstevel@tonic-gate 11167c478bd9Sstevel@tonic-gate #define FATTR4_MANDATTR_MASK ( \ 11177c478bd9Sstevel@tonic-gate FATTR4_SUPPORTED_ATTRS_MASK | \ 11187c478bd9Sstevel@tonic-gate FATTR4_TYPE_MASK | \ 11197c478bd9Sstevel@tonic-gate FATTR4_FH_EXPIRE_TYPE_MASK | \ 11207c478bd9Sstevel@tonic-gate FATTR4_CHANGE_MASK | \ 11217c478bd9Sstevel@tonic-gate FATTR4_SIZE_MASK | \ 11227c478bd9Sstevel@tonic-gate FATTR4_LINK_SUPPORT_MASK | \ 11237c478bd9Sstevel@tonic-gate FATTR4_SYMLINK_SUPPORT_MASK | \ 11247c478bd9Sstevel@tonic-gate FATTR4_NAMED_ATTR_MASK | \ 11257c478bd9Sstevel@tonic-gate FATTR4_FSID_MASK | \ 11267c478bd9Sstevel@tonic-gate FATTR4_UNIQUE_HANDLES_MASK | \ 11277c478bd9Sstevel@tonic-gate FATTR4_LEASE_TIME_MASK | \ 11287c478bd9Sstevel@tonic-gate FATTR4_RDATTR_ERROR_MASK | \ 11297c478bd9Sstevel@tonic-gate FATTR4_FILEHANDLE_MASK) 11307c478bd9Sstevel@tonic-gate 11317c478bd9Sstevel@tonic-gate 11327c478bd9Sstevel@tonic-gate struct nfs4attr_to_osattr { 11337c478bd9Sstevel@tonic-gate void *attrconv_arg; 11347c478bd9Sstevel@tonic-gate uint_t mask; 11357c478bd9Sstevel@tonic-gate }; 11367c478bd9Sstevel@tonic-gate 11377c478bd9Sstevel@tonic-gate struct mntinfo4; 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate /* 11407c478bd9Sstevel@tonic-gate * lkp4_attr_setup lists the different options for attributes when calling 11417c478bd9Sstevel@tonic-gate * nfs4lookup_setup - either no attributes (just lookups - e.g., secinfo), 11427c478bd9Sstevel@tonic-gate * one component only (normal component lookup), get attributes for the 11437c478bd9Sstevel@tonic-gate * last component (e.g., mount), attributes for each component (e.g., 11447c478bd9Sstevel@tonic-gate * failovers later), just the filehandle for the last component (e.g., 11457c478bd9Sstevel@tonic-gate * volatile filehandle recovery), or stuff that needs OPENATTR (e.g. 11467c478bd9Sstevel@tonic-gate * looking up a named attribute or it's hidden directory). 11477c478bd9Sstevel@tonic-gate */ 11487c478bd9Sstevel@tonic-gate enum lkp4_attr_setup { 11497c478bd9Sstevel@tonic-gate LKP4_NO_ATTRIBUTES = 0, /* no attrs or filehandles */ 11507c478bd9Sstevel@tonic-gate LKP4_ALL_ATTRIBUTES = 3, /* multi-comp: attrs for all comps */ 11517c478bd9Sstevel@tonic-gate LKP4_LAST_NAMED_ATTR = 5, /* multi-comp: named attr & attrdir */ 11527c478bd9Sstevel@tonic-gate LKP4_LAST_ATTRDIR = 6, /* multi-comp: just attrdir */ 11537c478bd9Sstevel@tonic-gate LKP4_ALL_ATTR_SECINFO = 7 /* multi-comp: attrs for all comp and */ 11547c478bd9Sstevel@tonic-gate /* secinfo for last comp */ 11557c478bd9Sstevel@tonic-gate }; 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate /* 11587c478bd9Sstevel@tonic-gate * lookup4_param a set of parameters to nfs4lookup_setup - 11597c478bd9Sstevel@tonic-gate * used to setup a path lookup compound request. 11607c478bd9Sstevel@tonic-gate */ 11617c478bd9Sstevel@tonic-gate typedef struct lookup4_param { 11627c478bd9Sstevel@tonic-gate enum lkp4_attr_setup l4_getattrs; /* (in) get attrs in the lookup? */ 11637c478bd9Sstevel@tonic-gate int header_len; /* (in) num ops before first lookup */ 11647c478bd9Sstevel@tonic-gate int trailer_len; /* (in) num ops after last */ 11657c478bd9Sstevel@tonic-gate /* Lookup/Getattr */ 11667c478bd9Sstevel@tonic-gate bitmap4 ga_bits; /* (in) Which attributes for Getattr */ 11677c478bd9Sstevel@tonic-gate COMPOUND4args_clnt *argsp; /* (in/out) args for compound struct */ 11687c478bd9Sstevel@tonic-gate COMPOUND4res_clnt *resp; /* (in/out) res for compound struct */ 11697c478bd9Sstevel@tonic-gate int arglen; /* (out) argop buffer alloc'd length */ 11707c478bd9Sstevel@tonic-gate struct mntinfo4 *mi; 11717c478bd9Sstevel@tonic-gate } lookup4_param_t; 11727c478bd9Sstevel@tonic-gate 11737c478bd9Sstevel@tonic-gate 11747c478bd9Sstevel@tonic-gate #define NFS4_FATTR4_FINISH -1 /* fattr4 index indicating finish */ 11757c478bd9Sstevel@tonic-gate 11767c478bd9Sstevel@tonic-gate typedef int (*nfs4attr_to_os_t)(int, union nfs4_attr_u *, 11777c478bd9Sstevel@tonic-gate struct nfs4attr_to_osattr *); 11787c478bd9Sstevel@tonic-gate 11797c478bd9Sstevel@tonic-gate /* 11807c478bd9Sstevel@tonic-gate * The nfs4_error_t is the basic structure to return error values 11817c478bd9Sstevel@tonic-gate * from rfs4call. It encapsulates the unix errno 11827c478bd9Sstevel@tonic-gate * value, the nfsstat4 value and the rpc status value into a single 11837c478bd9Sstevel@tonic-gate * structure. 11847c478bd9Sstevel@tonic-gate * 11857c478bd9Sstevel@tonic-gate * If error is set, then stat is ignored and rpc_status may be 11867c478bd9Sstevel@tonic-gate * set if the error occurred as the result of a CLNT_CALL. If 11877c478bd9Sstevel@tonic-gate * stat is set, then rpc request succeeded, error and 11887c478bd9Sstevel@tonic-gate * rpc_status are set to 0 and stat contains the result of 11897c478bd9Sstevel@tonic-gate * operation, NFS4_OK or one of the NFS4ERR_* values. 11907c478bd9Sstevel@tonic-gate * 11917c478bd9Sstevel@tonic-gate * Functions which want to generate errors independently from 11927c478bd9Sstevel@tonic-gate * rfs4call should set error to the desired errno value and 11937c478bd9Sstevel@tonic-gate * set stat and rpc_status to 0. nfs4_error_init() is a 11947c478bd9Sstevel@tonic-gate * convenient function to do this. 11957c478bd9Sstevel@tonic-gate */ 11967c478bd9Sstevel@tonic-gate typedef struct { 11977c478bd9Sstevel@tonic-gate int error; 11987c478bd9Sstevel@tonic-gate nfsstat4 stat; 11997c478bd9Sstevel@tonic-gate enum clnt_stat rpc_status; 12007c478bd9Sstevel@tonic-gate } nfs4_error_t; 12017c478bd9Sstevel@tonic-gate 12027c478bd9Sstevel@tonic-gate /* 12037c478bd9Sstevel@tonic-gate * Shared functions 12047c478bd9Sstevel@tonic-gate */ 12057c478bd9Sstevel@tonic-gate extern void rfs4_op_readdir(nfs_argop4 *, nfs_resop4 *, 12067c478bd9Sstevel@tonic-gate struct svc_req *, struct compound_state *); 12077c478bd9Sstevel@tonic-gate extern void nfs_fh4_copy(nfs_fh4 *, nfs_fh4 *); 12087c478bd9Sstevel@tonic-gate 12097c478bd9Sstevel@tonic-gate extern void nfs4_fattr4_free(fattr4 *); 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate extern int nfs4lookup_setup(char *, lookup4_param_t *, int); 12127c478bd9Sstevel@tonic-gate extern void nfs4_getattr_otw_norecovery(vnode_t *, 12137c478bd9Sstevel@tonic-gate nfs4_ga_res_t *, nfs4_error_t *, cred_t *, int); 12147c478bd9Sstevel@tonic-gate extern int nfs4_getattr_otw(vnode_t *, nfs4_ga_res_t *, cred_t *, int); 12157c478bd9Sstevel@tonic-gate extern int nfs4cmpfh(const nfs_fh4 *, const nfs_fh4 *); 12167c478bd9Sstevel@tonic-gate extern int nfs4cmpfhandle(nfs4_fhandle_t *, nfs4_fhandle_t *); 12177c478bd9Sstevel@tonic-gate extern int nfs4getattr(vnode_t *, struct vattr *, cred_t *); 12187c478bd9Sstevel@tonic-gate extern int nfs4_waitfor_purge_complete(vnode_t *); 12197c478bd9Sstevel@tonic-gate extern int nfs4_validate_caches(vnode_t *, cred_t *); 12207c478bd9Sstevel@tonic-gate extern int nfs4init(int, char *); 12217c478bd9Sstevel@tonic-gate extern void nfs4fini(void); 12227c478bd9Sstevel@tonic-gate extern int nfs4_vfsinit(void); 12237c478bd9Sstevel@tonic-gate extern void nfs4_vfsfini(void); 12247c478bd9Sstevel@tonic-gate 12257c478bd9Sstevel@tonic-gate extern void nfs4_vnops_init(void); 12267c478bd9Sstevel@tonic-gate extern void nfs4_vnops_fini(void); 12277c478bd9Sstevel@tonic-gate extern void nfs_idmap_init(void); 12287c478bd9Sstevel@tonic-gate extern void nfs_idmap_flush(int); 12297c478bd9Sstevel@tonic-gate extern void nfs_idmap_fini(void); 12307c478bd9Sstevel@tonic-gate extern int nfs4_rnode_init(void); 12317c478bd9Sstevel@tonic-gate extern int nfs4_rnode_fini(void); 12327c478bd9Sstevel@tonic-gate extern int nfs4_shadow_init(void); 12337c478bd9Sstevel@tonic-gate extern int nfs4_shadow_fini(void); 12347c478bd9Sstevel@tonic-gate extern int nfs4_acache_init(void); 12357c478bd9Sstevel@tonic-gate extern int nfs4_acache_fini(void); 12367c478bd9Sstevel@tonic-gate extern int nfs4_subr_init(void); 12377c478bd9Sstevel@tonic-gate extern int nfs4_subr_fini(void); 12387c478bd9Sstevel@tonic-gate extern void nfs4_acl_init(void); 12397c478bd9Sstevel@tonic-gate extern void nfs4_acl_free_cache(vsecattr_t *); 12407c478bd9Sstevel@tonic-gate 12417c478bd9Sstevel@tonic-gate extern int geterrno4(nfsstat4); 12427c478bd9Sstevel@tonic-gate extern nfsstat4 puterrno4(int); 12437c478bd9Sstevel@tonic-gate extern int nfs4_need_to_bump_seqid(COMPOUND4res_clnt *); 12447c478bd9Sstevel@tonic-gate extern int nfs4tsize(void); 12457c478bd9Sstevel@tonic-gate extern int checkauth4(struct compound_state *, struct svc_req *); 12467c478bd9Sstevel@tonic-gate extern nfsstat4 call_checkauth4(struct compound_state *, struct svc_req *); 12477c478bd9Sstevel@tonic-gate extern int is_exported_sec(int, struct exportinfo *); 12487c478bd9Sstevel@tonic-gate extern void nfs4_vmask_to_nmask(uint_t, bitmap4 *); 12499720e166Sjasmith extern void nfs4_vmask_to_nmask_set(uint_t, bitmap4 *); 12507c478bd9Sstevel@tonic-gate extern int nfs_idmap_str_uid(utf8string *u8s, uid_t *, bool_t); 12517c478bd9Sstevel@tonic-gate extern int nfs_idmap_str_gid(utf8string *u8s, gid_t *, bool_t); 12527c478bd9Sstevel@tonic-gate extern int nfs_idmap_uid_str(uid_t, utf8string *u8s, bool_t); 12537c478bd9Sstevel@tonic-gate extern int nfs_idmap_gid_str(gid_t gid, utf8string *u8s, bool_t); 12547c478bd9Sstevel@tonic-gate extern int nfs4_time_ntov(nfstime4 *, timestruc_t *); 12557c478bd9Sstevel@tonic-gate extern int nfs4_time_vton(timestruc_t *, nfstime4 *); 12567c478bd9Sstevel@tonic-gate extern char *utf8_to_str(utf8string *, uint_t *, char *); 12577c478bd9Sstevel@tonic-gate extern char *utf8_to_fn(utf8string *, uint_t *, char *); 12587c478bd9Sstevel@tonic-gate extern utf8string *str_to_utf8(char *, utf8string *); 12597c478bd9Sstevel@tonic-gate extern utf8string *utf8_copy(utf8string *, utf8string *); 12607c478bd9Sstevel@tonic-gate extern int utf8_compare(const utf8string *, const utf8string *); 12617c478bd9Sstevel@tonic-gate extern int utf8_dir_verify(utf8string *); 12627c478bd9Sstevel@tonic-gate extern char *utf8_strchr(utf8string *, const char); 12637c478bd9Sstevel@tonic-gate extern int ln_ace4_cmp(nfsace4 *, nfsace4 *, int); 12647c478bd9Sstevel@tonic-gate extern int vs_aent_to_ace4(vsecattr_t *, vsecattr_t *, int, int); 12657c478bd9Sstevel@tonic-gate extern int vs_ace4_to_aent(vsecattr_t *, vsecattr_t *, uid_t, gid_t, 12667c478bd9Sstevel@tonic-gate int, int, int); 12677c478bd9Sstevel@tonic-gate extern int vs_ace4_to_acet(vsecattr_t *, vsecattr_t *, uid_t, gid_t, 1268*fa9e4066Sahrens int, int); 1269*fa9e4066Sahrens extern int vs_acet_to_ace4(vsecattr_t *, vsecattr_t *, int); 12707c478bd9Sstevel@tonic-gate extern void vs_acet_destroy(vsecattr_t *); 12717c478bd9Sstevel@tonic-gate extern void vs_ace4_destroy(vsecattr_t *); 12727c478bd9Sstevel@tonic-gate extern void vs_aent_destroy(vsecattr_t *); 12737c478bd9Sstevel@tonic-gate 12747c478bd9Sstevel@tonic-gate extern int stateid4_cmp(stateid4 *, stateid4 *); 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate extern vtype_t nf4_to_vt[]; 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate extern struct nfs4_ntov_map nfs4_ntov_map[]; 12797c478bd9Sstevel@tonic-gate extern uint_t nfs4_ntov_map_size; 12807c478bd9Sstevel@tonic-gate 12817c478bd9Sstevel@tonic-gate extern kstat_named_t *rfsproccnt_v4_ptr; 12827c478bd9Sstevel@tonic-gate extern struct vfsops *nfs4_vfsops; 12837c478bd9Sstevel@tonic-gate extern struct vnodeops *nfs4_vnodeops; 12847c478bd9Sstevel@tonic-gate extern const struct fs_operation_def nfs4_vnodeops_template[]; 12857c478bd9Sstevel@tonic-gate 12867c478bd9Sstevel@tonic-gate extern uint_t nfs4_tsize(struct knetconfig *); 12877c478bd9Sstevel@tonic-gate extern uint_t rfs4_tsize(struct svc_req *); 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate #ifdef DEBUG 12907c478bd9Sstevel@tonic-gate extern int rfs4_do_pre_op_attr; 12917c478bd9Sstevel@tonic-gate extern int rfs4_do_post_op_attr; 12927c478bd9Sstevel@tonic-gate #endif 12937c478bd9Sstevel@tonic-gate 12947c478bd9Sstevel@tonic-gate extern stateid4 clnt_special0; 12957c478bd9Sstevel@tonic-gate extern stateid4 clnt_special1; 12967c478bd9Sstevel@tonic-gate #define CLNT_ISSPECIAL(id) (stateid4_cmp(id, &clnt_special0) || \ 12977c478bd9Sstevel@tonic-gate stateid4_cmp(id, &clnt_special1)) 12987c478bd9Sstevel@tonic-gate 12997c478bd9Sstevel@tonic-gate /* 13007c478bd9Sstevel@tonic-gate * The NFS Version 4 service procedures. 13017c478bd9Sstevel@tonic-gate */ 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate extern void rfs4_compound(COMPOUND4args *, COMPOUND4res *, 13047c478bd9Sstevel@tonic-gate struct exportinfo *, struct svc_req *, cred_t *); 13057c478bd9Sstevel@tonic-gate extern void rfs4_compound_free(COMPOUND4res *); 13067c478bd9Sstevel@tonic-gate extern void rfs4_compound_flagproc(COMPOUND4args *, int *); 13077c478bd9Sstevel@tonic-gate 13087c478bd9Sstevel@tonic-gate extern int rfs4_srvrinit(void); 13097c478bd9Sstevel@tonic-gate extern void rfs4_srvrfini(void); 13107c478bd9Sstevel@tonic-gate extern void rfs4_state_init(void); 13117c478bd9Sstevel@tonic-gate extern void rfs4_state_fini(void); 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate #endif 13147c478bd9Sstevel@tonic-gate #ifdef __cplusplus 13157c478bd9Sstevel@tonic-gate } 13167c478bd9Sstevel@tonic-gate #endif 13177c478bd9Sstevel@tonic-gate 13187c478bd9Sstevel@tonic-gate #endif /* _NFS4_H */ 1319