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 527242a7cSthurlow * Common Development and Distribution License (the "License"). 627242a7cSthurlow * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22*e913d9ecSLisa Week * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #ifndef _NFS4_H 277c478bd9Sstevel@tonic-gate #define _NFS4_H 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate #include <sys/types.h> 307c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 317c478bd9Sstevel@tonic-gate #include <sys/fem.h> 327c478bd9Sstevel@tonic-gate #include <rpc/rpc.h> 337c478bd9Sstevel@tonic-gate #include <nfs/nfs.h> 347c478bd9Sstevel@tonic-gate 357c478bd9Sstevel@tonic-gate #ifdef _KERNEL 367c478bd9Sstevel@tonic-gate #include <nfs/nfs4_kprot.h> 37cee86682Scalum #include <sys/nvpair.h> 387c478bd9Sstevel@tonic-gate #else 397c478bd9Sstevel@tonic-gate #include <rpcsvc/nfs4_prot.h> 407c478bd9Sstevel@tonic-gate #endif 417c478bd9Sstevel@tonic-gate #include <nfs/nfs4_attr.h> 427c478bd9Sstevel@tonic-gate #include <sys/acl.h> 43d216dff5SRobert Mastors #include <sys/list.h> 447c478bd9Sstevel@tonic-gate 457c478bd9Sstevel@tonic-gate #ifdef __cplusplus 467c478bd9Sstevel@tonic-gate extern "C" { 477c478bd9Sstevel@tonic-gate #endif 487c478bd9Sstevel@tonic-gate 497c478bd9Sstevel@tonic-gate #define NFS4_MAX_UTF8STRING 65536 507c478bd9Sstevel@tonic-gate #define NFS4_MAX_PATHNAME4 65536 517c478bd9Sstevel@tonic-gate #define NFS4_MAX_SECOID4 65536 527c478bd9Sstevel@tonic-gate 537c478bd9Sstevel@tonic-gate #ifdef _KERNEL 547c478bd9Sstevel@tonic-gate 557c478bd9Sstevel@tonic-gate typedef struct nfs4_fhandle { 567c478bd9Sstevel@tonic-gate int fh_len; 577c478bd9Sstevel@tonic-gate char fh_buf[NFS4_FHSIZE]; 587c478bd9Sstevel@tonic-gate } nfs4_fhandle_t; 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate #define NFS4_MINORVERSION 0 617c478bd9Sstevel@tonic-gate #define CB4_MINORVERSION 0 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate /* 647c478bd9Sstevel@tonic-gate * Set the fattr4_change variable using a time struct. Note that change 657c478bd9Sstevel@tonic-gate * is 64 bits, but timestruc_t is 128 bits in a 64-bit kernel. 667c478bd9Sstevel@tonic-gate */ 677c478bd9Sstevel@tonic-gate #define NFS4_SET_FATTR4_CHANGE(change, ts) \ 687c478bd9Sstevel@tonic-gate { \ 697c478bd9Sstevel@tonic-gate change = (ts).tv_sec; \ 707c478bd9Sstevel@tonic-gate change <<= 32; \ 717c478bd9Sstevel@tonic-gate change |= (uint32_t)((ts).tv_nsec); \ 727c478bd9Sstevel@tonic-gate } 737c478bd9Sstevel@tonic-gate 747c478bd9Sstevel@tonic-gate /* 757c478bd9Sstevel@tonic-gate * Server lease period. Value is in seconds; Also used for grace period 767c478bd9Sstevel@tonic-gate */ 777c478bd9Sstevel@tonic-gate extern time_t rfs4_lease_time; 787c478bd9Sstevel@tonic-gate 797c478bd9Sstevel@tonic-gate /* 807c478bd9Sstevel@tonic-gate * This set of typedefs and interfaces represent the core or base set 817c478bd9Sstevel@tonic-gate * of functionality that backs the NFSv4 server's state related data 827c478bd9Sstevel@tonic-gate * structures. Since the NFSv4 server needs inter-RPC state to be 837c478bd9Sstevel@tonic-gate * available that is unrelated to the filesystem (in other words, 847c478bd9Sstevel@tonic-gate * soft-state), this functionality is needed to maintain that and is 857c478bd9Sstevel@tonic-gate * written to be somewhat flexible to adapt to the various types of 867c478bd9Sstevel@tonic-gate * data structures contained within the server. 877c478bd9Sstevel@tonic-gate * 887c478bd9Sstevel@tonic-gate * The basic structure at this level is that the server maintains a 897c478bd9Sstevel@tonic-gate * global "database" which consists of a set of tables. Each table 907c478bd9Sstevel@tonic-gate * contains a set of like data structures. Each table is indexed by 917c478bd9Sstevel@tonic-gate * at least one hash function and in most cases two hashes. Each 927c478bd9Sstevel@tonic-gate * table's characteristics is set when it is created at run-time via 937c478bd9Sstevel@tonic-gate * rfs4_table_create(). All table creation and related functions are 947c478bd9Sstevel@tonic-gate * located in nfs4_state.c. The generic database functionality is 957c478bd9Sstevel@tonic-gate * located in nfs4_db.c. 967c478bd9Sstevel@tonic-gate */ 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate typedef struct rfs4_dbe rfs4_dbe_t; /* basic opaque db entry */ 997c478bd9Sstevel@tonic-gate typedef struct rfs4_table rfs4_table_t; /* basic table type */ 1007c478bd9Sstevel@tonic-gate typedef struct rfs4_index rfs4_index_t; /* index */ 1017c478bd9Sstevel@tonic-gate typedef struct rfs4_database rfs4_database_t; /* and database */ 1027c478bd9Sstevel@tonic-gate 1037c478bd9Sstevel@tonic-gate typedef struct { /* opaque entry type for later use */ 1047c478bd9Sstevel@tonic-gate rfs4_dbe_t *dbe; 1057c478bd9Sstevel@tonic-gate } *rfs4_entry_t; 1067c478bd9Sstevel@tonic-gate 1077c478bd9Sstevel@tonic-gate extern rfs4_table_t *rfs4_client_tab; 1087c478bd9Sstevel@tonic-gate 1097c478bd9Sstevel@tonic-gate /* database, table, index creation entry points */ 1107c478bd9Sstevel@tonic-gate extern rfs4_database_t *rfs4_database_create(uint32_t); 1117c478bd9Sstevel@tonic-gate extern void rfs4_database_shutdown(rfs4_database_t *); 1127c478bd9Sstevel@tonic-gate extern void rfs4_database_destroy(rfs4_database_t *); 1137c478bd9Sstevel@tonic-gate 1147c478bd9Sstevel@tonic-gate extern void rfs4_database_destroy(rfs4_database_t *); 1157c478bd9Sstevel@tonic-gate 1167c478bd9Sstevel@tonic-gate extern rfs4_table_t *rfs4_table_create(rfs4_database_t *, char *, 1177c478bd9Sstevel@tonic-gate time_t, uint32_t, 1187c478bd9Sstevel@tonic-gate bool_t (*create)(rfs4_entry_t, void *), 1197c478bd9Sstevel@tonic-gate void (*destroy)(rfs4_entry_t), 1207c478bd9Sstevel@tonic-gate bool_t (*expiry)(rfs4_entry_t), 1217c478bd9Sstevel@tonic-gate uint32_t, uint32_t, uint32_t, id_t); 1227c478bd9Sstevel@tonic-gate extern void rfs4_table_destroy(rfs4_database_t *, rfs4_table_t *); 1237c478bd9Sstevel@tonic-gate extern rfs4_index_t *rfs4_index_create(rfs4_table_t *, char *, 1247c478bd9Sstevel@tonic-gate uint32_t (*hash)(void *), 1257c478bd9Sstevel@tonic-gate bool_t (compare)(rfs4_entry_t, void *), 1267c478bd9Sstevel@tonic-gate void *(*mkkey)(rfs4_entry_t), bool_t); 1277c478bd9Sstevel@tonic-gate extern void rfs4_index_destroy(rfs4_index_t *); 1287c478bd9Sstevel@tonic-gate 1297c478bd9Sstevel@tonic-gate /* Type used to direct rfs4_dbsearch() in what types of records to inspect */ 1307c478bd9Sstevel@tonic-gate typedef enum {RFS4_DBS_VALID, RFS4_DBS_INVALID} rfs4_dbsearch_type_t; 1317c478bd9Sstevel@tonic-gate /* search and db entry manipulation entry points */ 1327c478bd9Sstevel@tonic-gate extern rfs4_entry_t rfs4_dbsearch(rfs4_index_t *, void *, 1337c478bd9Sstevel@tonic-gate bool_t *, void *, rfs4_dbsearch_type_t); 1347c478bd9Sstevel@tonic-gate extern void rfs4_dbe_lock(rfs4_dbe_t *); 1357c478bd9Sstevel@tonic-gate extern void rfs4_dbe_unlock(rfs4_dbe_t *); 1367c478bd9Sstevel@tonic-gate extern clock_t rfs4_dbe_twait(rfs4_dbe_t *, clock_t); 1377c478bd9Sstevel@tonic-gate extern void rfs4_dbe_cv_broadcast(rfs4_dbe_t *); 1387c478bd9Sstevel@tonic-gate extern void rfs4_dbe_hold(rfs4_dbe_t *); 1397c478bd9Sstevel@tonic-gate extern void rfs4_dbe_hold_nolock(rfs4_dbe_t *); 1407c478bd9Sstevel@tonic-gate extern void rfs4_dbe_rele_nolock(rfs4_dbe_t *); 1417c478bd9Sstevel@tonic-gate extern void rfs4_dbe_rele(rfs4_dbe_t *); 1427c478bd9Sstevel@tonic-gate extern uint32_t rfs4_dbe_refcnt(rfs4_dbe_t *); 1437c478bd9Sstevel@tonic-gate extern id_t rfs4_dbe_getid(rfs4_dbe_t *); 1447c478bd9Sstevel@tonic-gate extern void rfs4_dbe_invalidate(rfs4_dbe_t *); 1457c478bd9Sstevel@tonic-gate extern bool_t rfs4_dbe_is_invalid(rfs4_dbe_t *); 1467c478bd9Sstevel@tonic-gate extern time_t rfs4_dbe_get_timerele(rfs4_dbe_t *); 1477c478bd9Sstevel@tonic-gate extern void rfs4_dbe_hide(rfs4_dbe_t *); 1487c478bd9Sstevel@tonic-gate extern void rfs4_dbe_unhide(rfs4_dbe_t *); 1497c478bd9Sstevel@tonic-gate #ifdef DEBUG 1507c478bd9Sstevel@tonic-gate extern bool_t rfs4_dbe_islocked(rfs4_dbe_t *); 1517c478bd9Sstevel@tonic-gate #endif 1527c478bd9Sstevel@tonic-gate extern void rfs4_dbe_walk(rfs4_table_t *, 1537c478bd9Sstevel@tonic-gate void (*callout)(rfs4_entry_t, void *), void *); 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate /* 1567c478bd9Sstevel@tonic-gate * Minimal server stable storage. 1577c478bd9Sstevel@tonic-gate * 1587c478bd9Sstevel@tonic-gate * Currently the NFSv4 server will only save the client 1597c478bd9Sstevel@tonic-gate * ID (the long version) so that it will be able to 1607c478bd9Sstevel@tonic-gate * grant possible reclaim requests during the infamous 1617c478bd9Sstevel@tonic-gate * grace_period. 1627c478bd9Sstevel@tonic-gate */ 1637c478bd9Sstevel@tonic-gate 1647c478bd9Sstevel@tonic-gate #define RFS4_SS_DIRSIZE 64 * 1024 1657c478bd9Sstevel@tonic-gate #define NFS4_SS_VERSION 1 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate /* handy pathname structure */ 1687c478bd9Sstevel@tonic-gate typedef struct ss_pn { 1697c478bd9Sstevel@tonic-gate char *leaf; 1707c478bd9Sstevel@tonic-gate char pn[MAXPATHLEN]; 1717c478bd9Sstevel@tonic-gate } rfs4_ss_pn_t; 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate /* 1747c478bd9Sstevel@tonic-gate * The server will build this link list on startup. It represents the 1757c478bd9Sstevel@tonic-gate * clients that have had valid state on the server in a prior instance. 1767c478bd9Sstevel@tonic-gate * 1777c478bd9Sstevel@tonic-gate */ 1787c478bd9Sstevel@tonic-gate typedef struct rfs4_oldstate { 1797c478bd9Sstevel@tonic-gate struct rfs4_oldstate *next; 1807c478bd9Sstevel@tonic-gate struct rfs4_oldstate *prev; 1817c478bd9Sstevel@tonic-gate rfs4_ss_pn_t *ss_pn; 1827c478bd9Sstevel@tonic-gate nfs_client_id4 cl_id4; 1837c478bd9Sstevel@tonic-gate } rfs4_oldstate_t; 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate /* 1867c478bd9Sstevel@tonic-gate * This union is used to overlay the server's internal treatment of 1877c478bd9Sstevel@tonic-gate * the protocols stateid4 datatype. Therefore, "bits" must not exceed 1887c478bd9Sstevel@tonic-gate * the size of stateid4 and more importantly should match the size of 1897c478bd9Sstevel@tonic-gate * stateid4. The chgseq field must the first entry since it overlays 1907c478bd9Sstevel@tonic-gate * stateid4.seqid. 1917c478bd9Sstevel@tonic-gate */ 1927c478bd9Sstevel@tonic-gate typedef union { 1937c478bd9Sstevel@tonic-gate stateid4 stateid; 1947c478bd9Sstevel@tonic-gate struct { 1957c478bd9Sstevel@tonic-gate uint32_t chgseq; /* State changes / protocol's seqid */ 1967c478bd9Sstevel@tonic-gate uint32_t boottime; /* boot time */ 1977c478bd9Sstevel@tonic-gate uint32_t type:2; /* stateid_type_t as define below */ 1987c478bd9Sstevel@tonic-gate uint32_t clnodeid:8; /* cluster server nodeid */ 1997c478bd9Sstevel@tonic-gate uint32_t ident:22; /* 2^22-1 openowner x fhs */ 2007c478bd9Sstevel@tonic-gate pid_t pid; /* pid of corresponding lock owner */ 2017c478bd9Sstevel@tonic-gate } bits; 2027c478bd9Sstevel@tonic-gate } stateid_t; 2037c478bd9Sstevel@tonic-gate /* 2047c478bd9Sstevel@tonic-gate * Note that the way the type field above is defined, this enum must 2057c478bd9Sstevel@tonic-gate * not have more than 4 members. 2067c478bd9Sstevel@tonic-gate */ 2077c478bd9Sstevel@tonic-gate typedef enum {OPENID, LOCKID, DELEGID} stateid_type_t; 2087c478bd9Sstevel@tonic-gate 2097c478bd9Sstevel@tonic-gate 2107c478bd9Sstevel@tonic-gate /* 2117c478bd9Sstevel@tonic-gate * Set of RPC credentials used for a particular operation. 2127c478bd9Sstevel@tonic-gate * Used for operations like SETCLIENTID_CONFIRM where the 2137c478bd9Sstevel@tonic-gate * credentials needs to match those used at SETCLIENTID. 2147c478bd9Sstevel@tonic-gate */ 2157c478bd9Sstevel@tonic-gate typedef void *cred_set_t; /* For now XXX */ 2167c478bd9Sstevel@tonic-gate 2177c478bd9Sstevel@tonic-gate /* 2187c478bd9Sstevel@tonic-gate * "wait" struct for use in the open open and lock owner state 2197c478bd9Sstevel@tonic-gate * structures to provide serialization between server threads that are 2207c478bd9Sstevel@tonic-gate * handling requests for the same open owner or lock stateid. This 2217c478bd9Sstevel@tonic-gate * way only one thread will be updating things like sequence ids, 2227c478bd9Sstevel@tonic-gate * replay cache and stateid at a time. 2237c478bd9Sstevel@tonic-gate */ 2247c478bd9Sstevel@tonic-gate typedef struct rfs4_state_wait { 2257c478bd9Sstevel@tonic-gate uint32_t sw_active; 2267c478bd9Sstevel@tonic-gate uint32_t sw_wait_count; 2277c478bd9Sstevel@tonic-gate kmutex_t sw_cv_lock[1]; 2287c478bd9Sstevel@tonic-gate kcondvar_t sw_cv[1]; 2297c478bd9Sstevel@tonic-gate } rfs4_state_wait_t; 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate extern void rfs4_sw_enter(rfs4_state_wait_t *); 2327c478bd9Sstevel@tonic-gate extern void rfs4_sw_exit(rfs4_state_wait_t *); 2337c478bd9Sstevel@tonic-gate 2347c478bd9Sstevel@tonic-gate /* 2357c478bd9Sstevel@tonic-gate * This enum and the following rfs4_cbinfo_t struct are used to 2367c478bd9Sstevel@tonic-gate * maintain information about the callback path used from the server 2377c478bd9Sstevel@tonic-gate * to client for operations like CB_GETATTR and CB_RECALL. The 2387c478bd9Sstevel@tonic-gate * rfs4_cbinfo_t struct is meant to be encompassed in the client 2397c478bd9Sstevel@tonic-gate * struct and managed within that structure's locking scheme. 2407c478bd9Sstevel@tonic-gate * 2417c478bd9Sstevel@tonic-gate * The various states of the callback path are used by the server to 2427c478bd9Sstevel@tonic-gate * determine if delegations should initially be provided to a client 2437c478bd9Sstevel@tonic-gate * and then later on if connectivity has been lost and delegations 2447c478bd9Sstevel@tonic-gate * should be revoked. 2457c478bd9Sstevel@tonic-gate */ 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate /* 2487c478bd9Sstevel@tonic-gate * CB_NOCHANGE - Special value used for interfaces within the delegation 2497c478bd9Sstevel@tonic-gate * code to signify that "no change" has occurred to the 2507c478bd9Sstevel@tonic-gate * callback path 2517c478bd9Sstevel@tonic-gate * CB_UNINIT - No callback info provided by the client 2527c478bd9Sstevel@tonic-gate * CB_NONE - Callback info provided but CB_NULL call 2537c478bd9Sstevel@tonic-gate * has yet to be attempted 2547c478bd9Sstevel@tonic-gate * CB_OK - Callback path tested with CB_NULL with success 2557c478bd9Sstevel@tonic-gate * CB_INPROG - Callback path currently being tested with CB_NULL 2567c478bd9Sstevel@tonic-gate * CB_FAILED - Callback path was == CB_OK but has failed 2577c478bd9Sstevel@tonic-gate * with timeout/rpc error 2587c478bd9Sstevel@tonic-gate * CB_BAD - Callback info provided but CB_NULL failed 2597c478bd9Sstevel@tonic-gate */ 2607c478bd9Sstevel@tonic-gate typedef enum { 2617c478bd9Sstevel@tonic-gate CB_NOCHANGE = 0, 2627c478bd9Sstevel@tonic-gate CB_UNINIT = 1, 2637c478bd9Sstevel@tonic-gate CB_NONE = 2, 2647c478bd9Sstevel@tonic-gate CB_OK = 3, 2657c478bd9Sstevel@tonic-gate CB_INPROG = 4, 2667c478bd9Sstevel@tonic-gate CB_FAILED = 5, 2677c478bd9Sstevel@tonic-gate CB_BAD = 6 2687c478bd9Sstevel@tonic-gate } rfs4_cbstate_t; 2697c478bd9Sstevel@tonic-gate 2707c478bd9Sstevel@tonic-gate #define RFS4_CBCH_MAX 10 /* size callback client handle cache */ 2717c478bd9Sstevel@tonic-gate /* 2727c478bd9Sstevel@tonic-gate * Callback info for a client. 2737c478bd9Sstevel@tonic-gate * Client only provides: cb_client4 and cb_ident 2747c478bd9Sstevel@tonic-gate * The rest of the information is used to track callback path status 2757c478bd9Sstevel@tonic-gate * and usage. 2767c478bd9Sstevel@tonic-gate * 2777c478bd9Sstevel@tonic-gate * cb_state - used as comments for the rfs4_cbstate_t enum indicate 2787c478bd9Sstevel@tonic-gate * cb_notified_of_cb_path_down - if the callback path was once CB_OK and 2797c478bd9Sstevel@tonic-gate * has hence CB_FAILED, the client needs to be notified via RENEW. 2807c478bd9Sstevel@tonic-gate * cb_timefailed - current time when cb_state transitioned from 2817c478bd9Sstevel@tonic-gate * CB_OK -> CB_FAILED. Meant for observability. When did that happen? 2827c478bd9Sstevel@tonic-gate * cb_chc_free/cb_chc - cache of client handles for the callback path 2837c478bd9Sstevel@tonic-gate * cb_ident - SETCLIENTID provided callback_ident value 2847c478bd9Sstevel@tonic-gate * callback - SETCLIENTID provided cb_client4 value 2857c478bd9Sstevel@tonic-gate * cb_refcnt - current number of users of this structure's content 2867c478bd9Sstevel@tonic-gate * protected by cb_lock 2877c478bd9Sstevel@tonic-gate * cb_badbehavior - how many times did a client do something we didn't like? 2887c478bd9Sstevel@tonic-gate * cb_lock - lock for contents of cbinfo 2897c478bd9Sstevel@tonic-gate * cb_cv - used to allow threads to wait on CB_NULL completion 2907c478bd9Sstevel@tonic-gate * cb_nullcaller - is there a thread currently taking care of 2917c478bd9Sstevel@tonic-gate * new callback information? 2927c478bd9Sstevel@tonic-gate * cb_cv_nullcaller - used by the thread doing CB_NULL to wait on 2937c478bd9Sstevel@tonic-gate * threads that may be using client handles of the current 2947c478bd9Sstevel@tonic-gate * client handle cache. 2957c478bd9Sstevel@tonic-gate * newer - new callback info provided by a client and awaiting 2967c478bd9Sstevel@tonic-gate * CB_NULL testing and move to regular cbinfo. 2977c478bd9Sstevel@tonic-gate */ 2987c478bd9Sstevel@tonic-gate typedef struct { 2997c478bd9Sstevel@tonic-gate rfs4_cbstate_t cb_state; 3007c478bd9Sstevel@tonic-gate unsigned cb_notified_of_cb_path_down:1; 3017c478bd9Sstevel@tonic-gate time_t cb_timefailed; 3027c478bd9Sstevel@tonic-gate int cb_chc_free; 3037c478bd9Sstevel@tonic-gate CLIENT *cb_chc[RFS4_CBCH_MAX]; 3047c478bd9Sstevel@tonic-gate uint32_t cb_ident; 3057c478bd9Sstevel@tonic-gate cb_client4 cb_callback; 3067c478bd9Sstevel@tonic-gate uint32_t cb_refcnt; 3077c478bd9Sstevel@tonic-gate uint32_t cb_badbehavior; 3087c478bd9Sstevel@tonic-gate kmutex_t cb_lock[1]; 3097c478bd9Sstevel@tonic-gate kcondvar_t cb_cv[1]; 3107c478bd9Sstevel@tonic-gate bool_t cb_nullcaller; 3117c478bd9Sstevel@tonic-gate kcondvar_t cb_cv_nullcaller[1]; 3127c478bd9Sstevel@tonic-gate struct { 3137c478bd9Sstevel@tonic-gate bool_t cb_new; 3147c478bd9Sstevel@tonic-gate bool_t cb_confirmed; 3157c478bd9Sstevel@tonic-gate uint32_t cb_ident; 3167c478bd9Sstevel@tonic-gate cb_client4 cb_callback; 3177c478bd9Sstevel@tonic-gate } cb_newer; 3187c478bd9Sstevel@tonic-gate } rfs4_cbinfo_t; 3197c478bd9Sstevel@tonic-gate 3207c478bd9Sstevel@tonic-gate /* 3217c478bd9Sstevel@tonic-gate * A server instance. We can associate sets of clients - via a pointer in 3227c478bd9Sstevel@tonic-gate * rfs4_client_t - with a given server instance, allowing us to treat clients 3237c478bd9Sstevel@tonic-gate * in the set differently to clients in other sets. 3247c478bd9Sstevel@tonic-gate * 3257c478bd9Sstevel@tonic-gate * Currently used only for Sun Cluster HA-NFS support, to group clients 3267c478bd9Sstevel@tonic-gate * on NFS resource failover so each set of clients gets its own dedicated 327cee86682Scalum * grace period and distributed stable storage data. 3287c478bd9Sstevel@tonic-gate */ 3297c478bd9Sstevel@tonic-gate typedef struct rfs4_servinst { 330cee86682Scalum int dss_npaths; 3317c478bd9Sstevel@tonic-gate krwlock_t rwlock; 332cee86682Scalum krwlock_t oldstate_lock; 3337c478bd9Sstevel@tonic-gate time_t start_time; 3347c478bd9Sstevel@tonic-gate time_t grace_period; 335cee86682Scalum rfs4_oldstate_t *oldstate; 336cee86682Scalum struct rfs4_dss_path **dss_paths; 3377c478bd9Sstevel@tonic-gate struct rfs4_servinst *next; 3387c478bd9Sstevel@tonic-gate struct rfs4_servinst *prev; 3397c478bd9Sstevel@tonic-gate } rfs4_servinst_t; 3407c478bd9Sstevel@tonic-gate 341cee86682Scalum /* 342cee86682Scalum * DSS: distributed stable storage 343cee86682Scalum */ 344cee86682Scalum 345cee86682Scalum typedef struct rfs4_dss_path { 346cee86682Scalum struct rfs4_dss_path *next; /* for insque/remque */ 347cee86682Scalum struct rfs4_dss_path *prev; /* for insque/remque */ 348cee86682Scalum char *path; 349cee86682Scalum struct rfs4_servinst *sip; 350cee86682Scalum unsigned index; /* offset in servinst's array */ 351cee86682Scalum } rfs4_dss_path_t; 352cee86682Scalum 353cee86682Scalum /* array of paths passed-in from nfsd command-line; stored in nvlist */ 354cee86682Scalum char **rfs4_dss_newpaths; 355cee86682Scalum uint_t rfs4_dss_numnewpaths; 356cee86682Scalum 357cee86682Scalum /* 358cee86682Scalum * Circular doubly-linked list of paths for currently-served RGs. 359cee86682Scalum * No locking required: only changed on warmstart. Managed with insque/remque. 360cee86682Scalum */ 361cee86682Scalum rfs4_dss_path_t *rfs4_dss_pathlist; 362cee86682Scalum 363cee86682Scalum /* nvlists of all DSS paths: current, and before last warmstart */ 364cee86682Scalum nvlist_t *rfs4_dss_paths, *rfs4_dss_oldpaths; 365cee86682Scalum 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. 4632f172c55SRobert Thurlow * no_referrals - set if the client is Solaris and pre-dates referrals 4647c478bd9Sstevel@tonic-gate * deleg_revoked - how many delegations have been revoked for this client? 4657c478bd9Sstevel@tonic-gate * 4667c478bd9Sstevel@tonic-gate * cp_confirmed - this refers to a confirmed client struct that has 4677c478bd9Sstevel@tonic-gate * the same nfs_client_id4 as this client struct. When/if this client 4687c478bd9Sstevel@tonic-gate * struct is confirmed via SETCLINETID_CONFIRM, the previously 4697c478bd9Sstevel@tonic-gate * confirmed client struct will be "closed" and hence this reference. 4707c478bd9Sstevel@tonic-gate * 4717c478bd9Sstevel@tonic-gate * last_access - used to determine if the client has let its lease expire 4727c478bd9Sstevel@tonic-gate * cbinfo - struct containing all callback related information 4737c478bd9Sstevel@tonic-gate * cr_set - credentials used for the SETCLIENTID/SETCLIENTID_CONFIRM pair 4747c478bd9Sstevel@tonic-gate * sysid - the lock manager sysid allocated for this client's file locks 4757c478bd9Sstevel@tonic-gate * openownerlist - root of openowners list associated with 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 { 481d216dff5SRobert Mastors rfs4_dbe_t *rc_dbe; 482d216dff5SRobert Mastors clientid4 rc_clientid; 483d216dff5SRobert Mastors nfs_client_id4 rc_nfs_client; 484d216dff5SRobert Mastors verifier4 rc_confirm_verf; 485d216dff5SRobert Mastors unsigned rc_need_confirm:1; 486d216dff5SRobert Mastors unsigned rc_unlksys_completed:1; 487d216dff5SRobert Mastors unsigned rc_can_reclaim:1; 488d216dff5SRobert Mastors unsigned rc_ss_remove:1; 489d216dff5SRobert Mastors unsigned rc_forced_expire:1; 490d216dff5SRobert Mastors uint_t rc_deleg_revoked; 491d216dff5SRobert Mastors struct rfs4_client *rc_cp_confirmed; 492d216dff5SRobert Mastors time_t rc_last_access; 493d216dff5SRobert Mastors rfs4_cbinfo_t rc_cbinfo; 494d216dff5SRobert Mastors cred_set_t rc_cr_set; 495d216dff5SRobert Mastors sysid_t rc_sysidt; 496d216dff5SRobert Mastors list_t rc_openownerlist; 497d216dff5SRobert Mastors rfs4_ss_pn_t *rc_ss_pn; 498d216dff5SRobert Mastors struct sockaddr_storage rc_addr; 499d216dff5SRobert Mastors rfs4_servinst_t *rc_server_instance; 5007c478bd9Sstevel@tonic-gate } rfs4_client_t; 5017c478bd9Sstevel@tonic-gate 5022f172c55SRobert Thurlow /* 5032f172c55SRobert Thurlow * ClntIP struct - holds the diagnosis about whether the client 5042f172c55SRobert Thurlow * cannot support referrals. Set to true for old Solaris clients. 5052f172c55SRobert Thurlow */ 5062f172c55SRobert Thurlow 5072f172c55SRobert Thurlow typedef struct rfs4_clntip { 5082f172c55SRobert Thurlow rfs4_dbe_t *ri_dbe; 5092f172c55SRobert Thurlow struct sockaddr_storage ri_addr; 5102f172c55SRobert Thurlow unsigned ri_no_referrals:1; 5112f172c55SRobert Thurlow } rfs4_clntip_t; 5122f172c55SRobert Thurlow 5137c478bd9Sstevel@tonic-gate /* 5147c478bd9Sstevel@tonic-gate * The openowner contains the client supplied open_owner4 as well as 5157c478bd9Sstevel@tonic-gate * the matching sequence id and is used to track the client's usage of 5167c478bd9Sstevel@tonic-gate * the open_owner4. Note that a reply is saved here as well for 5177c478bd9Sstevel@tonic-gate * processing of retransmissions. 5187c478bd9Sstevel@tonic-gate * 5197c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 5207c478bd9Sstevel@tonic-gate * client - reference to rfs4_client_t for this openowner 5217c478bd9Sstevel@tonic-gate * owner - actual client supplied open_owner4 5227c478bd9Sstevel@tonic-gate * need_confirm - does this openowner need to be OPEN_CONFIRMed 5237c478bd9Sstevel@tonic-gate * postpone_confirm - set if error received on first use of open_owner 5247c478bd9Sstevel@tonic-gate * state2confirm - what stateid4 should be used on the OPEN_CONFIRM 5257c478bd9Sstevel@tonic-gate * open_seqid - what is the next open_seqid expected for this openowner 5267c478bd9Sstevel@tonic-gate * oo_sw - used to serialize access to the open seqid/reply handling 5277c478bd9Sstevel@tonic-gate * cr_set - credential used for the OPEN 528d216dff5SRobert Mastors * statelist - root of state struct list associated with this openowner 529d216dff5SRobert Mastors * node - node for client struct list of openowners 5307c478bd9Sstevel@tonic-gate * reply_fh - open replay processing needs the filehandle so that it is 5317c478bd9Sstevel@tonic-gate * able to reset the current filehandle for appropriate compound 5327c478bd9Sstevel@tonic-gate * processing and reply. 5337c478bd9Sstevel@tonic-gate * reply - last reply sent in relation to this openowner 5347c478bd9Sstevel@tonic-gate */ 5357c478bd9Sstevel@tonic-gate typedef struct rfs4_openowner { 536d216dff5SRobert Mastors rfs4_dbe_t *ro_dbe; 537d216dff5SRobert Mastors rfs4_client_t *ro_client; 538d216dff5SRobert Mastors open_owner4 ro_owner; 539d216dff5SRobert Mastors unsigned ro_need_confirm:1; 540d216dff5SRobert Mastors unsigned ro_postpone_confirm:1; 541d216dff5SRobert Mastors seqid4 ro_open_seqid; 542d216dff5SRobert Mastors rfs4_state_wait_t ro_sw; 543d216dff5SRobert Mastors cred_set_t ro_cr_set; 544d216dff5SRobert Mastors list_t ro_statelist; 545d216dff5SRobert Mastors list_node_t ro_node; 546d216dff5SRobert Mastors nfs_fh4 ro_reply_fh; 547d216dff5SRobert Mastors nfs_resop4 ro_reply; 5487c478bd9Sstevel@tonic-gate } rfs4_openowner_t; 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate /* 5517c478bd9Sstevel@tonic-gate * This state struct represents the association between an openowner 5527c478bd9Sstevel@tonic-gate * and a file that has been OPENed by that openowner. 5537c478bd9Sstevel@tonic-gate * 5547c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 5557c478bd9Sstevel@tonic-gate * stateid - server provided stateid 5567c478bd9Sstevel@tonic-gate * owner - reference back to the openowner for this state 5577c478bd9Sstevel@tonic-gate * finfo - reference to the open file for this state 55850956b22SJames Wahlig * open_access - how did the openowner OPEN the file (access) 55950956b22SJames Wahlig * open_deny - how did the openowner OPEN the file (deny) 56050956b22SJames Wahlig * share_access - what share reservation is on the file (access) 56150956b22SJames Wahlig * share_deny - what share reservation is on the file (deny) 5627c478bd9Sstevel@tonic-gate * closed - has this file been closed? 563d216dff5SRobert Mastors * lostatelist - root of list of lo_state associated with this state/file 564d216dff5SRobert Mastors * node - node for state struct list of states 5657c478bd9Sstevel@tonic-gate */ 5667c478bd9Sstevel@tonic-gate typedef struct rfs4_state { 567d216dff5SRobert Mastors rfs4_dbe_t *rs_dbe; 568d216dff5SRobert Mastors stateid_t rs_stateid; 569d216dff5SRobert Mastors rfs4_openowner_t *rs_owner; 570d216dff5SRobert Mastors struct rfs4_file *rs_finfo; 57150956b22SJames Wahlig uint32_t rs_open_access; 57250956b22SJames Wahlig uint32_t rs_open_deny; 573d216dff5SRobert Mastors uint32_t rs_share_access; 574d216dff5SRobert Mastors uint32_t rs_share_deny; 575d216dff5SRobert Mastors unsigned rs_closed:1; 576d216dff5SRobert Mastors list_t rs_lostatelist; 577d216dff5SRobert Mastors list_node_t rs_node; 5787c478bd9Sstevel@tonic-gate } rfs4_state_t; 5797c478bd9Sstevel@tonic-gate 5807c478bd9Sstevel@tonic-gate /* 5817c478bd9Sstevel@tonic-gate * Lockowner - track the lockowner and its related info 5827c478bd9Sstevel@tonic-gate * 5837c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 5847c478bd9Sstevel@tonic-gate * client - reference to the client 5857c478bd9Sstevel@tonic-gate * owner - lockowner supplied by the client 5867c478bd9Sstevel@tonic-gate * pid - local identifier used for file locking 5877c478bd9Sstevel@tonic-gate */ 5887c478bd9Sstevel@tonic-gate typedef struct rfs4_lockowner { 589d216dff5SRobert Mastors rfs4_dbe_t *rl_dbe; 590d216dff5SRobert Mastors rfs4_client_t *rl_client; 591d216dff5SRobert Mastors lock_owner4 rl_owner; 592d216dff5SRobert Mastors pid_t rl_pid; 5937c478bd9Sstevel@tonic-gate } rfs4_lockowner_t; 5947c478bd9Sstevel@tonic-gate 5957c478bd9Sstevel@tonic-gate /* 5967c478bd9Sstevel@tonic-gate * Lockowner_state associated with a state struct and lockowner 5977c478bd9Sstevel@tonic-gate * 5987c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 5997c478bd9Sstevel@tonic-gate * state - reference back to state struct for open file 6007c478bd9Sstevel@tonic-gate * lockid - stateid for this lockowner/state 6017c478bd9Sstevel@tonic-gate * locker - reference to lockowner 6027c478bd9Sstevel@tonic-gate * seqid - sequence id for this lockowner/state 6037c478bd9Sstevel@tonic-gate * skip_seqid_check - used on initialization of struct 6047c478bd9Sstevel@tonic-gate * locks_cleaned - have all locks been released for this lockowner/file? 6057c478bd9Sstevel@tonic-gate * lock_completed - successful LOCK with lockowner/file? 6067c478bd9Sstevel@tonic-gate * ls_sw - used to serialize update seqid/reply/stateid handling 607d216dff5SRobert Mastors * node - node for state struct list of lo_states 6087c478bd9Sstevel@tonic-gate * reply - last reply sent in relation to this lockowner/state 6097c478bd9Sstevel@tonic-gate */ 6107c478bd9Sstevel@tonic-gate typedef struct rfs4_lo_state { 611d216dff5SRobert Mastors rfs4_dbe_t *rls_dbe; 612d216dff5SRobert Mastors rfs4_state_t *rls_state; 613d216dff5SRobert Mastors stateid_t rls_lockid; 614d216dff5SRobert Mastors rfs4_lockowner_t *rls_locker; 615d216dff5SRobert Mastors seqid4 rls_seqid; 616d216dff5SRobert Mastors unsigned rls_skip_seqid_check:1; 617d216dff5SRobert Mastors unsigned rls_locks_cleaned:1; 618d216dff5SRobert Mastors unsigned rls_lock_completed:1; 619d216dff5SRobert Mastors rfs4_state_wait_t rls_sw; 620d216dff5SRobert Mastors list_node_t rls_node; 621d216dff5SRobert Mastors nfs_resop4 rls_reply; 6227c478bd9Sstevel@tonic-gate } rfs4_lo_state_t; 6237c478bd9Sstevel@tonic-gate 6247c478bd9Sstevel@tonic-gate /* 6257c478bd9Sstevel@tonic-gate * Delegation state - per client 6267c478bd9Sstevel@tonic-gate * 6277c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 6287c478bd9Sstevel@tonic-gate * dtype - type of delegation (NONE, READ, WRITE) 6297c478bd9Sstevel@tonic-gate * delegid - stateid for this delegation 6307c478bd9Sstevel@tonic-gate * time_granted - time this delegation was assigned to client 6317c478bd9Sstevel@tonic-gate * time_recalled - time when the server started recall process 6327c478bd9Sstevel@tonic-gate * time_revoked - if revoked, time that the revoke occurred 6337c478bd9Sstevel@tonic-gate * finfo - reference to the file associated with this delegation 6347c478bd9Sstevel@tonic-gate * client - reference to client for which this delegation is associated 635d216dff5SRobert Mastors * node - list of delegations for the file (WRITE == 1, READ == ) 6367c478bd9Sstevel@tonic-gate */ 6377c478bd9Sstevel@tonic-gate typedef struct rfs4_deleg_state { 638d216dff5SRobert Mastors rfs4_dbe_t *rds_dbe; 639d216dff5SRobert Mastors open_delegation_type4 rds_dtype; 640d216dff5SRobert Mastors stateid_t rds_delegid; 641d216dff5SRobert Mastors time_t rds_time_granted; 642d216dff5SRobert Mastors time_t rds_time_recalled; 643d216dff5SRobert Mastors time_t rds_time_revoked; 644d216dff5SRobert Mastors struct rfs4_file *rds_finfo; 645d216dff5SRobert Mastors rfs4_client_t *rds_client; 646d216dff5SRobert Mastors list_node_t rds_node; 6477c478bd9Sstevel@tonic-gate } rfs4_deleg_state_t; 6487c478bd9Sstevel@tonic-gate 6497c478bd9Sstevel@tonic-gate /* 6507c478bd9Sstevel@tonic-gate * Delegation info associated with the file 6517c478bd9Sstevel@tonic-gate * 6527c478bd9Sstevel@tonic-gate * dtype - type of delegation for file (NONE, READ, WRITE) 6537c478bd9Sstevel@tonic-gate * time_returned - time that last delegation was returned for file 6547c478bd9Sstevel@tonic-gate * time_recalled - time that recall sequence started 6557c478bd9Sstevel@tonic-gate * time_lastgrant - time that last delegation was provided to a client 6567c478bd9Sstevel@tonic-gate * time_lastwrite - time of last write to use the delegation stateid 6577c478bd9Sstevel@tonic-gate * time_rm_delayed - time of last remove/rename which was DELAYed 6587c478bd9Sstevel@tonic-gate * rdgrants - how many read delegations have been provided for this file 6597c478bd9Sstevel@tonic-gate * wrgrants - how many write delegations provided (can only be one) 6607c478bd9Sstevel@tonic-gate * recall_count - how many recall threads are outstanding 6617c478bd9Sstevel@tonic-gate * recall_lock - lock to protect contents of this struct 6627c478bd9Sstevel@tonic-gate * recall_cv - condition var for the "parent" thread to wait upon 6637c478bd9Sstevel@tonic-gate * deleg_change_grant - value for change attribute at time of write grant 6647c478bd9Sstevel@tonic-gate * deleg_change - most recent value of change obtained from client 6657c478bd9Sstevel@tonic-gate * deleg_change_ts - time of last deleg_change update 6667c478bd9Sstevel@tonic-gate * ever_recalled - has this particular delegation ever been recalled? 6677c478bd9Sstevel@tonic-gate * dont_grant - file deletion is impending, don't grant a delegation 6687c478bd9Sstevel@tonic-gate * conflicted_client - clientid of the client that caused a CB_RECALL 6697c478bd9Sstevel@tonic-gate * to occur. This is used for delegation policy (should a delegation 6707c478bd9Sstevel@tonic-gate * be granted shortly after it has been returned?) 6717c478bd9Sstevel@tonic-gate */ 6727c478bd9Sstevel@tonic-gate typedef struct rfs4_dinfo { 673d216dff5SRobert Mastors open_delegation_type4 rd_dtype; 674d216dff5SRobert Mastors time_t rd_time_returned; 675d216dff5SRobert Mastors time_t rd_time_recalled; 676d216dff5SRobert Mastors time_t rd_time_lastgrant; 677d216dff5SRobert Mastors time_t rd_time_lastwrite; 678d216dff5SRobert Mastors time_t rd_time_rm_delayed; 679d216dff5SRobert Mastors uint32_t rd_rdgrants; 680d216dff5SRobert Mastors uint32_t rd_wrgrants; 681d216dff5SRobert Mastors int32_t rd_recall_count; 682d216dff5SRobert Mastors kmutex_t rd_recall_lock[1]; 683d216dff5SRobert Mastors kcondvar_t rd_recall_cv[1]; 684d216dff5SRobert Mastors bool_t rd_ever_recalled; 685d216dff5SRobert Mastors uint32_t rd_hold_grant; 686d216dff5SRobert Mastors clientid4 rd_conflicted_client; 6877c478bd9Sstevel@tonic-gate } rfs4_dinfo_t; 6887c478bd9Sstevel@tonic-gate 6897c478bd9Sstevel@tonic-gate /* 6907c478bd9Sstevel@tonic-gate * File 6917c478bd9Sstevel@tonic-gate * 6927c478bd9Sstevel@tonic-gate * dbe - encapsulation struct 6937c478bd9Sstevel@tonic-gate * vp - vnode for the file that is open or has a delegation 6947c478bd9Sstevel@tonic-gate * filehandle - the filehandle generated by the server for this file 695d216dff5SRobert Mastors * delegstatelist - root of delegation list for this file 6967c478bd9Sstevel@tonic-gate * dinfo - see struct definition above 6977c478bd9Sstevel@tonic-gate * share_deny - union of all deny modes on file 6987c478bd9Sstevel@tonic-gate * share_access - union of all access modes on file 6997c478bd9Sstevel@tonic-gate * access_read - count of read access 7007c478bd9Sstevel@tonic-gate * access_write - count of write access 7017c478bd9Sstevel@tonic-gate * deny_read - count of deny reads 7027c478bd9Sstevel@tonic-gate * deny_write - count of deny writes 7037c478bd9Sstevel@tonic-gate * file_rwlock - lock for serializing the removal of a file while 7047c478bd9Sstevel@tonic-gate * the state structures are active within the server 7057c478bd9Sstevel@tonic-gate * 7067c478bd9Sstevel@tonic-gate * The only requirement for locking file_rwlock is that the 7077c478bd9Sstevel@tonic-gate * caller have a reference to the containing rfs4_file. The dbe 7087c478bd9Sstevel@tonic-gate * lock may or may not be held for lock/unlock of file_rwlock. 7097c478bd9Sstevel@tonic-gate * As mentioned above, the file_rwlock is used for serialization 7107c478bd9Sstevel@tonic-gate * of file removal and more specifically reference to the held 7117c478bd9Sstevel@tonic-gate * vnode (e.g. vp). 7127c478bd9Sstevel@tonic-gate */ 7137c478bd9Sstevel@tonic-gate typedef struct rfs4_file { 714d216dff5SRobert Mastors rfs4_dbe_t *rf_dbe; 715d216dff5SRobert Mastors vnode_t *rf_vp; 716d216dff5SRobert Mastors nfs_fh4 rf_filehandle; 717d216dff5SRobert Mastors list_t rf_delegstatelist; 718d216dff5SRobert Mastors rfs4_dinfo_t rf_dinfo; 719d216dff5SRobert Mastors uint32_t rf_share_deny; 720d216dff5SRobert Mastors uint32_t rf_share_access; 721d216dff5SRobert Mastors uint32_t rf_access_read; 722d216dff5SRobert Mastors uint32_t rf_access_write; 723d216dff5SRobert Mastors uint32_t rf_deny_read; 724d216dff5SRobert Mastors uint32_t rf_deny_write; 725d216dff5SRobert Mastors krwlock_t rf_file_rwlock; 7267c478bd9Sstevel@tonic-gate } rfs4_file_t; 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate extern int rfs4_seen_first_compound; /* set first time we see one */ 7297c478bd9Sstevel@tonic-gate 7307c478bd9Sstevel@tonic-gate extern rfs4_servinst_t *rfs4_cur_servinst; /* current server instance */ 7317c478bd9Sstevel@tonic-gate extern kmutex_t rfs4_servinst_lock; /* protects linked list */ 732cee86682Scalum extern void rfs4_servinst_create(int, int, char **); 7337c478bd9Sstevel@tonic-gate extern void rfs4_servinst_destroy_all(void); 7347c478bd9Sstevel@tonic-gate extern void rfs4_servinst_assign(rfs4_client_t *, 7357c478bd9Sstevel@tonic-gate rfs4_servinst_t *); 7367c478bd9Sstevel@tonic-gate extern rfs4_servinst_t *rfs4_servinst(rfs4_client_t *); 7377c478bd9Sstevel@tonic-gate extern int rfs4_clnt_in_grace(rfs4_client_t *); 7387c478bd9Sstevel@tonic-gate extern int rfs4_servinst_in_grace(rfs4_servinst_t *); 7397c478bd9Sstevel@tonic-gate extern int rfs4_servinst_grace_new(rfs4_servinst_t *); 7407c478bd9Sstevel@tonic-gate extern void rfs4_grace_start(rfs4_servinst_t *); 7417c478bd9Sstevel@tonic-gate extern void rfs4_grace_start_new(void); 7427c478bd9Sstevel@tonic-gate extern void rfs4_grace_reset_all(void); 743cee86682Scalum extern void rfs4_ss_oldstate(rfs4_oldstate_t *, char *, char *); 744cee86682Scalum extern void rfs4_dss_readstate(int, char **); 7457c478bd9Sstevel@tonic-gate 7467c478bd9Sstevel@tonic-gate /* 7477c478bd9Sstevel@tonic-gate * rfs4_deleg_policy is used to signify the server's global delegation 7487c478bd9Sstevel@tonic-gate * policy. The default is to NEVER delegate files and the 7497c478bd9Sstevel@tonic-gate * administrator must configure the server to enable delegations. 7507c478bd9Sstevel@tonic-gate * 7517c478bd9Sstevel@tonic-gate * The disable/enable delegation functions are used to eliminate a 7527c478bd9Sstevel@tonic-gate * race with exclusive creates. 7537c478bd9Sstevel@tonic-gate */ 7547c478bd9Sstevel@tonic-gate typedef enum { 7557c478bd9Sstevel@tonic-gate SRV_NEVER_DELEGATE = 0, 7567c478bd9Sstevel@tonic-gate SRV_NORMAL_DELEGATE = 1 7577c478bd9Sstevel@tonic-gate } srv_deleg_policy_t; 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate extern srv_deleg_policy_t rfs4_deleg_policy; 7607c478bd9Sstevel@tonic-gate extern kmutex_t rfs4_deleg_lock; 7617c478bd9Sstevel@tonic-gate extern void rfs4_disable_delegation(void), rfs4_enable_delegation(void); 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate /* 7647c478bd9Sstevel@tonic-gate * Request types for delegation. These correspond with 7657c478bd9Sstevel@tonic-gate * open_delegation_type4 with the addition of a new value, DELEG_ANY, 7667c478bd9Sstevel@tonic-gate * to reqequest any delegation. 7677c478bd9Sstevel@tonic-gate */ 7687c478bd9Sstevel@tonic-gate typedef enum { 7697c478bd9Sstevel@tonic-gate DELEG_NONE = 0, /* Corresponds to OPEN_DELEG_NONE */ 7707c478bd9Sstevel@tonic-gate DELEG_READ = 1, /* Corresponds to OPEN_DELEG_READ */ 7717c478bd9Sstevel@tonic-gate DELEG_WRITE = 2, /* Corresponds to OPEN_DELEG_WRITE */ 7727c478bd9Sstevel@tonic-gate DELEG_ANY = -1 /* New value to request any delegation type */ 7737c478bd9Sstevel@tonic-gate } delegreq_t; 7747c478bd9Sstevel@tonic-gate 7757c478bd9Sstevel@tonic-gate #define NFS4_DELEG4TYPE2REQTYPE(x) (delegreq_t)(x) 7767c478bd9Sstevel@tonic-gate 7777c478bd9Sstevel@tonic-gate /* 7787c478bd9Sstevel@tonic-gate * Various interfaces to manipulate the state structures introduced 7797c478bd9Sstevel@tonic-gate * above 7807c478bd9Sstevel@tonic-gate */ 7817c478bd9Sstevel@tonic-gate extern kmutex_t rfs4_state_lock; 7827c478bd9Sstevel@tonic-gate extern void rfs4_clean_state_exi(struct exportinfo *exi); 7837c478bd9Sstevel@tonic-gate extern void rfs4_free_reply(nfs_resop4 *); 7847c478bd9Sstevel@tonic-gate extern void rfs4_copy_reply(nfs_resop4 *, nfs_resop4 *); 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate /* rfs4_client_t handling */ 7877c478bd9Sstevel@tonic-gate extern rfs4_client_t *rfs4_findclient(nfs_client_id4 *, 7887c478bd9Sstevel@tonic-gate bool_t *, rfs4_client_t *); 7897c478bd9Sstevel@tonic-gate extern rfs4_client_t *rfs4_findclient_by_id(clientid4, bool_t); 7902f172c55SRobert Thurlow extern rfs4_client_t *rfs4_findclient_by_addr(struct sockaddr *); 7917c478bd9Sstevel@tonic-gate extern void rfs4_client_rele(rfs4_client_t *); 7927c478bd9Sstevel@tonic-gate extern void rfs4_client_close(rfs4_client_t *); 7937c478bd9Sstevel@tonic-gate extern void rfs4_client_state_remove(rfs4_client_t *); 7947c478bd9Sstevel@tonic-gate extern void rfs4_client_scv_next(rfs4_client_t *); 7957c478bd9Sstevel@tonic-gate extern void rfs4_update_lease(rfs4_client_t *); 7967c478bd9Sstevel@tonic-gate extern bool_t rfs4_lease_expired(rfs4_client_t *); 7977c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_check_clientid(clientid4 *, int); 7987c478bd9Sstevel@tonic-gate 7992f172c55SRobert Thurlow /* rfs4_clntip_t handling */ 8002f172c55SRobert Thurlow extern rfs4_clntip_t *rfs4_find_clntip(struct sockaddr *, bool_t *); 8012f172c55SRobert Thurlow extern void rfs4_invalidate_clntip(struct sockaddr *); 8022f172c55SRobert Thurlow 8037c478bd9Sstevel@tonic-gate /* rfs4_openowner_t handling */ 8047c478bd9Sstevel@tonic-gate extern rfs4_openowner_t *rfs4_findopenowner(open_owner4 *, bool_t *, seqid4); 8057c478bd9Sstevel@tonic-gate extern void rfs4_update_open_sequence(rfs4_openowner_t *); 8067c478bd9Sstevel@tonic-gate extern void rfs4_update_open_resp(rfs4_openowner_t *, 8077c478bd9Sstevel@tonic-gate nfs_resop4 *, nfs_fh4 *); 8087c478bd9Sstevel@tonic-gate extern void rfs4_openowner_rele(rfs4_openowner_t *); 8097c478bd9Sstevel@tonic-gate extern void rfs4_free_opens(rfs4_openowner_t *, bool_t, bool_t); 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate /* rfs4_lockowner_t handling */ 8127c478bd9Sstevel@tonic-gate extern rfs4_lockowner_t *rfs4_findlockowner(lock_owner4 *, bool_t *); 8137c478bd9Sstevel@tonic-gate extern rfs4_lockowner_t *rfs4_findlockowner_by_pid(pid_t); 8147c478bd9Sstevel@tonic-gate extern void rfs4_lockowner_rele(rfs4_lockowner_t *); 8157c478bd9Sstevel@tonic-gate 8167c478bd9Sstevel@tonic-gate /* rfs4_state_t handling */ 8177c478bd9Sstevel@tonic-gate extern rfs4_state_t *rfs4_findstate_by_owner_file(rfs4_openowner_t *, 8187c478bd9Sstevel@tonic-gate rfs4_file_t *, bool_t *); 8197c478bd9Sstevel@tonic-gate extern void rfs4_state_rele(rfs4_state_t *); 8207c478bd9Sstevel@tonic-gate extern void rfs4_state_close(rfs4_state_t *, bool_t, 8217c478bd9Sstevel@tonic-gate bool_t, cred_t *); 8227c478bd9Sstevel@tonic-gate extern void rfs4_release_share_lock_state(rfs4_state_t *, 8237c478bd9Sstevel@tonic-gate cred_t *, bool_t); 8247c478bd9Sstevel@tonic-gate extern void rfs4_close_all_state(rfs4_file_t *); 8257c478bd9Sstevel@tonic-gate 8267c478bd9Sstevel@tonic-gate /* rfs4_lo_state_t handling */ 8277c478bd9Sstevel@tonic-gate extern rfs4_lo_state_t *rfs4_findlo_state_by_owner(rfs4_lockowner_t *, 8287c478bd9Sstevel@tonic-gate rfs4_state_t *, bool_t *); 8297c478bd9Sstevel@tonic-gate extern void rfs4_lo_state_rele(rfs4_lo_state_t *, bool_t); 8307c478bd9Sstevel@tonic-gate extern void rfs4_update_lock_sequence(rfs4_lo_state_t *); 8317c478bd9Sstevel@tonic-gate extern void rfs4_update_lock_resp(rfs4_lo_state_t *, 8327c478bd9Sstevel@tonic-gate nfs_resop4 *); 8337c478bd9Sstevel@tonic-gate 8347c478bd9Sstevel@tonic-gate /* rfs4_file_t handling */ 8357c478bd9Sstevel@tonic-gate extern rfs4_file_t *rfs4_findfile(vnode_t *, nfs_fh4 *, bool_t *); 8367c478bd9Sstevel@tonic-gate extern rfs4_file_t *rfs4_findfile_withlock(vnode_t *, nfs_fh4 *, 8377c478bd9Sstevel@tonic-gate bool_t *); 8387c478bd9Sstevel@tonic-gate extern void rfs4_file_rele(rfs4_file_t *); 8397c478bd9Sstevel@tonic-gate 8407c478bd9Sstevel@tonic-gate /* General collection of "get state" functions */ 8417c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_get_state(stateid4 *, rfs4_state_t **, 8427c478bd9Sstevel@tonic-gate rfs4_dbsearch_type_t); 8437c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_get_deleg_state(stateid4 *, 8447c478bd9Sstevel@tonic-gate rfs4_deleg_state_t **); 8457c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_get_lo_state(stateid4 *, rfs4_lo_state_t **, 8467c478bd9Sstevel@tonic-gate bool_t); 8477c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_check_stateid(int, vnode_t *, stateid4 *, 848da6c28aaSamw bool_t, bool_t *, bool_t, 849da6c28aaSamw caller_context_t *); 8507c478bd9Sstevel@tonic-gate extern int rfs4_check_stateid_seqid(rfs4_state_t *, stateid4 *); 8517c478bd9Sstevel@tonic-gate extern int rfs4_check_lo_stateid_seqid(rfs4_lo_state_t *, 8527c478bd9Sstevel@tonic-gate stateid4 *); 8537c478bd9Sstevel@tonic-gate 8547c478bd9Sstevel@tonic-gate /* return values for rfs4_check_stateid_seqid() */ 8557c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_OKAY 1 8567c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_OLD 2 8577c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_BAD 3 8587c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_EXPIRED 4 8597c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_REPLAY 5 8607c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_CLOSED 6 8617c478bd9Sstevel@tonic-gate #define NFS4_CHECK_STATEID_UNCONFIRMED 7 8627c478bd9Sstevel@tonic-gate 8637c478bd9Sstevel@tonic-gate /* delay() time that server is willing to briefly wait for a delegreturn */ 8647c478bd9Sstevel@tonic-gate #define NFS4_DELEGATION_CONFLICT_DELAY (hz/10) 8657c478bd9Sstevel@tonic-gate 8667c478bd9Sstevel@tonic-gate /* 8677c478bd9Sstevel@tonic-gate * Interfaces for handling of callback's client handle cache and 8687c478bd9Sstevel@tonic-gate * callback interfaces themselves. 8697c478bd9Sstevel@tonic-gate */ 8707c478bd9Sstevel@tonic-gate extern void rfs4_cbinfo_free(rfs4_cbinfo_t *); 8717c478bd9Sstevel@tonic-gate extern void rfs4_client_setcb(rfs4_client_t *, cb_client4 *, 8727c478bd9Sstevel@tonic-gate uint32_t); 8737c478bd9Sstevel@tonic-gate extern void rfs4_deleg_cb_check(rfs4_client_t *); 8747c478bd9Sstevel@tonic-gate extern nfsstat4 rfs4_vop_getattr(vnode_t *, vattr_t *, int, cred_t *); 8757c478bd9Sstevel@tonic-gate 8767c478bd9Sstevel@tonic-gate /* rfs4_deleg_state_t handling and other delegation interfaces */ 8777c478bd9Sstevel@tonic-gate extern rfs4_deleg_state_t *rfs4_finddeleg(rfs4_state_t *, bool_t *); 8787c478bd9Sstevel@tonic-gate extern rfs4_deleg_state_t *rfs4_finddelegstate(stateid_t *); 8797c478bd9Sstevel@tonic-gate extern bool_t rfs4_check_recall(rfs4_state_t *, uint32_t); 8807c478bd9Sstevel@tonic-gate extern void rfs4_recall_deleg(rfs4_file_t *, 8817c478bd9Sstevel@tonic-gate bool_t, rfs4_client_t *); 8827c478bd9Sstevel@tonic-gate extern int rfs4_get_deleg(rfs4_state_t *, open_delegation_type4, 8837c478bd9Sstevel@tonic-gate open_delegation_type4 (*policy)(rfs4_state_t *, 8847c478bd9Sstevel@tonic-gate open_delegation_type4 dtype)); 8857c478bd9Sstevel@tonic-gate extern rfs4_deleg_state_t *rfs4_grant_delegation(delegreq_t, rfs4_state_t *, 8867c478bd9Sstevel@tonic-gate int *); 8877c478bd9Sstevel@tonic-gate extern void rfs4_set_deleg_response(rfs4_deleg_state_t *, 8887c478bd9Sstevel@tonic-gate open_delegation4 *, nfsace4 *, int); 8897c478bd9Sstevel@tonic-gate extern void rfs4_return_deleg(rfs4_deleg_state_t *, bool_t); 8907c478bd9Sstevel@tonic-gate extern bool_t rfs4_is_deleg(rfs4_state_t *); 8917c478bd9Sstevel@tonic-gate extern void rfs4_deleg_state_rele(rfs4_deleg_state_t *); 8927c478bd9Sstevel@tonic-gate extern bool_t rfs4_check_delegated_byfp(int, rfs4_file_t *, 8937c478bd9Sstevel@tonic-gate bool_t, bool_t, bool_t, clientid4 *); 8947c478bd9Sstevel@tonic-gate extern void rfs4_clear_dont_grant(rfs4_file_t *); 8957c478bd9Sstevel@tonic-gate 8967c478bd9Sstevel@tonic-gate /* 8977c478bd9Sstevel@tonic-gate * nfs4 monitored operations. 8987c478bd9Sstevel@tonic-gate */ 899cfae96c2Sjwahlig extern int deleg_rd_open(femarg_t *, int, cred_t *, caller_context_t *); 900cfae96c2Sjwahlig extern int deleg_wr_open(femarg_t *, int, cred_t *, caller_context_t *); 901cfae96c2Sjwahlig extern int deleg_wr_read(femarg_t *, uio_t *, int, cred_t *, 902cfae96c2Sjwahlig caller_context_t *); 903cfae96c2Sjwahlig extern int deleg_rd_write(femarg_t *, uio_t *, int, cred_t *, 904cfae96c2Sjwahlig caller_context_t *); 905cfae96c2Sjwahlig extern int deleg_wr_write(femarg_t *, uio_t *, int, cred_t *, 906cfae96c2Sjwahlig caller_context_t *); 907cfae96c2Sjwahlig extern int deleg_rd_setattr(femarg_t *, vattr_t *, int, cred_t *, 908cfae96c2Sjwahlig caller_context_t *); 909cfae96c2Sjwahlig extern int deleg_wr_setattr(femarg_t *, vattr_t *, int, cred_t *, 910cfae96c2Sjwahlig caller_context_t *); 9117c478bd9Sstevel@tonic-gate extern int deleg_rd_rwlock(femarg_t *, int, caller_context_t *); 9127c478bd9Sstevel@tonic-gate extern int deleg_wr_rwlock(femarg_t *, int, caller_context_t *); 913cfae96c2Sjwahlig extern int deleg_rd_space(femarg_t *, int, flock64_t *, int, offset_t, cred_t *, 914cfae96c2Sjwahlig caller_context_t *); 915cfae96c2Sjwahlig extern int deleg_wr_space(femarg_t *, int, flock64_t *, int, offset_t, cred_t *, 916cfae96c2Sjwahlig caller_context_t *); 917cfae96c2Sjwahlig extern int deleg_rd_setsecattr(femarg_t *, vsecattr_t *, int, cred_t *, 9187c478bd9Sstevel@tonic-gate caller_context_t *); 919cfae96c2Sjwahlig extern int deleg_wr_setsecattr(femarg_t *, vsecattr_t *, int, cred_t *, 9207c478bd9Sstevel@tonic-gate caller_context_t *); 921cfae96c2Sjwahlig extern int deleg_rd_vnevent(femarg_t *, vnevent_t, vnode_t *, char *, 922da6c28aaSamw caller_context_t *); 923cfae96c2Sjwahlig extern int deleg_wr_vnevent(femarg_t *, vnevent_t, vnode_t *, char *, 924da6c28aaSamw caller_context_t *); 9257c478bd9Sstevel@tonic-gate 9267c478bd9Sstevel@tonic-gate extern void rfs4_mon_hold(void *); 9277c478bd9Sstevel@tonic-gate extern void rfs4_mon_rele(void *); 9287c478bd9Sstevel@tonic-gate 9297c478bd9Sstevel@tonic-gate extern fem_t *deleg_rdops; 9307c478bd9Sstevel@tonic-gate extern fem_t *deleg_wrops; 9317c478bd9Sstevel@tonic-gate 932d216dff5SRobert Mastors extern int rfs4_share(rfs4_state_t *, uint32_t, uint32_t); 933d216dff5SRobert Mastors extern int rfs4_unshare(rfs4_state_t *); 9347c478bd9Sstevel@tonic-gate extern void rfs4_set_deleg_policy(srv_deleg_policy_t); 9357c478bd9Sstevel@tonic-gate #ifdef DEBUG 9367c478bd9Sstevel@tonic-gate #define NFS4_DEBUG(var, args) if (var) cmn_err args 9377c478bd9Sstevel@tonic-gate 9387c478bd9Sstevel@tonic-gate extern int rfs4_debug; 9397c478bd9Sstevel@tonic-gate extern int nfs4_client_attr_debug; 9407c478bd9Sstevel@tonic-gate extern int nfs4_client_state_debug; 9417c478bd9Sstevel@tonic-gate extern int nfs4_client_shadow_debug; 9427c478bd9Sstevel@tonic-gate extern int nfs4_client_lock_debug; 9437c478bd9Sstevel@tonic-gate extern int nfs4_client_lease_debug; 9447c478bd9Sstevel@tonic-gate extern int nfs4_seqid_sync; 9457c478bd9Sstevel@tonic-gate extern int nfs4_client_map_debug; 9467c478bd9Sstevel@tonic-gate extern int nfs4_client_inactive_debug; 9477c478bd9Sstevel@tonic-gate extern int nfs4_client_recov_debug; 9487c478bd9Sstevel@tonic-gate extern int nfs4_client_failover_debug; 9497c478bd9Sstevel@tonic-gate extern int nfs4_client_call_debug; 9507c478bd9Sstevel@tonic-gate extern int nfs4_client_foo_debug; 9517c478bd9Sstevel@tonic-gate extern int nfs4_client_zone_debug; 9527c478bd9Sstevel@tonic-gate extern int nfs4_lost_rqst_debug; 9537c478bd9Sstevel@tonic-gate extern int nfs4_open_stream_debug; 9547c478bd9Sstevel@tonic-gate extern int nfs4_client_open_dg; 9557c478bd9Sstevel@tonic-gate extern int nfs4_srvmnt_debug; 9567c478bd9Sstevel@tonic-gate extern int nfs4_utf8_debug; 9577c478bd9Sstevel@tonic-gate 9587c478bd9Sstevel@tonic-gate void rfs4_dbe_debug(rfs4_dbe_t *e); 9597c478bd9Sstevel@tonic-gate 9607c478bd9Sstevel@tonic-gate #ifdef NFS4_DEBUG_MUTEX 9617c478bd9Sstevel@tonic-gate void nfs4_debug_mutex_enter(kmutex_t *, char *, int); 9627c478bd9Sstevel@tonic-gate void nfs4_debug_mutex_exit(kmutex_t *, char *, int); 9637c478bd9Sstevel@tonic-gate 9647c478bd9Sstevel@tonic-gate #define mutex_enter(m) nfs4_debug_mutex_enter((m), __FILE__, __LINE__) 9657c478bd9Sstevel@tonic-gate #define mutex_exit(m) nfs4_debug_mutex_exit((m), __FILE__, __LINE__) 9667c478bd9Sstevel@tonic-gate #endif /* NFS4_DEBUG_MUTEX */ 9677c478bd9Sstevel@tonic-gate 9687c478bd9Sstevel@tonic-gate #else /* ! DEBUG */ 9697c478bd9Sstevel@tonic-gate #define NFS4_DEBUG(var, args) 9707c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 9717c478bd9Sstevel@tonic-gate 9727c478bd9Sstevel@tonic-gate /* 9737c478bd9Sstevel@tonic-gate * XXX - temporary for testing of volatile fh 9747c478bd9Sstevel@tonic-gate */ 9757c478bd9Sstevel@tonic-gate 9767c478bd9Sstevel@tonic-gate #ifdef VOLATILE_FH_TEST 9777c478bd9Sstevel@tonic-gate 9787c478bd9Sstevel@tonic-gate struct nfs_fh4_fmt { 97927242a7cSthurlow fhandle4_t fh4_i; 9807c46fb7fSek uint32_t fh4_flag; 9817c46fb7fSek uint32_t fh4_volatile_id; 9827c478bd9Sstevel@tonic-gate }; 9837c478bd9Sstevel@tonic-gate 9847c478bd9Sstevel@tonic-gate #else /* VOLATILE_FH_TEST */ 9857c478bd9Sstevel@tonic-gate 9867c478bd9Sstevel@tonic-gate struct nfs_fh4_fmt { 98727242a7cSthurlow fhandle4_t fh4_i; 9887c46fb7fSek uint32_t fh4_flag; 9897c478bd9Sstevel@tonic-gate }; 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate #endif /* VOLATILE_FH_TEST */ 9927c478bd9Sstevel@tonic-gate 9937c478bd9Sstevel@tonic-gate #define FH4_NAMEDATTR 1 9947c478bd9Sstevel@tonic-gate #define FH4_ATTRDIR 2 9957c478bd9Sstevel@tonic-gate 9967c46fb7fSek #define fh4_fsid fh4_i.fhx_fsid 9977c46fb7fSek #define fh4_len fh4_i.fhx_len /* fid length */ 9987c46fb7fSek #define fh4_data fh4_i.fhx_data /* fid bytes */ 9997c46fb7fSek #define fh4_xlen fh4_i.fhx_xlen 10007c46fb7fSek #define fh4_xdata fh4_i.fhx_xdata 10017c478bd9Sstevel@tonic-gate typedef struct nfs_fh4_fmt nfs_fh4_fmt_t; 10027c478bd9Sstevel@tonic-gate 10037c478bd9Sstevel@tonic-gate #define fh4_to_fmt4(fh4p) ((nfs_fh4_fmt_t *)(fh4p)->nfs_fh4_val) 10047c478bd9Sstevel@tonic-gate #define get_fh4_flag(fh4p, flag) ((fh4_to_fmt4(fh4p)->fh4_flag) & (flag)) 10057c478bd9Sstevel@tonic-gate #define set_fh4_flag(fh4p, flag) ((fh4_to_fmt4(fh4p)->fh4_flag) |= (flag)) 10067c478bd9Sstevel@tonic-gate #define clr_fh4_flag(fh4p, flag) ((fh4_to_fmt4(fh4p)->fh4_flag) &= ~(flag)) 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate #define NFS_FH4_LEN sizeof (nfs_fh4_fmt_t) 10097c478bd9Sstevel@tonic-gate 1010b096b66cSnr /* 1011b096b66cSnr * Copy fields from external (fhandle_t) to in-memory (nfs_fh4_fmt_t) 1012b096b66cSnr * format to support export info checking. It does not copy over 1013b096b66cSnr * the complete filehandle, just the fsid, xlen and xdata. It may 1014b096b66cSnr * need to be changed to be used in other places. 1015b096b66cSnr * 1016b096b66cSnr * NOTE: The macro expects the space to be pre-allocated for 1017b096b66cSnr * the contents of nfs_fh4_fmt_t. 1018b096b66cSnr */ 1019b096b66cSnr #define FH_TO_FMT4(exifh, nfs_fmt) { \ 1020b096b66cSnr bzero((nfs_fmt), NFS_FH4_LEN); \ 1021b096b66cSnr (nfs_fmt)->fh4_fsid = (exifh)->fh_fsid; \ 1022b096b66cSnr (nfs_fmt)->fh4_xlen = (exifh)->fh_xlen; \ 1023b096b66cSnr bcopy((exifh)->fh_xdata, (nfs_fmt)->fh4_xdata, \ 1024b096b66cSnr (exifh)->fh_xlen); \ 1025b096b66cSnr } 10267c478bd9Sstevel@tonic-gate 10277c478bd9Sstevel@tonic-gate /* 10287c478bd9Sstevel@tonic-gate * A few definitions of repeatedly used constructs for nfsv4 10297c478bd9Sstevel@tonic-gate */ 10307c478bd9Sstevel@tonic-gate #define UTF8STRING_FREE(str) \ 10317c478bd9Sstevel@tonic-gate kmem_free((str).utf8string_val, (str).utf8string_len); \ 10327c478bd9Sstevel@tonic-gate (str).utf8string_val = NULL; \ 10337c478bd9Sstevel@tonic-gate (str).utf8string_len = 0; 10347c478bd9Sstevel@tonic-gate 10357c478bd9Sstevel@tonic-gate /* 10367c478bd9Sstevel@tonic-gate * NFS4_VOLATILE_FH yields non-zero if the filesystem uses non-persistent 10377c478bd9Sstevel@tonic-gate * filehandles. 10387c478bd9Sstevel@tonic-gate */ 10397c478bd9Sstevel@tonic-gate #define NFS4_VOLATILE_FH(mi) \ 10407c478bd9Sstevel@tonic-gate ((mi)->mi_fh_expire_type & \ 10417c478bd9Sstevel@tonic-gate (FH4_VOLATILE_ANY | FH4_VOL_MIGRATION | FH4_VOL_RENAME)) 10427c478bd9Sstevel@tonic-gate 10437c478bd9Sstevel@tonic-gate /* 10447c478bd9Sstevel@tonic-gate * NFS_IS_DOTNAME checks if the name given represents a dot or dotdot entry 10457c478bd9Sstevel@tonic-gate */ 10467c478bd9Sstevel@tonic-gate #define NFS_IS_DOTNAME(name) \ 10477c478bd9Sstevel@tonic-gate (((name)[0] == '.') && \ 10487c478bd9Sstevel@tonic-gate (((name)[1] == '\0') || (((name)[1] == '.') && ((name)[2] == '\0')))) 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate /* 10517c478bd9Sstevel@tonic-gate * Define the number of bits in a bitmap word (uint32) 10527c478bd9Sstevel@tonic-gate */ 10537c478bd9Sstevel@tonic-gate #define NFS4_BITMAP4_BITSPERWORD (sizeof (uint32_t) * 8) 10547c478bd9Sstevel@tonic-gate 10557c478bd9Sstevel@tonic-gate /* 10567c478bd9Sstevel@tonic-gate * Define the value for the access field of the compound_state structure 10577c478bd9Sstevel@tonic-gate * based on the result of nfsauth access checking. 10587c478bd9Sstevel@tonic-gate */ 10597c478bd9Sstevel@tonic-gate #define CS_ACCESS_OK 0x1 10607c478bd9Sstevel@tonic-gate #define CS_ACCESS_DENIED 0x2 10617c478bd9Sstevel@tonic-gate #define CS_ACCESS_LIMITED 0x4 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate /* 10647c478bd9Sstevel@tonic-gate * compound state in nfsv4 server 10657c478bd9Sstevel@tonic-gate */ 10667c478bd9Sstevel@tonic-gate struct compound_state { 10677c478bd9Sstevel@tonic-gate struct exportinfo *exi; 10687c478bd9Sstevel@tonic-gate struct exportinfo *saved_exi; /* export struct for saved_vp */ 10697c478bd9Sstevel@tonic-gate cred_t *basecr; /* UNIX cred: only RPC request */ 10707c478bd9Sstevel@tonic-gate caddr_t principal; 10717c478bd9Sstevel@tonic-gate int nfsflavor; 10727c478bd9Sstevel@tonic-gate cred_t *cr; /* UNIX cred: RPC request and */ 10737c478bd9Sstevel@tonic-gate /* target export */ 10747c478bd9Sstevel@tonic-gate bool_t cont; 10757c478bd9Sstevel@tonic-gate uint_t access; /* access perm on vp per request */ 10767c478bd9Sstevel@tonic-gate bool_t deleg; /* TRUE if current fh has */ 10777c478bd9Sstevel@tonic-gate /* write delegated */ 10787c478bd9Sstevel@tonic-gate vnode_t *vp; /* modified by PUTFH, and by ops that */ 10797c478bd9Sstevel@tonic-gate /* input to GETFH */ 10807c478bd9Sstevel@tonic-gate bool_t mandlock; /* Is mandatory locking in effect */ 10817c478bd9Sstevel@tonic-gate /* for vp */ 10827c478bd9Sstevel@tonic-gate vnode_t *saved_vp; /* modified by SAVEFH, copied to */ 10837c478bd9Sstevel@tonic-gate /* vp by RESTOREFH */ 10847c478bd9Sstevel@tonic-gate nfsstat4 *statusp; 10857c478bd9Sstevel@tonic-gate nfs_fh4 fh; /* ditto. valid only if vp != NULL */ 10867c478bd9Sstevel@tonic-gate nfs_fh4 saved_fh; /* ditto. valid only if */ 10877c478bd9Sstevel@tonic-gate /* saved_vp != NULL */ 10887c478bd9Sstevel@tonic-gate struct svc_req *req; 10897c478bd9Sstevel@tonic-gate char fhbuf[NFS4_FHSIZE]; 10907c478bd9Sstevel@tonic-gate }; 10917c478bd9Sstevel@tonic-gate 10927c478bd9Sstevel@tonic-gate /* 10937c478bd9Sstevel@tonic-gate * Conversion commands for nfsv4 server attr checking 10947c478bd9Sstevel@tonic-gate */ 10957c478bd9Sstevel@tonic-gate enum nfs4_attr_cmd { 10967c478bd9Sstevel@tonic-gate NFS4ATTR_SUPPORTED = 0, /* check which attrs supported */ 10977c478bd9Sstevel@tonic-gate NFS4ATTR_GETIT = 1, /* getattr - sys to fattr4 (r) */ 10987c478bd9Sstevel@tonic-gate NFS4ATTR_SETIT = 2, /* setattr - fattr4 to sys (w) */ 10997c478bd9Sstevel@tonic-gate NFS4ATTR_VERIT = 3, /* verify - fattr4 to sys (r) */ 11007c478bd9Sstevel@tonic-gate NFS4ATTR_FREEIT = 4 /* free any alloc'd space for attr */ 11017c478bd9Sstevel@tonic-gate }; 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate typedef enum nfs4_attr_cmd nfs4_attr_cmd_t; 11047c478bd9Sstevel@tonic-gate 11057c478bd9Sstevel@tonic-gate struct nfs4_svgetit_arg { 11067c478bd9Sstevel@tonic-gate nfs4_attr_cmd_t op; /* getit or setit */ 11077c478bd9Sstevel@tonic-gate struct compound_state *cs; 11087c478bd9Sstevel@tonic-gate struct statvfs64 *sbp; 11097c478bd9Sstevel@tonic-gate uint_t flag; /* VOP_GETATTR/VOP_SETATTR flag */ 11107c478bd9Sstevel@tonic-gate uint_t xattr; /* object is xattr */ 11117c478bd9Sstevel@tonic-gate bool_t rdattr_error_req; /* if readdir & client wants */ 11127c478bd9Sstevel@tonic-gate /* rdattr_error */ 11137c478bd9Sstevel@tonic-gate nfsstat4 rdattr_error; /* used for per-entry status */ 11147c478bd9Sstevel@tonic-gate /* (if rdattr_err) */ 11152f172c55SRobert Thurlow bool_t is_referral; /* because sometimes we tell lies */ 11167c478bd9Sstevel@tonic-gate bool_t mntdfid_set; 11177c478bd9Sstevel@tonic-gate fattr4_mounted_on_fileid 11187c478bd9Sstevel@tonic-gate mounted_on_fileid; 11197c478bd9Sstevel@tonic-gate /* readdir op can always return */ 11207c478bd9Sstevel@tonic-gate /* d_ino from server fs dirent */ 11217c478bd9Sstevel@tonic-gate /* for mounted_on_fileid attr. */ 11227c478bd9Sstevel@tonic-gate /* This field holds d_ino so */ 11237c478bd9Sstevel@tonic-gate /* srv attr conv code can avoid */ 11247c478bd9Sstevel@tonic-gate /* doing an untraverse. */ 11257c478bd9Sstevel@tonic-gate vattr_t vap[1]; 11267c478bd9Sstevel@tonic-gate }; 11277c478bd9Sstevel@tonic-gate 11287c478bd9Sstevel@tonic-gate struct nfs4_ntov_map { 11297c478bd9Sstevel@tonic-gate bitmap4 fbit; /* FATTR4_XXX_MASKY */ 11307c478bd9Sstevel@tonic-gate uint_t vbit; /* AT_XXX */ 11317c478bd9Sstevel@tonic-gate bool_t vfsstat; 11327c478bd9Sstevel@tonic-gate bool_t mandatory; /* attribute mandatory to implement? */ 11337c478bd9Sstevel@tonic-gate uint_t nval; 11347c478bd9Sstevel@tonic-gate int xdr_size; /* Size of XDR'd attr */ 11357c478bd9Sstevel@tonic-gate xdrproc_t xfunc; 11367c478bd9Sstevel@tonic-gate int (*sv_getit)(nfs4_attr_cmd_t, struct nfs4_svgetit_arg *, 11377c478bd9Sstevel@tonic-gate union nfs4_attr_u *); /* subroutine for getting attr. */ 11387c478bd9Sstevel@tonic-gate char *prtstr; /* string attr for printing */ 11397c478bd9Sstevel@tonic-gate }; 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate struct nfs4attr_to_vattr { 11427c478bd9Sstevel@tonic-gate vnode_t *vp; 11437c478bd9Sstevel@tonic-gate vattr_t *vap; 11447c478bd9Sstevel@tonic-gate nfs_fh4 *fhp; 11457c478bd9Sstevel@tonic-gate nfsstat4 rdattr_error; 11467c478bd9Sstevel@tonic-gate uint32_t flag; 11477c478bd9Sstevel@tonic-gate fattr4_change change; 11487c478bd9Sstevel@tonic-gate fattr4_fsid srv_fsid; 11497c478bd9Sstevel@tonic-gate fattr4_mounted_on_fileid mntd_fid; 11507c478bd9Sstevel@tonic-gate }; 11517c478bd9Sstevel@tonic-gate 11527c478bd9Sstevel@tonic-gate typedef struct nfs4attr_to_vattr ntov4_t; 11537c478bd9Sstevel@tonic-gate 11547c478bd9Sstevel@tonic-gate /* 11557c478bd9Sstevel@tonic-gate * nfs4attr_to_vattr flags 11567c478bd9Sstevel@tonic-gate */ 11577c478bd9Sstevel@tonic-gate #define NTOV_FHP_VALID 0x01 11587c478bd9Sstevel@tonic-gate #define NTOV_RDATTR_ERROR_VALID 0x02 11597c478bd9Sstevel@tonic-gate #define NTOV_CHANGE_VALID 0x04 11607c478bd9Sstevel@tonic-gate #define NTOV_SUPP_VALID 0x08 11617c478bd9Sstevel@tonic-gate #define NTOV_SRV_FSID_VALID 0x10 11627c478bd9Sstevel@tonic-gate #define NTOV_MOUNTED_ON_FILEID_VALID 0x20 11637c478bd9Sstevel@tonic-gate 11647c478bd9Sstevel@tonic-gate 11657c478bd9Sstevel@tonic-gate #define FATTR4_MANDATTR_MASK ( \ 11667c478bd9Sstevel@tonic-gate FATTR4_SUPPORTED_ATTRS_MASK | \ 11677c478bd9Sstevel@tonic-gate FATTR4_TYPE_MASK | \ 11687c478bd9Sstevel@tonic-gate FATTR4_FH_EXPIRE_TYPE_MASK | \ 11697c478bd9Sstevel@tonic-gate FATTR4_CHANGE_MASK | \ 11707c478bd9Sstevel@tonic-gate FATTR4_SIZE_MASK | \ 11717c478bd9Sstevel@tonic-gate FATTR4_LINK_SUPPORT_MASK | \ 11727c478bd9Sstevel@tonic-gate FATTR4_SYMLINK_SUPPORT_MASK | \ 11737c478bd9Sstevel@tonic-gate FATTR4_NAMED_ATTR_MASK | \ 11747c478bd9Sstevel@tonic-gate FATTR4_FSID_MASK | \ 11757c478bd9Sstevel@tonic-gate FATTR4_UNIQUE_HANDLES_MASK | \ 11767c478bd9Sstevel@tonic-gate FATTR4_LEASE_TIME_MASK | \ 11777c478bd9Sstevel@tonic-gate FATTR4_RDATTR_ERROR_MASK | \ 11787c478bd9Sstevel@tonic-gate FATTR4_FILEHANDLE_MASK) 11797c478bd9Sstevel@tonic-gate 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate struct nfs4attr_to_osattr { 11827c478bd9Sstevel@tonic-gate void *attrconv_arg; 11837c478bd9Sstevel@tonic-gate uint_t mask; 11847c478bd9Sstevel@tonic-gate }; 11857c478bd9Sstevel@tonic-gate 11867c478bd9Sstevel@tonic-gate struct mntinfo4; 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate /* 11897c478bd9Sstevel@tonic-gate * lkp4_attr_setup lists the different options for attributes when calling 11907c478bd9Sstevel@tonic-gate * nfs4lookup_setup - either no attributes (just lookups - e.g., secinfo), 11917c478bd9Sstevel@tonic-gate * one component only (normal component lookup), get attributes for the 11927c478bd9Sstevel@tonic-gate * last component (e.g., mount), attributes for each component (e.g., 11937c478bd9Sstevel@tonic-gate * failovers later), just the filehandle for the last component (e.g., 11947c478bd9Sstevel@tonic-gate * volatile filehandle recovery), or stuff that needs OPENATTR (e.g. 11957c478bd9Sstevel@tonic-gate * looking up a named attribute or it's hidden directory). 11967c478bd9Sstevel@tonic-gate */ 11977c478bd9Sstevel@tonic-gate enum lkp4_attr_setup { 11987c478bd9Sstevel@tonic-gate LKP4_NO_ATTRIBUTES = 0, /* no attrs or filehandles */ 11997c478bd9Sstevel@tonic-gate LKP4_ALL_ATTRIBUTES = 3, /* multi-comp: attrs for all comps */ 12007c478bd9Sstevel@tonic-gate LKP4_LAST_NAMED_ATTR = 5, /* multi-comp: named attr & attrdir */ 12017c478bd9Sstevel@tonic-gate LKP4_LAST_ATTRDIR = 6, /* multi-comp: just attrdir */ 12027c478bd9Sstevel@tonic-gate LKP4_ALL_ATTR_SECINFO = 7 /* multi-comp: attrs for all comp and */ 12037c478bd9Sstevel@tonic-gate /* secinfo for last comp */ 12047c478bd9Sstevel@tonic-gate }; 12057c478bd9Sstevel@tonic-gate 12067c478bd9Sstevel@tonic-gate /* 12077c478bd9Sstevel@tonic-gate * lookup4_param a set of parameters to nfs4lookup_setup - 12087c478bd9Sstevel@tonic-gate * used to setup a path lookup compound request. 12097c478bd9Sstevel@tonic-gate */ 12107c478bd9Sstevel@tonic-gate typedef struct lookup4_param { 12117c478bd9Sstevel@tonic-gate enum lkp4_attr_setup l4_getattrs; /* (in) get attrs in the lookup? */ 12127c478bd9Sstevel@tonic-gate int header_len; /* (in) num ops before first lookup */ 12137c478bd9Sstevel@tonic-gate int trailer_len; /* (in) num ops after last */ 12147c478bd9Sstevel@tonic-gate /* Lookup/Getattr */ 12157c478bd9Sstevel@tonic-gate bitmap4 ga_bits; /* (in) Which attributes for Getattr */ 12167c478bd9Sstevel@tonic-gate COMPOUND4args_clnt *argsp; /* (in/out) args for compound struct */ 12177c478bd9Sstevel@tonic-gate COMPOUND4res_clnt *resp; /* (in/out) res for compound struct */ 12187c478bd9Sstevel@tonic-gate int arglen; /* (out) argop buffer alloc'd length */ 12197c478bd9Sstevel@tonic-gate struct mntinfo4 *mi; 12207c478bd9Sstevel@tonic-gate } lookup4_param_t; 12217c478bd9Sstevel@tonic-gate 12227c478bd9Sstevel@tonic-gate 12237c478bd9Sstevel@tonic-gate #define NFS4_FATTR4_FINISH -1 /* fattr4 index indicating finish */ 12247c478bd9Sstevel@tonic-gate 12257c478bd9Sstevel@tonic-gate typedef int (*nfs4attr_to_os_t)(int, union nfs4_attr_u *, 12267c478bd9Sstevel@tonic-gate struct nfs4attr_to_osattr *); 12277c478bd9Sstevel@tonic-gate 12287c478bd9Sstevel@tonic-gate /* 12297c478bd9Sstevel@tonic-gate * The nfs4_error_t is the basic structure to return error values 12307c478bd9Sstevel@tonic-gate * from rfs4call. It encapsulates the unix errno 12317c478bd9Sstevel@tonic-gate * value, the nfsstat4 value and the rpc status value into a single 12327c478bd9Sstevel@tonic-gate * structure. 12337c478bd9Sstevel@tonic-gate * 12347c478bd9Sstevel@tonic-gate * If error is set, then stat is ignored and rpc_status may be 12357c478bd9Sstevel@tonic-gate * set if the error occurred as the result of a CLNT_CALL. If 12367c478bd9Sstevel@tonic-gate * stat is set, then rpc request succeeded, error and 12377c478bd9Sstevel@tonic-gate * rpc_status are set to 0 and stat contains the result of 12387c478bd9Sstevel@tonic-gate * operation, NFS4_OK or one of the NFS4ERR_* values. 12397c478bd9Sstevel@tonic-gate * 12407c478bd9Sstevel@tonic-gate * Functions which want to generate errors independently from 12417c478bd9Sstevel@tonic-gate * rfs4call should set error to the desired errno value and 12427c478bd9Sstevel@tonic-gate * set stat and rpc_status to 0. nfs4_error_init() is a 12437c478bd9Sstevel@tonic-gate * convenient function to do this. 12447c478bd9Sstevel@tonic-gate */ 12457c478bd9Sstevel@tonic-gate typedef struct { 12467c478bd9Sstevel@tonic-gate int error; 12477c478bd9Sstevel@tonic-gate nfsstat4 stat; 12487c478bd9Sstevel@tonic-gate enum clnt_stat rpc_status; 12497c478bd9Sstevel@tonic-gate } nfs4_error_t; 12507c478bd9Sstevel@tonic-gate 12517c478bd9Sstevel@tonic-gate /* 12527c478bd9Sstevel@tonic-gate * Shared functions 12537c478bd9Sstevel@tonic-gate */ 12547c478bd9Sstevel@tonic-gate extern void rfs4_op_readdir(nfs_argop4 *, nfs_resop4 *, 12557c478bd9Sstevel@tonic-gate struct svc_req *, struct compound_state *); 12567c478bd9Sstevel@tonic-gate extern void nfs_fh4_copy(nfs_fh4 *, nfs_fh4 *); 12577c478bd9Sstevel@tonic-gate 12587c478bd9Sstevel@tonic-gate extern void nfs4_fattr4_free(fattr4 *); 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate extern int nfs4lookup_setup(char *, lookup4_param_t *, int); 12617c478bd9Sstevel@tonic-gate extern void nfs4_getattr_otw_norecovery(vnode_t *, 12627c478bd9Sstevel@tonic-gate nfs4_ga_res_t *, nfs4_error_t *, cred_t *, int); 12637c478bd9Sstevel@tonic-gate extern int nfs4_getattr_otw(vnode_t *, nfs4_ga_res_t *, cred_t *, int); 12647c478bd9Sstevel@tonic-gate extern int nfs4cmpfh(const nfs_fh4 *, const nfs_fh4 *); 12657c478bd9Sstevel@tonic-gate extern int nfs4cmpfhandle(nfs4_fhandle_t *, nfs4_fhandle_t *); 12667c478bd9Sstevel@tonic-gate extern int nfs4getattr(vnode_t *, struct vattr *, cred_t *); 12677c478bd9Sstevel@tonic-gate extern int nfs4_waitfor_purge_complete(vnode_t *); 12687c478bd9Sstevel@tonic-gate extern int nfs4_validate_caches(vnode_t *, cred_t *); 12697c478bd9Sstevel@tonic-gate extern int nfs4init(int, char *); 12707c478bd9Sstevel@tonic-gate extern void nfs4fini(void); 12717c478bd9Sstevel@tonic-gate extern int nfs4_vfsinit(void); 12727c478bd9Sstevel@tonic-gate extern void nfs4_vfsfini(void); 12737c478bd9Sstevel@tonic-gate 12747c478bd9Sstevel@tonic-gate extern void nfs4_vnops_init(void); 12757c478bd9Sstevel@tonic-gate extern void nfs4_vnops_fini(void); 12767c478bd9Sstevel@tonic-gate extern void nfs_idmap_init(void); 12777c478bd9Sstevel@tonic-gate extern void nfs_idmap_flush(int); 12787c478bd9Sstevel@tonic-gate extern void nfs_idmap_fini(void); 12797c478bd9Sstevel@tonic-gate extern int nfs4_rnode_init(void); 12807c478bd9Sstevel@tonic-gate extern int nfs4_rnode_fini(void); 12817c478bd9Sstevel@tonic-gate extern int nfs4_shadow_init(void); 12827c478bd9Sstevel@tonic-gate extern int nfs4_shadow_fini(void); 12837c478bd9Sstevel@tonic-gate extern int nfs4_acache_init(void); 12847c478bd9Sstevel@tonic-gate extern int nfs4_acache_fini(void); 12857c478bd9Sstevel@tonic-gate extern int nfs4_subr_init(void); 12867c478bd9Sstevel@tonic-gate extern int nfs4_subr_fini(void); 12877c478bd9Sstevel@tonic-gate extern void nfs4_acl_init(void); 12887c478bd9Sstevel@tonic-gate extern void nfs4_acl_free_cache(vsecattr_t *); 12897c478bd9Sstevel@tonic-gate 12907c478bd9Sstevel@tonic-gate extern int geterrno4(nfsstat4); 12917c478bd9Sstevel@tonic-gate extern nfsstat4 puterrno4(int); 12927c478bd9Sstevel@tonic-gate extern int nfs4_need_to_bump_seqid(COMPOUND4res_clnt *); 12937c478bd9Sstevel@tonic-gate extern int nfs4tsize(void); 12947c478bd9Sstevel@tonic-gate extern int checkauth4(struct compound_state *, struct svc_req *); 12957c478bd9Sstevel@tonic-gate extern nfsstat4 call_checkauth4(struct compound_state *, struct svc_req *); 12967c478bd9Sstevel@tonic-gate extern int is_exported_sec(int, struct exportinfo *); 12977c478bd9Sstevel@tonic-gate extern void nfs4_vmask_to_nmask(uint_t, bitmap4 *); 12989720e166Sjasmith extern void nfs4_vmask_to_nmask_set(uint_t, bitmap4 *); 12997c478bd9Sstevel@tonic-gate extern int nfs_idmap_str_uid(utf8string *u8s, uid_t *, bool_t); 13007c478bd9Sstevel@tonic-gate extern int nfs_idmap_str_gid(utf8string *u8s, gid_t *, bool_t); 13017c478bd9Sstevel@tonic-gate extern int nfs_idmap_uid_str(uid_t, utf8string *u8s, bool_t); 13027c478bd9Sstevel@tonic-gate extern int nfs_idmap_gid_str(gid_t gid, utf8string *u8s, bool_t); 13037c478bd9Sstevel@tonic-gate extern int nfs4_time_ntov(nfstime4 *, timestruc_t *); 13047c478bd9Sstevel@tonic-gate extern int nfs4_time_vton(timestruc_t *, nfstime4 *); 13057c478bd9Sstevel@tonic-gate extern char *utf8_to_str(utf8string *, uint_t *, char *); 13067c478bd9Sstevel@tonic-gate extern char *utf8_to_fn(utf8string *, uint_t *, char *); 13077c478bd9Sstevel@tonic-gate extern utf8string *str_to_utf8(char *, utf8string *); 13087c478bd9Sstevel@tonic-gate extern utf8string *utf8_copy(utf8string *, utf8string *); 13097c478bd9Sstevel@tonic-gate extern int utf8_compare(const utf8string *, const utf8string *); 13107c478bd9Sstevel@tonic-gate extern int utf8_dir_verify(utf8string *); 13117c478bd9Sstevel@tonic-gate extern char *utf8_strchr(utf8string *, const char); 13127c478bd9Sstevel@tonic-gate extern int ln_ace4_cmp(nfsace4 *, nfsace4 *, int); 13137c478bd9Sstevel@tonic-gate extern int vs_aent_to_ace4(vsecattr_t *, vsecattr_t *, int, int); 13147c478bd9Sstevel@tonic-gate extern int vs_ace4_to_aent(vsecattr_t *, vsecattr_t *, uid_t, gid_t, 1315fa9e4066Sahrens int, int); 1316*e913d9ecSLisa Week extern int vs_ace4_to_acet(vsecattr_t *, vsecattr_t *, uid_t, gid_t, 1317*e913d9ecSLisa Week int); 1318fa9e4066Sahrens extern int vs_acet_to_ace4(vsecattr_t *, vsecattr_t *, int); 13197c478bd9Sstevel@tonic-gate extern void vs_acet_destroy(vsecattr_t *); 13207c478bd9Sstevel@tonic-gate extern void vs_ace4_destroy(vsecattr_t *); 13217c478bd9Sstevel@tonic-gate extern void vs_aent_destroy(vsecattr_t *); 13227c478bd9Sstevel@tonic-gate 13232f172c55SRobert Thurlow extern int vn_find_nfs_record(vnode_t *, nvlist_t **, char **, char **); 13242f172c55SRobert Thurlow extern int vn_is_nfs_reparse(vnode_t *, cred_t *); 13252f172c55SRobert Thurlow extern fs_locations4 *fetch_referral(vnode_t *, cred_t *); 13262f172c55SRobert Thurlow extern char *build_symlink(vnode_t *, cred_t *, size_t *); 13272f172c55SRobert Thurlow 13287c478bd9Sstevel@tonic-gate extern int stateid4_cmp(stateid4 *, stateid4 *); 13297c478bd9Sstevel@tonic-gate 13307c478bd9Sstevel@tonic-gate extern vtype_t nf4_to_vt[]; 13317c478bd9Sstevel@tonic-gate 13327c478bd9Sstevel@tonic-gate extern struct nfs4_ntov_map nfs4_ntov_map[]; 13337c478bd9Sstevel@tonic-gate extern uint_t nfs4_ntov_map_size; 13347c478bd9Sstevel@tonic-gate 13357c478bd9Sstevel@tonic-gate extern kstat_named_t *rfsproccnt_v4_ptr; 13367c478bd9Sstevel@tonic-gate extern struct vfsops *nfs4_vfsops; 13377c478bd9Sstevel@tonic-gate extern struct vnodeops *nfs4_vnodeops; 13387c478bd9Sstevel@tonic-gate extern const struct fs_operation_def nfs4_vnodeops_template[]; 1339b9238976Sth extern vnodeops_t *nfs4_trigger_vnodeops; 1340b9238976Sth extern const struct fs_operation_def nfs4_trigger_vnodeops_template[]; 13417c478bd9Sstevel@tonic-gate 13427c478bd9Sstevel@tonic-gate extern uint_t nfs4_tsize(struct knetconfig *); 13437c478bd9Sstevel@tonic-gate extern uint_t rfs4_tsize(struct svc_req *); 13447c478bd9Sstevel@tonic-gate 1345eac3aab7Srobinson extern bool_t xdr_inline_decode_nfs_fh4(uint32_t *, nfs_fh4_fmt_t *, 1346eac3aab7Srobinson uint32_t); 13477c46fb7fSek extern bool_t xdr_inline_encode_nfs_fh4(uint32_t **, uint32_t *, 13487c46fb7fSek nfs_fh4_fmt_t *); 13497c46fb7fSek 13507c478bd9Sstevel@tonic-gate #ifdef DEBUG 13517c478bd9Sstevel@tonic-gate extern int rfs4_do_pre_op_attr; 13527c478bd9Sstevel@tonic-gate extern int rfs4_do_post_op_attr; 13537c478bd9Sstevel@tonic-gate #endif 13547c478bd9Sstevel@tonic-gate 13557c478bd9Sstevel@tonic-gate extern stateid4 clnt_special0; 13567c478bd9Sstevel@tonic-gate extern stateid4 clnt_special1; 13577c478bd9Sstevel@tonic-gate #define CLNT_ISSPECIAL(id) (stateid4_cmp(id, &clnt_special0) || \ 13587c478bd9Sstevel@tonic-gate stateid4_cmp(id, &clnt_special1)) 13597c478bd9Sstevel@tonic-gate 13607c478bd9Sstevel@tonic-gate /* 13617c478bd9Sstevel@tonic-gate * The NFS Version 4 service procedures. 13627c478bd9Sstevel@tonic-gate */ 13637c478bd9Sstevel@tonic-gate 13647c478bd9Sstevel@tonic-gate extern void rfs4_compound(COMPOUND4args *, COMPOUND4res *, 13652e9d26a4Srmesta struct exportinfo *, struct svc_req *, cred_t *, int *); 13667c478bd9Sstevel@tonic-gate extern void rfs4_compound_free(COMPOUND4res *); 13677c478bd9Sstevel@tonic-gate extern void rfs4_compound_flagproc(COMPOUND4args *, int *); 13687c478bd9Sstevel@tonic-gate 13697c478bd9Sstevel@tonic-gate extern int rfs4_srvrinit(void); 13707c478bd9Sstevel@tonic-gate extern void rfs4_srvrfini(void); 13717c478bd9Sstevel@tonic-gate extern void rfs4_state_init(void); 13727c478bd9Sstevel@tonic-gate extern void rfs4_state_fini(void); 13737c478bd9Sstevel@tonic-gate 13747c478bd9Sstevel@tonic-gate #endif 13757c478bd9Sstevel@tonic-gate #ifdef __cplusplus 13767c478bd9Sstevel@tonic-gate } 13777c478bd9Sstevel@tonic-gate #endif 13787c478bd9Sstevel@tonic-gate 13797c478bd9Sstevel@tonic-gate #endif /* _NFS4_H */ 1380