1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 27 /* All Rights Reserved */ 28 29 /* 30 * Portions of this source code were derived from Berkeley 4.3 BSD 31 * under license from the Regents of the University of California. 32 */ 33 34 #ifndef _NFS4_CLNT_H 35 #define _NFS4_CLNT_H 36 37 #pragma ident "%Z%%M% %I% %E% SMI" 38 39 #include <sys/errno.h> 40 #include <sys/types.h> 41 #include <sys/kstat.h> 42 #include <sys/time.h> 43 #include <sys/flock.h> 44 #include <vm/page.h> 45 #include <nfs/nfs4_kprot.h> 46 #include <nfs/nfs4.h> 47 #include <nfs/rnode.h> 48 #include <sys/avl.h> 49 #include <sys/list.h> 50 51 #ifdef __cplusplus 52 extern "C" { 53 #endif 54 55 #define NFS4_SIZE_OK(size) ((size) <= MAXOFFSET_T) 56 57 /* Four states of nfs4_server's lease_valid */ 58 #define NFS4_LEASE_INVALID 0 59 #define NFS4_LEASE_VALID 1 60 #define NFS4_LEASE_UNINITIALIZED 2 61 #define NFS4_LEASE_NOT_STARTED 3 62 63 /* flag to tell the renew thread it should exit */ 64 #define NFS4_THREAD_EXIT 1 65 66 /* Default number of seconds to wait on GRACE and DELAY errors */ 67 #define NFS4ERR_DELAY_TIME 10 68 69 /* Number of hash buckets for open owners for each nfs4_server */ 70 #define NFS4_NUM_OO_BUCKETS 53 71 72 /* Number of freed open owners (per mntinfo4_t) to keep around */ 73 #define NFS4_NUM_FREED_OPEN_OWNERS 8 74 75 /* Number of seconds to wait before retrying a SETCLIENTID(_CONFIRM) op */ 76 #define NFS4_RETRY_SCLID_DELAY 10 77 78 /* Number of times we should retry a SETCLIENTID(_CONFIRM) op */ 79 #define NFS4_NUM_SCLID_RETRIES 3 80 81 /* Number of times we should retry on open after getting NFS4ERR_BAD_SEQID */ 82 #define NFS4_NUM_RETRY_BAD_SEQID 3 83 84 /* 85 * Is the attribute cache valid? If client holds a delegation, then attrs 86 * are by definition valid. If not, then check to see if attrs have timed out. 87 */ 88 #define ATTRCACHE4_VALID(vp) (VTOR4(vp)->r_deleg_type != OPEN_DELEGATE_NONE || \ 89 gethrtime() < VTOR4(vp)->r_time_attr_inval) 90 91 /* 92 * Flags to indicate whether to purge the DNLC for non-directory vnodes 93 * in a call to nfs_purge_caches. 94 */ 95 #define NFS4_NOPURGE_DNLC 0 96 #define NFS4_PURGE_DNLC 1 97 98 /* 99 * Is cache valid? 100 * Swap is always valid, if no attributes (attrtime == 0) or 101 * if mtime matches cached mtime it is valid 102 * NOTE: mtime is now a timestruc_t. 103 * Caller should be holding the rnode r_statelock mutex. 104 */ 105 #define CACHE4_VALID(rp, mtime, fsize) \ 106 ((RTOV4(rp)->v_flag & VISSWAP) == VISSWAP || \ 107 (((mtime).tv_sec == (rp)->r_attr.va_mtime.tv_sec && \ 108 (mtime).tv_nsec == (rp)->r_attr.va_mtime.tv_nsec) && \ 109 ((fsize) == (rp)->r_attr.va_size))) 110 111 /* 112 * Macro to detect forced unmount or a zone shutdown. 113 */ 114 #define FS_OR_ZONE_GONE4(vfsp) \ 115 (((vfsp)->vfs_flag & VFS_UNMOUNTED) || \ 116 zone_status_get(curproc->p_zone) >= ZONE_IS_SHUTTING_DOWN) 117 118 /* 119 * Macro to help determine whether a request failed because the underlying 120 * filesystem has been forcibly unmounted or because of zone shutdown. 121 */ 122 #define NFS4_FRC_UNMT_ERR(err, vfsp) \ 123 ((err) == EIO && FS_OR_ZONE_GONE4((vfsp))) 124 125 /* 126 * Due to the way the address space callbacks are used to execute a delmap, 127 * we must keep track of how many times the same thread has called 128 * VOP_DELMAP()->nfs4_delmap(). This is done by having a list of 129 * nfs4_delmapcall_t's associated with each rnode4_t. This list is protected 130 * by the rnode4_t's r_statelock. The individual elements do not need to be 131 * protected as they will only ever be created, modified and destroyed by 132 * one thread (the call_id). 133 * See nfs4_delmap() for further explanation. 134 */ 135 typedef struct nfs4_delmapcall { 136 kthread_t *call_id; 137 int error; /* error from delmap */ 138 list_node_t call_node; 139 } nfs4_delmapcall_t; 140 141 /* 142 * delmap address space callback args 143 */ 144 typedef struct nfs4_delmap_args { 145 vnode_t *vp; 146 offset_t off; 147 caddr_t addr; 148 size_t len; 149 uint_t prot; 150 uint_t maxprot; 151 uint_t flags; 152 cred_t *cr; 153 nfs4_delmapcall_t *caller; /* to retrieve errors from the cb */ 154 } nfs4_delmap_args_t; 155 156 /* 157 * client side statistics 158 */ 159 /* 160 * Per-zone counters 161 */ 162 struct clstat4 { 163 kstat_named_t calls; /* client requests */ 164 kstat_named_t badcalls; /* rpc failures */ 165 kstat_named_t clgets; /* client handle gets */ 166 kstat_named_t cltoomany; /* client handle cache misses */ 167 #ifdef DEBUG 168 kstat_named_t clalloc; /* number of client handles */ 169 kstat_named_t noresponse; /* server not responding cnt */ 170 kstat_named_t failover; /* server failover count */ 171 kstat_named_t remap; /* server remap count */ 172 #endif 173 }; 174 175 #ifdef DEBUG 176 /* 177 * The following are statistics that describe the behavior of the system as a 178 * whole and don't correspond to any particular zone. 179 */ 180 struct clstat4_debug { 181 kstat_named_t nrnode; /* number of allocated rnodes */ 182 kstat_named_t access; /* size of access cache */ 183 kstat_named_t dirent; /* size of readdir cache */ 184 kstat_named_t dirents; /* size of readdir buf cache */ 185 kstat_named_t reclaim; /* number of reclaims */ 186 kstat_named_t clreclaim; /* number of cl reclaims */ 187 kstat_named_t f_reclaim; /* number of free reclaims */ 188 kstat_named_t a_reclaim; /* number of active reclaims */ 189 kstat_named_t r_reclaim; /* number of rnode reclaims */ 190 kstat_named_t rpath; /* bytes used to store rpaths */ 191 }; 192 extern struct clstat4_debug clstat4_debug; 193 194 #endif 195 196 /* 197 * The NFS specific async_reqs structure. 198 */ 199 200 enum iotype4 { 201 NFS4_READ_AHEAD, 202 NFS4_PUTAPAGE, 203 NFS4_PAGEIO, 204 NFS4_READDIR, 205 NFS4_INACTIVE, 206 NFS4_COMMIT 207 }; 208 #define NFS4_ASYNC_TYPES (NFS4_COMMIT + 1) 209 210 struct nfs4_async_read_req { 211 void (*readahead)(); /* pointer to readahead function */ 212 u_offset_t blkoff; /* offset in file */ 213 struct seg *seg; /* segment to do i/o to */ 214 caddr_t addr; /* address to do i/o to */ 215 }; 216 217 struct nfs4_pageio_req { 218 int (*pageio)(); /* pointer to pageio function */ 219 page_t *pp; /* page list */ 220 u_offset_t io_off; /* offset in file */ 221 uint_t io_len; /* size of request */ 222 int flags; 223 }; 224 225 struct nfs4_readdir_req { 226 int (*readdir)(); /* pointer to readdir function */ 227 struct rddir4_cache *rdc; /* pointer to cache entry to fill */ 228 }; 229 230 struct nfs4_commit_req { 231 void (*commit)(); /* pointer to commit function */ 232 page_t *plist; /* page list */ 233 offset4 offset; /* starting offset */ 234 count4 count; /* size of range to be commited */ 235 }; 236 237 struct nfs4_async_reqs { 238 struct nfs4_async_reqs *a_next; /* pointer to next arg struct */ 239 #ifdef DEBUG 240 kthread_t *a_queuer; /* thread id of queueing thread */ 241 #endif 242 struct vnode *a_vp; /* vnode pointer */ 243 struct cred *a_cred; /* cred pointer */ 244 enum iotype4 a_io; /* i/o type */ 245 union { 246 struct nfs4_async_read_req a_read_args; 247 struct nfs4_pageio_req a_pageio_args; 248 struct nfs4_readdir_req a_readdir_args; 249 struct nfs4_commit_req a_commit_args; 250 } a_args; 251 }; 252 253 #define a_nfs4_readahead a_args.a_read_args.readahead 254 #define a_nfs4_blkoff a_args.a_read_args.blkoff 255 #define a_nfs4_seg a_args.a_read_args.seg 256 #define a_nfs4_addr a_args.a_read_args.addr 257 258 #define a_nfs4_putapage a_args.a_pageio_args.pageio 259 #define a_nfs4_pageio a_args.a_pageio_args.pageio 260 #define a_nfs4_pp a_args.a_pageio_args.pp 261 #define a_nfs4_off a_args.a_pageio_args.io_off 262 #define a_nfs4_len a_args.a_pageio_args.io_len 263 #define a_nfs4_flags a_args.a_pageio_args.flags 264 265 #define a_nfs4_readdir a_args.a_readdir_args.readdir 266 #define a_nfs4_rdc a_args.a_readdir_args.rdc 267 268 #define a_nfs4_commit a_args.a_commit_args.commit 269 #define a_nfs4_plist a_args.a_commit_args.plist 270 #define a_nfs4_offset a_args.a_commit_args.offset 271 #define a_nfs4_count a_args.a_commit_args.count 272 273 /* 274 * Security information 275 */ 276 typedef struct sv_secinfo { 277 uint_t count; /* how many sdata there are */ 278 uint_t index; /* which sdata[index] */ 279 struct sec_data *sdata; 280 } sv_secinfo_t; 281 282 /* 283 * Hash bucket for the mi's open owner list (mi_oo_list). 284 */ 285 typedef struct nfs4_oo_hash_bucket { 286 list_t b_oo_hash_list; 287 kmutex_t b_lock; 288 } nfs4_oo_hash_bucket_t; 289 290 /* 291 * Global array of ctags. 292 */ 293 extern ctag_t nfs4_ctags[]; 294 295 typedef enum nfs4_tag_type { 296 TAG_NONE, 297 TAG_ACCESS, 298 TAG_CLOSE, 299 TAG_CLOSE_LOST, 300 TAG_CLOSE_UNDO, 301 TAG_COMMIT, 302 TAG_DELEGRETURN, 303 TAG_FSINFO, 304 TAG_GET_SYMLINK, 305 TAG_GETATTR, 306 TAG_INACTIVE, 307 TAG_LINK, 308 TAG_LOCK, 309 TAG_LOCK_RECLAIM, 310 TAG_LOCK_RESEND, 311 TAG_LOCK_REINSTATE, 312 TAG_LOCK_UNKNOWN, 313 TAG_LOCKT, 314 TAG_LOCKU, 315 TAG_LOCKU_RESEND, 316 TAG_LOCKU_REINSTATE, 317 TAG_LOOKUP, 318 TAG_LOOKUP_PARENT, 319 TAG_LOOKUP_VALID, 320 TAG_LOOKUP_VPARENT, 321 TAG_MKDIR, 322 TAG_MKNOD, 323 TAG_MOUNT, 324 TAG_OPEN, 325 TAG_OPEN_CONFIRM, 326 TAG_OPEN_CONFIRM_LOST, 327 TAG_OPEN_DG, 328 TAG_OPEN_DG_LOST, 329 TAG_OPEN_LOST, 330 TAG_OPENATTR, 331 TAG_PATHCONF, 332 TAG_PUTROOTFH, 333 TAG_READ, 334 TAG_READAHEAD, 335 TAG_READDIR, 336 TAG_READLINK, 337 TAG_RELOCK, 338 TAG_REMAP_LOOKUP, 339 TAG_REMAP_LOOKUP_AD, 340 TAG_REMAP_LOOKUP_NA, 341 TAG_REMAP_MOUNT, 342 TAG_RMDIR, 343 TAG_REMOVE, 344 TAG_RENAME, 345 TAG_RENAME_VFH, 346 TAG_RENEW, 347 TAG_REOPEN, 348 TAG_REOPEN_LOST, 349 TAG_SECINFO, 350 TAG_SETATTR, 351 TAG_SETCLIENTID, 352 TAG_SETCLIENTID_CF, 353 TAG_SYMLINK, 354 TAG_WRITE 355 } nfs4_tag_type_t; 356 357 #define NFS4_TAG_INITIALIZER { \ 358 {TAG_NONE, "", \ 359 {0x20202020, 0x20202020, 0x20202020}}, \ 360 {TAG_ACCESS, "access", \ 361 {0x61636365, 0x73732020, 0x20202020}}, \ 362 {TAG_CLOSE, "close", \ 363 {0x636c6f73, 0x65202020, 0x20202020}}, \ 364 {TAG_CLOSE_LOST, "lost close", \ 365 {0x6c6f7374, 0x20636c6f, 0x73652020}}, \ 366 {TAG_CLOSE_UNDO, "undo close", \ 367 {0x756e646f, 0x20636c6f, 0x73652020}}, \ 368 {TAG_COMMIT, "commit", \ 369 {0x636f6d6d, 0x69742020, 0x20202020}}, \ 370 {TAG_DELEGRETURN, "delegreturn", \ 371 {0x64656c65, 0x67726574, 0x75726e20}}, \ 372 {TAG_FSINFO, "fsinfo", \ 373 {0x6673696e, 0x666f2020, 0x20202020}}, \ 374 {TAG_GET_SYMLINK, "get symlink text", \ 375 {0x67657420, 0x736c6e6b, 0x20747874}}, \ 376 {TAG_GETATTR, "getattr", \ 377 {0x67657461, 0x74747220, 0x20202020}}, \ 378 {TAG_INACTIVE, "inactive", \ 379 {0x696e6163, 0x74697665, 0x20202020}}, \ 380 {TAG_LINK, "link", \ 381 {0x6c696e6b, 0x20202020, 0x20202020}}, \ 382 {TAG_LOCK, "lock", \ 383 {0x6c6f636b, 0x20202020, 0x20202020}}, \ 384 {TAG_LOCK_RECLAIM, "reclaim lock", \ 385 {0x7265636c, 0x61696d20, 0x6c6f636b}}, \ 386 {TAG_LOCK_RESEND, "resend lock", \ 387 {0x72657365, 0x6e64206c, 0x6f636b20}}, \ 388 {TAG_LOCK_REINSTATE, "reinstate lock", \ 389 {0x7265696e, 0x7374206c, 0x6f636b20}}, \ 390 {TAG_LOCK_UNKNOWN, "unknown lock", \ 391 {0x756e6b6e, 0x6f776e20, 0x6c6f636b}}, \ 392 {TAG_LOCKT, "lock test", \ 393 {0x6c6f636b, 0x5f746573, 0x74202020}}, \ 394 {TAG_LOCKU, "unlock", \ 395 {0x756e6c6f, 0x636b2020, 0x20202020}}, \ 396 {TAG_LOCKU_RESEND, "resend locku", \ 397 {0x72657365, 0x6e64206c, 0x6f636b75}}, \ 398 {TAG_LOCKU_REINSTATE, "reinstate unlock", \ 399 {0x7265696e, 0x73742075, 0x6e6c636b}}, \ 400 {TAG_LOOKUP, "lookup", \ 401 {0x6c6f6f6b, 0x75702020, 0x20202020}}, \ 402 {TAG_LOOKUP_PARENT, "lookup parent", \ 403 {0x6c6f6f6b, 0x75702070, 0x6172656e}}, \ 404 {TAG_LOOKUP_VALID, "lookup valid", \ 405 {0x6c6f6f6b, 0x75702076, 0x616c6964}}, \ 406 {TAG_LOOKUP_VPARENT, "lookup valid parent", \ 407 {0x6c6f6f6b, 0x766c6420, 0x7061726e}}, \ 408 {TAG_MKDIR, "mkdir", \ 409 {0x6d6b6469, 0x72202020, 0x20202020}}, \ 410 {TAG_MKNOD, "mknod", \ 411 {0x6d6b6e6f, 0x64202020, 0x20202020}}, \ 412 {TAG_MOUNT, "mount", \ 413 {0x6d6f756e, 0x74202020, 0x20202020}}, \ 414 {TAG_OPEN, "open", \ 415 {0x6f70656e, 0x20202020, 0x20202020}}, \ 416 {TAG_OPEN_CONFIRM, "open confirm", \ 417 {0x6f70656e, 0x5f636f6e, 0x6669726d}}, \ 418 {TAG_OPEN_CONFIRM_LOST, "lost open confirm", \ 419 {0x6c6f7374, 0x206f7065, 0x6e5f636f}}, \ 420 {TAG_OPEN_DG, "open downgrade", \ 421 {0x6f70656e, 0x20646772, 0x61646520}}, \ 422 {TAG_OPEN_DG_LOST, "lost open downgrade", \ 423 {0x6c737420, 0x6f70656e, 0x20646772}}, \ 424 {TAG_OPEN_LOST, "lost open", \ 425 {0x6c6f7374, 0x206f7065, 0x6e202020}}, \ 426 {TAG_OPENATTR, "openattr", \ 427 {0x6f70656e, 0x61747472, 0x20202020}}, \ 428 {TAG_PATHCONF, "pathhconf", \ 429 {0x70617468, 0x636f6e66, 0x20202020}}, \ 430 {TAG_PUTROOTFH, "putrootfh", \ 431 {0x70757472, 0x6f6f7466, 0x68202020}}, \ 432 {TAG_READ, "read", \ 433 {0x72656164, 0x20202020, 0x20202020}}, \ 434 {TAG_READAHEAD, "readahead", \ 435 {0x72656164, 0x61686561, 0x64202020}}, \ 436 {TAG_READDIR, "readdir", \ 437 {0x72656164, 0x64697220, 0x20202020}}, \ 438 {TAG_READLINK, "readlink", \ 439 {0x72656164, 0x6c696e6b, 0x20202020}}, \ 440 {TAG_RELOCK, "relock", \ 441 {0x72656c6f, 0x636b2020, 0x20202020}}, \ 442 {TAG_REMAP_LOOKUP, "remap lookup", \ 443 {0x72656d61, 0x70206c6f, 0x6f6b7570}}, \ 444 {TAG_REMAP_LOOKUP_AD, "remap lookup attr dir", \ 445 {0x72656d70, 0x206c6b75, 0x70206164}}, \ 446 {TAG_REMAP_LOOKUP_NA, "remap lookup named attrs", \ 447 {0x72656d70, 0x206c6b75, 0x70206e61}}, \ 448 {TAG_REMAP_MOUNT, "remap mount", \ 449 {0x72656d61, 0x70206d6f, 0x756e7420}}, \ 450 {TAG_RMDIR, "rmdir", \ 451 {0x726d6469, 0x72202020, 0x20202020}}, \ 452 {TAG_REMOVE, "remove", \ 453 {0x72656d6f, 0x76652020, 0x20202020}}, \ 454 {TAG_RENAME, "rename", \ 455 {0x72656e61, 0x6d652020, 0x20202020}}, \ 456 {TAG_RENAME_VFH, "rename volatile fh", \ 457 {0x72656e61, 0x6d652028, 0x76666829}}, \ 458 {TAG_RENEW, "renew", \ 459 {0x72656e65, 0x77202020, 0x20202020}}, \ 460 {TAG_REOPEN, "reopen", \ 461 {0x72656f70, 0x656e2020, 0x20202020}}, \ 462 {TAG_REOPEN_LOST, "lost reopen", \ 463 {0x6c6f7374, 0x2072656f, 0x70656e20}}, \ 464 {TAG_SECINFO, "secinfo", \ 465 {0x73656369, 0x6e666f20, 0x20202020}}, \ 466 {TAG_SETATTR, "setattr", \ 467 {0x73657461, 0x74747220, 0x20202020}}, \ 468 {TAG_SETCLIENTID, "setclientid", \ 469 {0x73657463, 0x6c69656e, 0x74696420}}, \ 470 {TAG_SETCLIENTID_CF, "setclientid_confirm", \ 471 {0x73636c6e, 0x7469645f, 0x636f6e66}}, \ 472 {TAG_SYMLINK, "symlink", \ 473 {0x73796d6c, 0x696e6b20, 0x20202020}}, \ 474 {TAG_WRITE, "write", \ 475 {0x77726974, 0x65202020, 0x20202020}} \ 476 } 477 478 /* 479 * These flags are for differentiating the search criterian for 480 * find_open_owner(). The comparison is done with the open_owners's 481 * 'oo_just_created' flag. 482 */ 483 #define NFS4_PERM_CREATED 0x0 484 #define NFS4_JUST_CREATED 0x1 485 486 /* 487 * Hashed by the cr_uid and cr_ruid of credential 'oo_cred'. 'oo_cred_otw' 488 * is stored upon a successful OPEN. This is needed when the user's effective 489 * and real uid's don't match. The 'oo_cred_otw' overrides the credential 490 * passed down by VFS for async read/write, commit, lock, and close operations. 491 * 492 * The oo_ref_count keeps track the number of active references on this 493 * data structure + number of nfs4_open_streams point to this structure. 494 * 495 * 'oo_valid' tells whether this stuct is about to be freed or not. 496 * 497 * 'oo_just_created' tells us whether this struct has just been created but 498 * not been fully finalized (that is created upon an OPEN request and 499 * finalized upon the OPEN success). 500 * 501 * The 'oo_seqid_inuse' is for the open seqid synchronization. If a thread 502 * is currently using the open owner and it's open_seqid, then it sets the 503 * oo_seqid_inuse to true if it currently is not set. If it is set then it 504 * does a cv_wait on the oo_cv_seqid_sync condition variable. When the thread 505 * is done it unsets the oo_seqid_inuse and does a cv_signal to wake a process 506 * waiting on the condition variable. 507 * 508 * 'oo_last_good_seqid' is the last valid seqid this open owner sent OTW, 509 * and 'oo_last_good_op' is the operation that issued the last valid seqid. 510 * 511 * Lock ordering: 512 * mntinfo4_t::mi_lock > oo_lock (for searching mi_oo_list) 513 * 514 * oo_seqid_inuse > mntinfo4_t::mi_lock 515 * oo_seqid_inuse > rnode4_t::r_statelock 516 * oo_seqid_inuse > rnode4_t::r_statev4_lock 517 * oo_seqid_inuse > nfs4_open_stream_t::os_sync_lock 518 * 519 * The 'oo_seqid_inuse'/'oo_cv_seqid_sync' protects: 520 * oo_last_good_op 521 * oo_last_good_seqid 522 * oo_name 523 * oo_seqid 524 * 525 * The 'oo_lock' protects: 526 * oo_cred 527 * oo_cred_otw 528 * oo_foo_node 529 * oo_hash_node 530 * oo_just_created 531 * oo_ref_count 532 * oo_valid 533 */ 534 535 typedef struct nfs4_open_owner { 536 cred_t *oo_cred; 537 int oo_ref_count; 538 int oo_valid; 539 int oo_just_created; 540 seqid4 oo_seqid; 541 seqid4 oo_last_good_seqid; 542 nfs4_tag_type_t oo_last_good_op; 543 unsigned oo_seqid_inuse:1; 544 cred_t *oo_cred_otw; 545 kcondvar_t oo_cv_seqid_sync; 546 /* 547 * Fix this to always be 8 bytes 548 */ 549 uint64_t oo_name; 550 list_node_t oo_hash_node; 551 list_node_t oo_foo_node; 552 kmutex_t oo_lock; 553 } nfs4_open_owner_t; 554 555 /* 556 * Static server information. 557 * These fields are read-only once they are initialized: 558 * sv_addr 559 * sv_dhsec 560 * sv_hostname 561 * sv_hostnamelen 562 * sv_knconf 563 * sv_next 564 * sv_origknconf 565 * 566 * These fields are protected by sv_lock: 567 * sv_currsec 568 * sv_fhandle 569 * sv_flags 570 * sv_fsid 571 * sv_path 572 * sv_pathlen 573 * sv_pfhandle 574 * sv_save_secinfo 575 * sv_savesec 576 * sv_secdata 577 * sv_secinfo 578 * sv_supp_attrs 579 * 580 * Lock ordering: 581 * nfs_rtable4_lock > sv_lock 582 * rnode4_t::r_statelock > sv_lock 583 */ 584 typedef struct servinfo4 { 585 struct knetconfig *sv_knconf; /* bound TLI fd */ 586 struct knetconfig *sv_origknconf; /* For RDMA save orig knconf */ 587 struct netbuf sv_addr; /* server's address */ 588 nfs4_fhandle_t sv_fhandle; /* this server's filehandle */ 589 nfs4_fhandle_t sv_pfhandle; /* parent dir filehandle */ 590 int sv_pathlen; /* Length of server path */ 591 char *sv_path; /* Path name on server */ 592 uint32_t sv_flags; /* flags for this server */ 593 sec_data_t *sv_secdata; /* client initiated security data */ 594 sv_secinfo_t *sv_secinfo; /* server security information */ 595 sec_data_t *sv_currsec; /* security data currently used; */ 596 /* points to one of the sec_data */ 597 /* entries in sv_secinfo */ 598 sv_secinfo_t *sv_save_secinfo; /* saved secinfo */ 599 sec_data_t *sv_savesec; /* saved security data */ 600 sec_data_t *sv_dhsec; /* AUTH_DH data from the user land */ 601 char *sv_hostname; /* server's hostname */ 602 int sv_hostnamelen; /* server's hostname length */ 603 fattr4_fsid sv_fsid; /* fsid of shared obj */ 604 fattr4_supported_attrs sv_supp_attrs; 605 struct servinfo4 *sv_next; /* next in list */ 606 nfs_rwlock_t sv_lock; 607 } servinfo4_t; 608 609 /* sv_flags fields */ 610 #define SV4_TRYSECINFO 0x001 /* try secinfo data from the server */ 611 #define SV4_TRYSECDEFAULT 0x002 /* try a default flavor */ 612 #define SV4_NOTINUSE 0x004 /* servinfo4_t had fatal errors */ 613 #define SV4_ROOT_STALE 0x008 /* root vnode got ESTALE */ 614 615 /* 616 * Lock call types. See nfs4frlock(). 617 */ 618 typedef enum nfs4_lock_call_type { 619 NFS4_LCK_CTYPE_NORM, 620 NFS4_LCK_CTYPE_RECLAIM, 621 NFS4_LCK_CTYPE_RESEND, 622 NFS4_LCK_CTYPE_REINSTATE 623 } nfs4_lock_call_type_t; 624 625 /* 626 * This structure holds the information for a lost open/close/open downgrade/ 627 * lock/locku request. It is also used for requests that are queued up so 628 * that the recovery thread can release server state after a forced 629 * unmount. 630 * "lr_op" is 0 if the struct is uninitialized. Otherwise, it is set to 631 * the proper OP_* nfs_opnum4 number. The other fields contain information 632 * to reconstruct the call. 633 * 634 * lr_dvp is used for OPENs with CREATE, so that we can do a PUTFH of the 635 * parent directroy without relying on vtodv (since we may not have a vp 636 * for the file we wish to create). 637 * 638 * lr_putfirst means that the request should go to the front of the resend 639 * queue, rather than the end. 640 */ 641 typedef struct nfs4_lost_rqst { 642 list_node_t lr_node; 643 nfs_opnum4 lr_op; 644 vnode_t *lr_vp; 645 vnode_t *lr_dvp; 646 nfs4_open_owner_t *lr_oop; 647 struct nfs4_open_stream *lr_osp; 648 struct nfs4_lock_owner *lr_lop; 649 cred_t *lr_cr; 650 flock64_t *lr_flk; 651 bool_t lr_putfirst; 652 union { 653 struct { 654 nfs4_lock_call_type_t lru_ctype; 655 nfs_lock_type4 lru_locktype; 656 } lru_lockargs; /* LOCK, LOCKU */ 657 struct { 658 uint32_t lru_oaccess; 659 uint32_t lru_odeny; 660 enum open_claim_type4 lru_oclaim; 661 stateid4 lru_ostateid; /* reopen only */ 662 component4 lru_ofile; 663 } lru_open_args; 664 struct { 665 uint32_t lru_dg_access; 666 uint32_t lru_dg_deny; 667 } lru_open_dg_args; 668 } nfs4_lr_u; 669 } nfs4_lost_rqst_t; 670 671 #define lr_oacc nfs4_lr_u.lru_open_args.lru_oaccess 672 #define lr_odeny nfs4_lr_u.lru_open_args.lru_odeny 673 #define lr_oclaim nfs4_lr_u.lru_open_args.lru_oclaim 674 #define lr_ostateid nfs4_lr_u.lru_open_args.lru_ostateid 675 #define lr_ofile nfs4_lr_u.lru_open_args.lru_ofile 676 #define lr_dg_acc nfs4_lr_u.lru_open_dg_args.lru_dg_access 677 #define lr_dg_deny nfs4_lr_u.lru_open_dg_args.lru_dg_deny 678 #define lr_ctype nfs4_lr_u.lru_lockargs.lru_ctype 679 #define lr_locktype nfs4_lr_u.lru_lockargs.lru_locktype 680 681 /* 682 * Recovery actions. Some actions can imply further recovery using a 683 * different recovery action (e.g., recovering the clientid leads to 684 * recovering open files and locks). 685 */ 686 687 typedef enum { 688 NR_UNUSED, 689 NR_CLIENTID, 690 NR_OPENFILES, 691 NR_FHEXPIRED, 692 NR_FAILOVER, 693 NR_WRONGSEC, 694 NR_EXPIRED, 695 NR_BAD_STATEID, 696 NR_BADHANDLE, 697 NR_BAD_SEQID, 698 NR_OLDSTATEID, 699 NR_GRACE, 700 NR_DELAY, 701 NR_LOST_LOCK, 702 NR_LOST_STATE_RQST, 703 NR_STALE 704 } nfs4_recov_t; 705 706 /* 707 * Administrative and debug message framework. 708 */ 709 710 #define NFS4_MSG_MAX 100 711 extern int nfs4_msg_max; 712 713 typedef enum { 714 RE_BAD_SEQID, 715 RE_BADHANDLE, 716 RE_CLIENTID, 717 RE_DEAD_FILE, 718 RE_END, 719 RE_FAIL_RELOCK, 720 RE_FAIL_REMAP_LEN, 721 RE_FAIL_REMAP_OP, 722 RE_FAILOVER, 723 RE_FILE_DIFF, 724 RE_LOST_STATE, 725 RE_OPENS_CHANGED, 726 RE_SIGLOST, 727 RE_SIGLOST_NO_DUMP, 728 RE_START, 729 RE_UNEXPECTED_ACTION, 730 RE_UNEXPECTED_ERRNO, 731 RE_UNEXPECTED_STATUS, 732 RE_WRONGSEC, 733 RE_LOST_STATE_BAD_OP 734 } nfs4_event_type_t; 735 736 typedef enum { 737 RFS_NO_INSPECT, 738 RFS_INSPECT 739 } nfs4_fact_status_t; 740 741 typedef enum { 742 RF_BADOWNER, 743 RF_ERR, 744 RF_RENEW_EXPIRED, 745 RF_SRV_NOT_RESPOND, 746 RF_SRV_OK, 747 RF_SRVS_NOT_RESPOND, 748 RF_SRVS_OK, 749 RF_DELMAP_CB_ERR 750 } nfs4_fact_type_t; 751 752 typedef enum { 753 NFS4_MS_DUMP, 754 NFS4_MS_NO_DUMP 755 } nfs4_msg_status_t; 756 757 typedef struct nfs4_rfact { 758 nfs4_fact_type_t rf_type; 759 nfs4_fact_status_t rf_status; 760 bool_t rf_reboot; 761 nfs4_recov_t rf_action; 762 nfs_opnum4 rf_op; 763 nfsstat4 rf_stat4; 764 timespec_t rf_time; 765 int rf_error; 766 struct rnode4 *rf_rp1; 767 char *rf_char1; 768 } nfs4_rfact_t; 769 770 typedef struct nfs4_revent { 771 nfs4_event_type_t re_type; 772 nfsstat4 re_stat4; 773 uint_t re_uint; 774 pid_t re_pid; 775 struct mntinfo4 *re_mi; 776 struct rnode4 *re_rp1; 777 struct rnode4 *re_rp2; 778 char *re_char1; 779 char *re_char2; 780 nfs4_tag_type_t re_tag1; 781 nfs4_tag_type_t re_tag2; 782 seqid4 re_seqid1; 783 seqid4 re_seqid2; 784 } nfs4_revent_t; 785 786 typedef enum { 787 RM_EVENT, 788 RM_FACT 789 } nfs4_msg_type_t; 790 791 typedef struct nfs4_debug_msg { 792 timespec_t msg_time; 793 nfs4_msg_type_t msg_type; 794 char *msg_srv; 795 char *msg_mntpt; 796 union { 797 nfs4_rfact_t msg_fact; 798 nfs4_revent_t msg_event; 799 } rmsg_u; 800 nfs4_msg_status_t msg_status; 801 list_node_t msg_node; 802 } nfs4_debug_msg_t; 803 804 /* 805 * NFS private data per mounted file system 806 * The mi_lock mutex protects the following fields: 807 * mi_flags 808 * mi_in_recovery 809 * mi_recovflags 810 * mi_recovthread 811 * mi_error 812 * mi_printed 813 * mi_down 814 * mi_stsize 815 * mi_curread 816 * mi_curwrite 817 * mi_timers 818 * mi_curr_serv 819 * mi_klmconfig 820 * mi_oo_list 821 * mi_foo_list 822 * mi_foo_num 823 * mi_foo_max 824 * mi_lost_state 825 * mi_bseqid_list 826 * 827 * Normally the netconfig information for the mount comes from 828 * mi_curr_serv and mi_klmconfig is NULL. If NLM calls need to use a 829 * different transport, mi_klmconfig contains the necessary netconfig 830 * information. 831 * 832 * The mi_async_lock mutex protects the following fields: 833 * mi_async_reqs 834 * mi_async_req_count 835 * mi_async_tail 836 * mi_async_curr 837 * mi_async_clusters 838 * mi_async_init_clusters 839 * mi_threads 840 * mi_inactive_thread 841 * mi_manager_thread 842 * 843 * The nfs4_server_t::s_lock protects the following fields: 844 * mi_clientid 845 * mi_clientid_next 846 * mi_clientid_prev 847 * mi_open_files 848 * mi_srvsettime 849 * 850 * The mntinfo4_t::mi_recovlock protects the following fields: 851 * mi_srvsettime 852 * 853 * Locking order: 854 * mi4_globals::mig_lock > mi_async_lock 855 * mi_async_lock > nfs4_server_t::s_lock > mi_lock 856 * mi_recovlock > mi_rename_lock > nfs_rtable4_lock 857 * nfs4_server_t::s_recovlock > mi_recovlock 858 * rnode4_t::r_rwlock > mi_rename_lock 859 * nfs_rtable4_lock > mi_lock 860 * nfs4_server_t::s_lock > mi_msg_list_lock 861 * mi_recovlock > nfs4_server_t::s_lock 862 * mi_recovlock > nfs4_server_lst_lock 863 * 864 * The 'mi_oo_list' represents the hash buckets that contain the 865 * nfs4_open_owenrs for this particular mntinfo4. 866 * 867 * The 'mi_foo_list' represents the freed nfs4_open_owners for this mntinfo4. 868 * 'mi_foo_num' is the current number of freed open owners on the list, 869 * 'mi_foo_max' is the maximum number of freed open owners that are allowable 870 * on the list. 871 * 872 * mi_rootfh and mi_srvparentfh are read-only once created, but that just 873 * refers to the pointer. The contents must be updated to keep in sync 874 * with mi_curr_serv. 875 * 876 * The mi_msg_list_lock protects against adding/deleting entries to the 877 * mi_msg_list, and also the updating/retrieving of mi_lease_period; 878 * 879 * 'mi_zone' is initialized at structure creation time, and never 880 * changes; it may be read without a lock. 881 * 882 * mi_zone_node is linkage into the mi4_globals.mig_list, and is 883 * protected by mi4_globals.mig_list_lock. 884 */ 885 struct zone; 886 typedef struct mntinfo4 { 887 kmutex_t mi_lock; /* protects mntinfo4 fields */ 888 struct servinfo4 *mi_servers; /* server list */ 889 struct servinfo4 *mi_curr_serv; /* current server */ 890 struct nfs4_sharedfh *mi_rootfh; /* root filehandle */ 891 struct nfs4_sharedfh *mi_srvparentfh; /* root's parent on server */ 892 kcondvar_t mi_failover_cv; /* failover synchronization */ 893 struct vfs *mi_vfsp; /* back pointer to vfs */ 894 enum vtype mi_type; /* file type of the root vnode */ 895 uint_t mi_flags; /* see below */ 896 uint_t mi_recovflags; /* if recovery active; see below */ 897 kthread_t *mi_recovthread; /* active recov thread or NULL */ 898 uint_t mi_error; /* only set/valid when MI4_RECOV_FAIL */ 899 /* is set in mi_flags */ 900 int mi_tsize; /* transfer size (bytes) */ 901 /* really read size */ 902 int mi_stsize; /* server's max transfer size (bytes) */ 903 /* really write size */ 904 int mi_timeo; /* inital timeout in 10th sec */ 905 int mi_retrans; /* times to retry request */ 906 hrtime_t mi_acregmin; /* min time to hold cached file attr */ 907 hrtime_t mi_acregmax; /* max time to hold cached file attr */ 908 hrtime_t mi_acdirmin; /* min time to hold cached dir attr */ 909 hrtime_t mi_acdirmax; /* max time to hold cached dir attr */ 910 len_t mi_maxfilesize; /* for pathconf _PC_FILESIZEBITS */ 911 int mi_curread; /* current read size */ 912 int mi_curwrite; /* current write size */ 913 uint_t mi_count; /* ref count */ 914 /* 915 * async I/O management. There may be a pool of threads to handle 916 * async I/O requests, etc., plus there is always one thread that 917 * handles over-the-wire requests for VOP_INACTIVE. The async pool 918 * can also help out with VOP_INACTIVE. 919 */ 920 struct nfs4_async_reqs *mi_async_reqs[NFS4_ASYNC_TYPES]; 921 struct nfs4_async_reqs *mi_async_tail[NFS4_ASYNC_TYPES]; 922 struct nfs4_async_reqs **mi_async_curr; /* current async queue */ 923 uint_t mi_async_clusters[NFS4_ASYNC_TYPES]; 924 uint_t mi_async_init_clusters; 925 uint_t mi_async_req_count; /* # outstanding work requests */ 926 kcondvar_t mi_async_reqs_cv; /* signaled when there's work */ 927 ushort_t mi_threads; /* number of active async threads */ 928 ushort_t mi_max_threads; /* max number of async threads */ 929 kthread_t *mi_manager_thread; /* async manager thread id */ 930 kthread_t *mi_inactive_thread; /* inactive thread id */ 931 kcondvar_t mi_inact_req_cv; /* notify VOP_INACTIVE thread */ 932 kcondvar_t mi_async_work_cv; /* tell workers to work */ 933 kcondvar_t mi_async_cv; /* all pool threads exited */ 934 kmutex_t mi_async_lock; 935 /* 936 * Other stuff 937 */ 938 struct pathcnf *mi_pathconf; /* static pathconf kludge */ 939 rpcprog_t mi_prog; /* RPC program number */ 940 rpcvers_t mi_vers; /* RPC program version number */ 941 char **mi_rfsnames; /* mapping to proc names */ 942 kstat_named_t *mi_reqs; /* count of requests */ 943 clock_t mi_printftime; /* last error printf time */ 944 nfs_rwlock_t mi_recovlock; /* separate ops from recovery (v4) */ 945 time_t mi_grace_wait; /* non-zero represents time to wait */ 946 time_t mi_srvsettime; /* when we switched nfs4_server_t */ 947 nfs_rwlock_t mi_rename_lock; /* atomic volfh rename */ 948 struct nfs4_fname *mi_fname; /* root fname */ 949 list_t mi_lost_state; /* resend list */ 950 list_t mi_bseqid_list; /* bad seqid list */ 951 /* 952 * Client Side Failover stats 953 */ 954 uint_t mi_noresponse; /* server not responding count */ 955 uint_t mi_failover; /* failover to new server count */ 956 uint_t mi_remap; /* remap to new server count */ 957 /* 958 * Kstat statistics 959 */ 960 struct kstat *mi_io_kstats; 961 struct kstat *mi_ro_kstats; 962 kstat_t *mi_recov_ksp; /* ptr to the recovery kstat */ 963 964 /* 965 * Volatile fh flags (nfsv4) 966 */ 967 uint32_t mi_fh_expire_type; 968 /* 969 * Lease Management 970 */ 971 struct mntinfo4 *mi_clientid_next; 972 struct mntinfo4 *mi_clientid_prev; 973 clientid4 mi_clientid; /* redundant info found in nfs4_server */ 974 int mi_open_files; /* count of open files */ 975 int mi_in_recovery; /* count of recovery instances */ 976 kcondvar_t mi_cv_in_recov; /* cv for recovery threads */ 977 /* 978 * Open owner stuff. 979 */ 980 struct nfs4_oo_hash_bucket mi_oo_list[NFS4_NUM_OO_BUCKETS]; 981 list_t mi_foo_list; 982 int mi_foo_num; 983 int mi_foo_max; 984 /* 985 * Shared filehandle pool. 986 */ 987 nfs_rwlock_t mi_fh_lock; 988 avl_tree_t mi_filehandles; 989 990 /* 991 * Debug message queue. 992 */ 993 list_t mi_msg_list; 994 int mi_msg_count; 995 time_t mi_lease_period; 996 /* 997 * not guaranteed to be accurate. 998 * only should be used by debug queue. 999 */ 1000 kmutex_t mi_msg_list_lock; 1001 /* 1002 * Zones support. 1003 */ 1004 struct zone *mi_zone; /* Zone mounted in */ 1005 list_node_t mi_zone_node; /* linkage into per-zone mi list */ 1006 } mntinfo4_t; 1007 1008 /* 1009 * The values for mi_flags. 1010 * 1011 * MI4_HARD hard or soft mount 1012 * MI4_PRINTED responding message printed 1013 * MI4_INT allow INTR on hard mount 1014 * MI4_DOWN server is down 1015 * MI4_NOAC don't cache attributes 1016 * MI4_NOCTO no close-to-open consistency 1017 * MI4_LLOCK local locking only (no lockmgr) 1018 * MI4_GRPID System V group id inheritance 1019 * MI4_SHUTDOWN System is rebooting or shutting down 1020 * MI4_LINK server supports link 1021 * MI4_SYMLINK server supports symlink 1022 * MI4_ACL server supports NFSv4 ACLs 1023 * MI4_NOPRINT don't print messages 1024 * MI4_DIRECTIO do direct I/O 1025 * MI4_RECOV_ACTIV filesystem has recovery a thread 1026 * MI4_REMOVE_ON_LAST_CLOSE remove from server's list 1027 * MI4_RECOV_FAIL client recovery failed 1028 * MI4_PUBLIC public/url option used 1029 * MI4_MOUNTING mount in progress, don't failover 1030 * MI4_POSIX_LOCK if server is using POSIX locking 1031 * MI4_LOCK_DEBUG cmn_err'd posix lock err msg 1032 * MI4_DEAD zone has released it 1033 * MI4_INACTIVE_IDLE inactive thread idle 1034 * MI4_BADOWNER_DEBUG badowner error msg per mount 1035 * MI4_ASYNC_MGR_STOP tell async manager to die 1036 * MI4_TIMEDOUT saw a timeout during zone shutdown 1037 */ 1038 #define MI4_HARD 0x1 1039 #define MI4_PRINTED 0x2 1040 #define MI4_INT 0x4 1041 #define MI4_DOWN 0x8 1042 #define MI4_NOAC 0x10 1043 #define MI4_NOCTO 0x20 1044 #define MI4_LLOCK 0x80 1045 #define MI4_GRPID 0x100 1046 #define MI4_SHUTDOWN 0x200 1047 #define MI4_LINK 0x400 1048 #define MI4_SYMLINK 0x800 1049 /* 0x1000 is available */ 1050 #define MI4_ACL 0x2000 1051 /* 0x4000 is available */ 1052 /* 0x8000 is available */ 1053 /* 0x10000 is available */ 1054 #define MI4_NOPRINT 0x20000 1055 #define MI4_DIRECTIO 0x40000 1056 /* 0x80000 is available */ 1057 #define MI4_RECOV_ACTIV 0x100000 1058 #define MI4_REMOVE_ON_LAST_CLOSE 0x200000 1059 #define MI4_RECOV_FAIL 0x400000 1060 #define MI4_PUBLIC 0x800000 1061 #define MI4_MOUNTING 0x1000000 1062 #define MI4_POSIX_LOCK 0x2000000 1063 #define MI4_LOCK_DEBUG 0x4000000 1064 #define MI4_DEAD 0x8000000 1065 #define MI4_INACTIVE_IDLE 0x10000000 1066 #define MI4_BADOWNER_DEBUG 0x20000000 1067 #define MI4_ASYNC_MGR_STOP 0x40000000 1068 #define MI4_TIMEDOUT 0x80000000 1069 1070 #define INTR4(vp) (VTOMI4(vp)->mi_flags & MI4_INT) 1071 1072 #define FAILOVER_MOUNT4(mi) (mi->mi_servers->sv_next) 1073 1074 /* 1075 * Recovery flags. 1076 * 1077 * MI4R_NEED_CLIENTID is sort of redundant (it's the nfs4_server_t flag 1078 * that's important), but some flag is needed to indicate that recovery is 1079 * going on for the filesystem. 1080 */ 1081 #define MI4R_NEED_CLIENTID 0x1 1082 #define MI4R_REOPEN_FILES 0x2 1083 #define MI4R_NEED_SECINFO 0x4 1084 #define MI4R_NEED_NEW_SERVER 0x8 1085 #define MI4R_REMAP_FILES 0x10 1086 #define MI4R_SRV_REBOOT 0x20 /* server has rebooted */ 1087 #define MI4R_LOST_STATE 0x40 1088 #define MI4R_BAD_SEQID 0x80 1089 1090 #define MI4_HOLD(mi) { \ 1091 mi_hold(mi); \ 1092 } 1093 1094 #define MI4_RELE(mi) { \ 1095 mi_rele(mi); \ 1096 } 1097 1098 /* 1099 * vfs pointer to mount info 1100 */ 1101 #define VFTOMI4(vfsp) ((mntinfo4_t *)((vfsp)->vfs_data)) 1102 1103 /* 1104 * vnode pointer to mount info 1105 */ 1106 #define VTOMI4(vp) ((mntinfo4_t *)(((vp)->v_vfsp)->vfs_data)) 1107 1108 /* 1109 * Lease Management 1110 * 1111 * lease_valid is initially set to NFS4_LEASE_NOT_STARTED. This is when the 1112 * nfs4_server is first created. lease_valid is then set to 1113 * NFS4_LEASE_UNITIALIZED when the renew thread is started. The extra state of 1114 * NFS4_LEASE_NOT_STARTED is needed for client recovery (so we know if a thread 1115 * already exists when we do SETCLIENTID). lease_valid is then set to 1116 * NFS4_LEASE_VALID (if it is at NFS4_LEASE_UNITIALIZED) when a state creating 1117 * operation (OPEN) is done. lease_valid stays at NFS4_LEASE_VALID as long as 1118 * the lease is renewed. It is set to NFS4_LEASE_INVALID when the lease 1119 * expires. Client recovery is needed to set the lease back to 1120 * NFS4_LEASE_VALID from NFS4_LEASE_INVALID. 1121 * 1122 * The s_cred is the credential used to mount the first file system for this 1123 * server. It used as the credential for the renew thread's calls to the 1124 * server. 1125 * 1126 * The renew thread waits on the condition variable cv_thread_exit. If the cv 1127 * is signalled, then the thread knows it must check s_thread_exit to see if 1128 * it should exit. The cv is signaled when the last file system is unmounted 1129 * from a particular server. s_thread_exit is set to 0 upon thread startup, 1130 * and set to NFS4_THREAD_EXIT, when the last file system is unmounted thereby 1131 * telling the thread to exit. s_thread_exit is needed to avoid spurious 1132 * wakeups. 1133 * 1134 * state_ref_count is incremented every time a new file is opened and 1135 * decremented every time a file is closed otw. This keeps track of whether 1136 * the nfs4_server has state associated with it or not. 1137 * 1138 * s_refcnt is the reference count for storage management of the struct 1139 * itself. 1140 * 1141 * mntinfo4_list points to the doubly linked list of mntinfo4s that share 1142 * this nfs4_server (ie: <clientid, saddr> pair) in the current zone. This is 1143 * needed for a nfs4_server to get a mntinfo4 for use in rfs4call. 1144 * 1145 * s_recovlock is used to synchronize recovery operations. The thread 1146 * that is recovering the client must acquire it as a writer. If the 1147 * thread is using the clientid (including recovery operations on other 1148 * state), acquire it as a reader. 1149 * 1150 * The 's_otw_call_count' keeps track of the number of outstanding over the 1151 * wire requests for this structure. The struct will not go away as long 1152 * as this is non-zero (or s_refcnt is non-zero). 1153 * 1154 * The 's_cv_otw_count' is used in conjuntion with the 's_otw_call_count' 1155 * variable to let the renew thread when an outstanding otw request has 1156 * finished. 1157 * 1158 * 'zoneid' and 'zone_globals' are set at creation of this structure 1159 * and are read-only after that; no lock is required to read them. 1160 * 1161 * s_lock protects: everything except cv_thread_exit and s_recovlock. 1162 * 1163 * s_program is used as the index into the nfs4_callback_globals's 1164 * nfs4prog2server table. When a callback request comes in, we can 1165 * use that request's program number (minus NFS4_CALLBACK) as an index 1166 * into the nfs4prog2server. That entry will hold the nfs4_server_t ptr. 1167 * We can then access that nfs4_server_t and its 's_deleg_list' (its list of 1168 * delegated rnode4_ts). 1169 * 1170 * Lock order: 1171 * nfs4_server::s_lock > mntinfo4::mi_lock 1172 * nfs_rtable4_lock > s_lock 1173 * nfs4_server_lst_lock > s_lock 1174 * s_recovlock > s_lock 1175 */ 1176 struct nfs4_callback_globals; 1177 1178 typedef struct nfs4_server { 1179 struct nfs4_server *forw; 1180 struct nfs4_server *back; 1181 struct netbuf saddr; 1182 uint_t s_flags; /* see below */ 1183 uint_t s_refcnt; 1184 clientid4 clientid; /* what we get from server */ 1185 nfs_client_id4 clidtosend; /* what we send to server */ 1186 mntinfo4_t *mntinfo4_list; 1187 int lease_valid; 1188 time_t s_lease_time; 1189 time_t last_renewal_time; 1190 timespec_t propagation_delay; 1191 cred_t *s_cred; 1192 kcondvar_t cv_thread_exit; 1193 int s_thread_exit; 1194 int state_ref_count; 1195 int s_otw_call_count; 1196 kcondvar_t s_cv_otw_count; 1197 kcondvar_t s_clientid_pend; 1198 kmutex_t s_lock; 1199 list_t s_deleg_list; 1200 rpcprog_t s_program; 1201 nfs_rwlock_t s_recovlock; 1202 kcondvar_t wait_cb_null; /* used to wait for CB_NULL */ 1203 zoneid_t zoneid; /* zone using this nfs4_server_t */ 1204 struct nfs4_callback_globals *zone_globals; /* globals */ 1205 } nfs4_server_t; 1206 1207 /* nfs4_server flags */ 1208 #define N4S_CLIENTID_SET 1 /* server has our clientid */ 1209 #define N4S_CLIENTID_PEND 0x2 /* server doesn't have clientid */ 1210 #define N4S_CB_PINGED 0x4 /* server has sent us a CB_NULL */ 1211 #define N4S_CB_WAITER 0x8 /* is/has wait{ing/ed} for cb_null */ 1212 #define N4S_INSERTED 0x10 /* list has reference for server */ 1213 #define N4S_BADOWNER_DEBUG 0x20 /* bad owner err msg per client */ 1214 1215 #define N4S_CB_PAUSE_TIME 10000 /* Amount of time to pause (10ms) */ 1216 1217 struct lease_time_arg { 1218 time_t lease_time; 1219 }; 1220 1221 enum nfs4_delegreturn_policy { 1222 IMMEDIATE, 1223 FIRSTCLOSE, 1224 LASTCLOSE, 1225 INACTIVE 1226 }; 1227 1228 /* 1229 * Operation hints for the recovery framework (mostly). 1230 * 1231 * EXCEPTIONS: 1232 * OH_ACCESS, OH_GETACL, OH_GETATTR, OH_LOOKUP, OH_READDIR 1233 * These hints exist to allow user visit/readdir a R4SRVSTUB dir. 1234 * (dir represents the root of a server fs that has not yet been 1235 * mounted at client) 1236 */ 1237 typedef enum { 1238 OH_OTHER, 1239 OH_READ, 1240 OH_WRITE, 1241 OH_COMMIT, 1242 OH_VFH_RENAME, 1243 OH_MOUNT, 1244 OH_CLOSE, 1245 OH_LOCKU, 1246 OH_DELEGRETURN, 1247 OH_ACCESS, 1248 OH_GETACL, 1249 OH_GETATTR, 1250 OH_LOOKUP, 1251 OH_READDIR 1252 } nfs4_op_hint_t; 1253 1254 /* 1255 * This macro evaluates to non-zero if the given op releases state at the 1256 * server. 1257 */ 1258 #define OH_IS_STATE_RELE(op) ((op) == OH_CLOSE || (op) == OH_LOCKU || \ 1259 (op) == OH_DELEGRETURN) 1260 1261 #ifdef _KERNEL 1262 1263 extern void nfs4_async_manager(struct vfs *); 1264 extern void nfs4_async_manager_stop(struct vfs *); 1265 extern void nfs4_async_stop(struct vfs *); 1266 extern int nfs4_async_stop_sig(struct vfs *); 1267 extern int nfs4_async_readahead(vnode_t *, u_offset_t, caddr_t, 1268 struct seg *, cred_t *, 1269 void (*)(vnode_t *, u_offset_t, 1270 caddr_t, struct seg *, cred_t *)); 1271 extern int nfs4_async_putapage(vnode_t *, page_t *, u_offset_t, size_t, 1272 int, cred_t *, int (*)(vnode_t *, page_t *, 1273 u_offset_t, size_t, int, cred_t *)); 1274 extern int nfs4_async_pageio(vnode_t *, page_t *, u_offset_t, size_t, 1275 int, cred_t *, int (*)(vnode_t *, page_t *, 1276 u_offset_t, size_t, int, cred_t *)); 1277 extern void nfs4_async_commit(vnode_t *, page_t *, offset3, count3, 1278 cred_t *, void (*)(vnode_t *, page_t *, 1279 offset3, count3, cred_t *)); 1280 extern void nfs4_async_inactive(vnode_t *, cred_t *); 1281 extern void nfs4_inactive_thread(mntinfo4_t *mi); 1282 extern void nfs4_inactive_otw(vnode_t *, cred_t *); 1283 extern int nfs4_putpages(vnode_t *, u_offset_t, size_t, int, cred_t *); 1284 1285 extern int nfs4_setopts(vnode_t *, model_t, struct nfs_args *); 1286 extern void nfs4_mnt_kstat_init(struct vfs *); 1287 1288 extern void rfs4call(struct mntinfo4 *, struct COMPOUND4args_clnt *, 1289 struct COMPOUND4res_clnt *, cred_t *, int *, int, 1290 nfs4_error_t *); 1291 extern void nfs4_acl_fill_cache(struct rnode4 *, vsecattr_t *); 1292 extern int nfs4_attr_otw(vnode_t *, nfs4_tag_type_t, 1293 nfs4_ga_res_t *, bitmap4, cred_t *); 1294 1295 extern void nfs4_attrcache_noinval(vnode_t *, nfs4_ga_res_t *, hrtime_t); 1296 extern void nfs4_attr_cache(vnode_t *, nfs4_ga_res_t *, 1297 hrtime_t, cred_t *, int, 1298 change_info4 *); 1299 extern void nfs4_purge_rddir_cache(vnode_t *); 1300 extern void nfs4_invalidate_pages(vnode_t *, u_offset_t, cred_t *); 1301 extern void nfs4_purge_caches(vnode_t *, int, cred_t *, int); 1302 extern void nfs4_purge_stale_fh(int, vnode_t *, cred_t *); 1303 1304 extern void nfs4rename_update(vnode_t *, vnode_t *, nfs_fh4 *, char *); 1305 extern void nfs4_update_paths(vnode_t *, char *, vnode_t *, char *, 1306 vnode_t *); 1307 1308 extern void nfs4args_lookup_free(nfs_argop4 *, int); 1309 extern void nfs4args_copen_free(OPEN4cargs *); 1310 1311 extern void nfs4_printfhandle(nfs4_fhandle_t *); 1312 1313 extern void nfs_free_mi4(mntinfo4_t *); 1314 extern void sv4_free(servinfo4_t *); 1315 extern void nfs4_mi_zonelist_add(mntinfo4_t *); 1316 extern int nfs4_mi_zonelist_remove(mntinfo4_t *); 1317 extern int nfs4_secinfo_recov(mntinfo4_t *, vnode_t *, vnode_t *); 1318 extern void nfs4_secinfo_init(void); 1319 extern void nfs4_secinfo_fini(void); 1320 extern int nfs4_secinfo_path(mntinfo4_t *, cred_t *, int); 1321 extern int nfs4_secinfo_vnode_otw(vnode_t *, char *, cred_t *); 1322 extern void secinfo_free(sv_secinfo_t *); 1323 extern void save_mnt_secinfo(servinfo4_t *); 1324 extern void check_mnt_secinfo(servinfo4_t *, vnode_t *); 1325 extern int vattr_to_fattr4(vattr_t *, vsecattr_t *, fattr4 *, int, 1326 enum nfs_opnum4, bitmap4 supp_mask); 1327 extern int nfs4_putapage(vnode_t *, page_t *, u_offset_t *, size_t *, 1328 int, cred_t *); 1329 extern void nfs4_write_error(vnode_t *, int, cred_t *); 1330 extern void nfs4_lockcompletion(vnode_t *, int); 1331 extern bool_t nfs4_map_lost_lock_conflict(vnode_t *); 1332 extern int vtodv(vnode_t *, vnode_t **, cred_t *, bool_t); 1333 extern void nfs4open_confirm(vnode_t *, seqid4*, stateid4 *, cred_t *, 1334 bool_t, bool_t *, nfs4_open_owner_t *, bool_t, 1335 nfs4_error_t *, int *); 1336 extern void nfs4_error_zinit(nfs4_error_t *); 1337 extern void nfs4_error_init(nfs4_error_t *, int); 1338 1339 extern void mi_hold(mntinfo4_t *); 1340 extern void mi_rele(mntinfo4_t *); 1341 1342 #ifdef DEBUG 1343 extern int nfs4_consistent_type(vnode_t *); 1344 #endif 1345 1346 extern void nfs4_init_dot_entries(void); 1347 extern void nfs4_destroy_dot_entries(void); 1348 extern struct nfs4_callback_globals *nfs4_get_callback_globals(void); 1349 1350 extern struct nfs4_server nfs4_server_lst; 1351 1352 extern clock_t nfs_write_error_interval; 1353 1354 #endif /* _KERNEL */ 1355 1356 /* 1357 * Flags for nfs4getfh_otw. 1358 */ 1359 1360 #define NFS4_GETFH_PUBLIC 0x01 1361 #define NFS4_GETFH_NEEDSOP 0x02 1362 1363 /* 1364 * Found through rnodes. 1365 * 1366 * The os_open_ref_count keeps track the number of open file descriptor 1367 * refernces on this data structure. It will be bumped for any successful 1368 * OTW OPEN call and any OPEN call that determines the OTW call is not 1369 * necessary and the open stream hasn't just been created (see 1370 * nfs4_is_otw_open_necessary). 1371 * 1372 * os_mapcnt is a count of the number of mmapped pages for a particular 1373 * open stream; this in conjunction w/ os_open_ref_count is used to 1374 * determine when to do a close to the server. This is necessary because 1375 * of the semantics of doing open, mmap, close; the OTW close must be wait 1376 * until all open and mmap references have vanished. 1377 * 1378 * 'os_valid' tells us whether this structure is about to be freed or not, 1379 * if it is then don't return it in find_open_stream(). 1380 * 1381 * 'os_final_close' is set when a CLOSE OTW was attempted. This is needed 1382 * so we can properly count the os_open_ref_count in cases where we VOP_CLOSE 1383 * without a VOP_OPEN, and have nfs4_inactive() drive the OTW CLOSE. It 1384 * also helps differentiate the VOP_OPEN/VN_RELE case from the VOP_CLOSE 1385 * that tried to close OTW but failed, and left the state cleanup to 1386 * nfs4_inactive/CLOSE_FORCE. 1387 * 1388 * 'os_force_close' is used to let us know if an intervening thread came 1389 * and reopened the open stream after we decided to issue a CLOSE_FORCE, 1390 * but before we could actually process the CLOSE_FORCE. 1391 * 1392 * 'os_pending_close' is set when an over-the-wire CLOSE is deferred to the 1393 * lost state queue. 1394 * 1395 * 'open_stateid' is set the last open stateid returned by the server unless 1396 * 'os_delegation' is 1, in which case 'open_stateid' refers to the 1397 * delegation stateid returned by the server. This is used in cases where the 1398 * client tries to OPEN a file but already has a suitable delegation, so we 1399 * just stick the delegation stateid in the open stream. 1400 * 1401 * os_dc_openacc are open access bits which have been granted to the 1402 * open stream by virtue of a delegation, but which have not been seen 1403 * by the server. This applies even if the open stream does not have 1404 * os_delegation set. These bits are used when setting file locks to 1405 * determine whether an open with CLAIM_DELEGATE_CUR needs to be done 1406 * before the lock request can be sent to the server. See 1407 * nfs4frlock_check_deleg(). 1408 * 1409 * 'os_mmap_read/write' keep track of the read and write access our memory 1410 * maps require. We need to keep track of this so we can provide the proper 1411 * access bits in the open/mmap/close/reboot/reopen case. 1412 * 1413 * 'os_failed_reopen' tells us that we failed to successfully reopen this 1414 * open stream; therefore, we should not use this open stateid as it is 1415 * not valid anymore. This flag is also used to indicate an unsuccessful 1416 * attempt to reopen a delegation open stream with CLAIM_DELEGATE_CUR. 1417 * 1418 * If 'os_orig_oo_name' is different than os_open_owner's oo_name 1419 * then this tells us that this open stream's open owner used a 1420 * bad seqid (that is, got NFS4ERR_BAD_SEQID). If different, this open 1421 * stream will no longer be used for future OTW state releasing calls. 1422 * 1423 * Lock ordering: 1424 * rnode4_t::r_os_lock > os_sync_lock 1425 * os_sync_lock > rnode4_t::r_statelock 1426 * os_sync_lock > rnode4_t::r_statev4_lock 1427 * os_sync_lock > mntinfo4_t::mi_lock (via hold over rfs4call) 1428 * 1429 * The 'os_sync_lock' protects: 1430 * open_stateid 1431 * os_dc_openacc 1432 * os_delegation 1433 * os_failed_reopen 1434 * os_final_close 1435 * os_force_close 1436 * os_mapcnt 1437 * os_mmap_read 1438 * os_mmap_write 1439 * os_open_ref_count 1440 * os_pending_close 1441 * os_share_acc_read 1442 * os_share_acc_write 1443 * os_share_deny_none 1444 * os_share_deny_read 1445 * os_share_deny_write 1446 * os_ref_count 1447 * os_valid 1448 * 1449 * The rnode4_t::r_os_lock protects: 1450 * os_node 1451 * 1452 * These fields are set at creation time and 1453 * read only after that: 1454 * os_open_owner 1455 * os_orig_oo_name 1456 */ 1457 typedef struct nfs4_open_stream { 1458 uint64_t os_share_acc_read; 1459 uint64_t os_share_acc_write; 1460 uint64_t os_mmap_read; 1461 uint64_t os_mmap_write; 1462 uint32_t os_share_deny_none; 1463 uint32_t os_share_deny_read; 1464 uint32_t os_share_deny_write; 1465 stateid4 open_stateid; 1466 int os_dc_openacc; 1467 int os_ref_count; 1468 unsigned os_valid:1; 1469 unsigned os_delegation:1; 1470 unsigned os_final_close:1; 1471 unsigned os_pending_close:1; 1472 unsigned os_failed_reopen:1; 1473 unsigned os_force_close:1; 1474 int os_open_ref_count; 1475 long os_mapcnt; 1476 list_node_t os_node; 1477 struct nfs4_open_owner *os_open_owner; 1478 uint64_t os_orig_oo_name; 1479 kmutex_t os_sync_lock; 1480 } nfs4_open_stream_t; 1481 1482 /* 1483 * This structure describes the format of the lock_owner_name 1484 * field of the lock owner. 1485 */ 1486 1487 typedef struct nfs4_lo_name { 1488 uint64_t ln_seq_num; 1489 pid_t ln_pid; 1490 } nfs4_lo_name_t; 1491 1492 /* 1493 * Flags for lo_flags. 1494 */ 1495 #define NFS4_LOCK_SEQID_INUSE 0x1 1496 #define NFS4_BAD_SEQID_LOCK 0x2 1497 1498 /* 1499 * The lo_prev_rnode and lo_next_rnode are for a circular list that hangs 1500 * off the rnode. If the links are NULL it means this object is not on the 1501 * list. 1502 * 1503 * 'lo_pending_rqsts' is non-zero if we ever tried to send a request and 1504 * didn't get a response back. This is used to figure out if we have 1505 * possible remote v4 locks, so that we can clean up at process exit. In 1506 * theory, the client should be able to figure out if the server received 1507 * the request (based on what seqid works), so maybe we can get rid of this 1508 * flag someday. 1509 * 1510 * 'lo_ref_count' tells us how many processes/threads are using this data 1511 * structure. The rnode's list accounts for one reference. 1512 * 1513 * 'lo_just_created' is set to NFS4_JUST_CREATED when we first create the 1514 * data structure. It is then set to NFS4_PERM_CREATED when a lock request 1515 * is successful using this lock owner structure. We need to keep 'temporary' 1516 * lock owners around so we can properly keep the lock seqid synchronization 1517 * when multiple processes/threads are trying to create the lock owner for the 1518 * first time (especially with the DENIED error case). Once 1519 * 'lo_just_created' is set to NFS4_PERM_CREATED, it doesn't change. 1520 * 1521 * 'lo_valid' tells us whether this structure is about to be freed or not, 1522 * if it is then don't return it from find_lock_owner(). 1523 * 1524 * Retrieving and setting of 'lock_seqid' is protected by the 1525 * NFS4_LOCK_SEQID_INUSE flag. Waiters for NFS4_LOCK_SEQID_INUSE should 1526 * use 'lo_cv_seqid_sync'. 1527 * 1528 * The setting of 'lock_stateid' is protected by the 1529 * NFS4_LOCK_SEQID_INUSE flag and 'lo_lock'. The retrieving of the 1530 * 'lock_stateid' is protected by 'lo_lock', with the additional 1531 * requirement that the calling function can handle NFS4ERR_OLD_STATEID and 1532 * NFS4ERR_BAD_STATEID as appropiate. 1533 * 1534 * The setting of NFS4_BAD_SEQID_LOCK to lo_flags tells us whether this lock 1535 * owner used a bad seqid (that is, got NFS4ERR_BAD_SEQID). With this set, 1536 * this lock owner will no longer be used for future OTW calls. Once set, 1537 * it is never unset. 1538 * 1539 * Lock ordering: 1540 * rnode4_t::r_statev4_lock > lo_lock 1541 */ 1542 typedef struct nfs4_lock_owner { 1543 struct nfs4_lock_owner *lo_next_rnode; 1544 struct nfs4_lock_owner *lo_prev_rnode; 1545 int lo_pid; 1546 stateid4 lock_stateid; 1547 seqid4 lock_seqid; 1548 /* 1549 * Fix this to always be 12 bytes 1550 */ 1551 nfs4_lo_name_t lock_owner_name; 1552 int lo_ref_count; 1553 int lo_valid; 1554 int lo_pending_rqsts; 1555 int lo_just_created; 1556 int lo_flags; 1557 kcondvar_t lo_cv_seqid_sync; 1558 kmutex_t lo_lock; 1559 kthread_t *lo_seqid_holder; /* debugging aid */ 1560 } nfs4_lock_owner_t; 1561 1562 /* for nfs4_lock_owner_t lookups */ 1563 typedef enum {LOWN_ANY, LOWN_VALID_STATEID} lown_which_t; 1564 1565 /* Number of times to retry a call that fails with state independent error */ 1566 #define NFS4_NUM_RECOV_RETRIES 3 1567 1568 typedef enum { 1569 NO_SID, 1570 DEL_SID, 1571 LOCK_SID, 1572 OPEN_SID, 1573 SPEC_SID 1574 } nfs4_stateid_type_t; 1575 1576 typedef struct nfs4_stateid_types { 1577 stateid4 d_sid; 1578 stateid4 l_sid; 1579 stateid4 o_sid; 1580 nfs4_stateid_type_t cur_sid_type; 1581 } nfs4_stateid_types_t; 1582 1583 /* 1584 * Per-zone data for dealing with callbacks. Included here solely for the 1585 * benefit of MDB. 1586 */ 1587 struct nfs4_callback_stats { 1588 kstat_named_t delegations; 1589 kstat_named_t cb_getattr; 1590 kstat_named_t cb_recall; 1591 kstat_named_t cb_null; 1592 kstat_named_t cb_dispatch; 1593 kstat_named_t delegaccept_r; 1594 kstat_named_t delegaccept_rw; 1595 kstat_named_t delegreturn; 1596 kstat_named_t callbacks; 1597 kstat_named_t claim_cur; 1598 kstat_named_t claim_cur_ok; 1599 kstat_named_t recall_trunc; 1600 kstat_named_t recall_failed; 1601 kstat_named_t return_limit_write; 1602 kstat_named_t return_limit_addmap; 1603 kstat_named_t deleg_recover; 1604 kstat_named_t cb_illegal; 1605 }; 1606 1607 struct nfs4_callback_globals { 1608 kmutex_t nfs4_cb_lock; 1609 kmutex_t nfs4_dlist_lock; 1610 int nfs4_program_hint; 1611 /* this table maps the program number to the nfs4_server structure */ 1612 struct nfs4_server **nfs4prog2server; 1613 list_t nfs4_dlist; 1614 list_t nfs4_cb_ports; 1615 struct nfs4_callback_stats nfs4_callback_stats; 1616 #ifdef DEBUG 1617 int nfs4_dlistadd_c; 1618 int nfs4_dlistclean_c; 1619 #endif 1620 }; 1621 1622 typedef enum { 1623 CLOSE_NORM, 1624 CLOSE_DELMAP, 1625 CLOSE_FORCE, 1626 CLOSE_RESEND, 1627 CLOSE_AFTER_RESEND 1628 } nfs4_close_type_t; 1629 1630 /* 1631 * Structure to hold the bad seqid information that is passed 1632 * to the recovery framework. 1633 */ 1634 typedef struct nfs4_bseqid_entry { 1635 nfs4_open_owner_t *bs_oop; 1636 nfs4_lock_owner_t *bs_lop; 1637 vnode_t *bs_vp; 1638 pid_t bs_pid; 1639 nfs4_tag_type_t bs_tag; 1640 seqid4 bs_seqid; 1641 list_node_t bs_node; 1642 } nfs4_bseqid_entry_t; 1643 1644 #ifdef _KERNEL 1645 1646 extern void nfs4close_one(vnode_t *, nfs4_open_stream_t *, cred_t *, int, 1647 nfs4_lost_rqst_t *, nfs4_error_t *, nfs4_close_type_t, 1648 size_t, uint_t, uint_t); 1649 extern void nfs4close_notw(vnode_t *, nfs4_open_stream_t *, int *); 1650 extern void nfs4_set_lock_stateid(nfs4_lock_owner_t *, stateid4); 1651 extern void open_owner_hold(nfs4_open_owner_t *); 1652 extern void open_owner_rele(nfs4_open_owner_t *); 1653 extern nfs4_open_stream_t *find_or_create_open_stream(nfs4_open_owner_t *, 1654 struct rnode4 *, int *); 1655 extern nfs4_open_stream_t *find_open_stream(nfs4_open_owner_t *, 1656 struct rnode4 *); 1657 extern nfs4_open_stream_t *create_open_stream(nfs4_open_owner_t *oop, 1658 struct rnode4 *rp); 1659 extern void open_stream_hold(nfs4_open_stream_t *); 1660 extern void open_stream_rele(nfs4_open_stream_t *, struct rnode4 *); 1661 extern int nfs4close_all(vnode_t *, cred_t *); 1662 extern void lock_owner_hold(nfs4_lock_owner_t *); 1663 extern void lock_owner_rele(nfs4_lock_owner_t *); 1664 extern nfs4_lock_owner_t *create_lock_owner(struct rnode4 *, pid_t); 1665 extern nfs4_lock_owner_t *find_lock_owner(struct rnode4 *, pid_t, lown_which_t); 1666 extern void nfs4_rnode_remove_lock_owner(struct rnode4 *, 1667 nfs4_lock_owner_t *); 1668 extern void nfs4_flush_lock_owners(struct rnode4 *); 1669 extern void nfs4_setlockowner_args(lock_owner4 *, struct rnode4 *, pid_t); 1670 extern void nfs4_set_open_seqid(seqid4, nfs4_open_owner_t *, 1671 nfs4_tag_type_t); 1672 extern void nfs4_set_lock_seqid(seqid4, nfs4_lock_owner_t *); 1673 extern void nfs4_get_and_set_next_open_seqid(nfs4_open_owner_t *, 1674 nfs4_tag_type_t); 1675 extern void nfs4_end_open_seqid_sync(nfs4_open_owner_t *); 1676 extern int nfs4_start_open_seqid_sync(nfs4_open_owner_t *, mntinfo4_t *); 1677 extern void nfs4_end_lock_seqid_sync(nfs4_lock_owner_t *); 1678 extern int nfs4_start_lock_seqid_sync(nfs4_lock_owner_t *, mntinfo4_t *); 1679 extern void nfs4_setup_lock_args(nfs4_lock_owner_t *, nfs4_open_owner_t *, 1680 nfs4_open_stream_t *, clientid4, locker4 *); 1681 extern void nfs4_destroy_open_owner(nfs4_open_owner_t *); 1682 1683 extern void nfs4_renew_lease_thread(nfs4_server_t *); 1684 extern nfs4_server_t *find_nfs4_server(mntinfo4_t *); 1685 extern nfs4_server_t *find_nfs4_server_all(mntinfo4_t *, int all); 1686 extern nfs4_server_t *new_nfs4_server(servinfo4_t *, cred_t *); 1687 extern void nfs4_mark_srv_dead(nfs4_server_t *); 1688 extern nfs4_server_t *servinfo4_to_nfs4_server(servinfo4_t *); 1689 extern void nfs4_inc_state_ref_count(mntinfo4_t *); 1690 extern void nfs4_inc_state_ref_count_nolock(nfs4_server_t *, 1691 mntinfo4_t *); 1692 extern void nfs4_dec_state_ref_count(mntinfo4_t *); 1693 extern void nfs4_dec_state_ref_count_nolock(nfs4_server_t *, 1694 mntinfo4_t *); 1695 extern clientid4 mi2clientid(mntinfo4_t *); 1696 extern int nfs4_server_in_recovery(nfs4_server_t *); 1697 extern bool_t nfs4_server_vlock(nfs4_server_t *, int); 1698 extern nfs4_open_owner_t *create_open_owner(cred_t *, mntinfo4_t *); 1699 extern uint64_t nfs4_get_new_oo_name(void); 1700 extern nfs4_open_owner_t *find_open_owner(cred_t *, int, mntinfo4_t *); 1701 extern nfs4_open_owner_t *find_open_owner_nolock(cred_t *, int, mntinfo4_t *); 1702 extern void nfs4frlock(nfs4_lock_call_type_t, vnode_t *, int, flock64_t *, 1703 int, u_offset_t, cred_t *, nfs4_error_t *, 1704 nfs4_lost_rqst_t *, int *); 1705 extern void nfs4open_dg_save_lost_rqst(int, nfs4_lost_rqst_t *, 1706 nfs4_open_owner_t *, nfs4_open_stream_t *, cred_t *, 1707 vnode_t *, int, int); 1708 extern void nfs4_open_downgrade(int, int, nfs4_open_owner_t *, 1709 nfs4_open_stream_t *, vnode_t *, cred_t *, 1710 nfs4_lost_rqst_t *, nfs4_error_t *, cred_t **, seqid4 *); 1711 extern seqid4 nfs4_get_open_seqid(nfs4_open_owner_t *); 1712 extern cred_t *nfs4_get_otw_cred(cred_t *, mntinfo4_t *, nfs4_open_owner_t *); 1713 extern void nfs4_init_stateid_types(nfs4_stateid_types_t *); 1714 extern void nfs4_save_stateid(stateid4 *, nfs4_stateid_types_t *); 1715 1716 extern kmutex_t nfs4_server_lst_lock; 1717 1718 extern void nfs4callback_destroy(nfs4_server_t *); 1719 extern void nfs4_callback_init(void); 1720 extern void nfs4_callback_fini(void); 1721 extern void nfs4_cb_args(nfs4_server_t *, struct knetconfig *, 1722 SETCLIENTID4args *); 1723 extern void nfs4delegreturn_async(struct rnode4 *, int, bool_t); 1724 1725 extern enum nfs4_delegreturn_policy nfs4_delegreturn_policy; 1726 1727 extern void nfs4_add_mi_to_server(nfs4_server_t *, mntinfo4_t *); 1728 extern void nfs4_remove_mi_from_server(mntinfo4_t *, nfs4_server_t *); 1729 extern nfs4_server_t *nfs4_move_mi(mntinfo4_t *, servinfo4_t *, servinfo4_t *); 1730 extern bool_t nfs4_fs_active(nfs4_server_t *); 1731 extern void nfs4_server_rele(nfs4_server_t *); 1732 extern bool_t inlease(nfs4_server_t *); 1733 extern bool_t nfs4_has_pages(vnode_t *); 1734 extern void nfs4_log_badowner(mntinfo4_t *, nfs_opnum4); 1735 1736 #endif /* _KERNEL */ 1737 1738 /* 1739 * Client State Recovery 1740 */ 1741 1742 /* 1743 * The following defines are used for rs_flags in 1744 * a nfs4_recov_state_t structure. 1745 * 1746 * NFS4_RS_RENAME_HELD Indicates that the mi_rename_lock was held. 1747 * NFS4_RS_GRACE_MSG Set once we have uprintf'ed a grace message. 1748 * NFS4_RS_DELAY_MSG Set once we have uprintf'ed a delay message. 1749 * NFS4_RS_RECALL_HELD1 r_deleg_recall_lock for vp1 was held. 1750 * NFS4_RS_RECALL_HELD2 r_deleg_recall_lock for vp2 was held. 1751 */ 1752 #define NFS4_RS_RENAME_HELD 0x000000001 1753 #define NFS4_RS_GRACE_MSG 0x000000002 1754 #define NFS4_RS_DELAY_MSG 0x000000004 1755 #define NFS4_RS_RECALL_HELD1 0x000000008 1756 #define NFS4_RS_RECALL_HELD2 0x000000010 1757 1758 /* 1759 * Information that is retrieved from nfs4_start_op() and that is 1760 * passed into nfs4_end_op(). 1761 * 1762 * rs_sp is a reference to the nfs4_server that was found, or NULL. 1763 * 1764 * rs_num_retry_despite_err is the number times client retried an 1765 * OTW op despite a recovery error. It is only incremented for hints 1766 * exempt to normal R4RECOVERR processing 1767 * (OH_CLOSE/OH_LOCKU/OH_DELEGRETURN). (XXX this special-case code 1768 * needs review for possible removal.) 1769 * It is initialized wherever nfs4_recov_state_t is declared -- usually 1770 * very near initialization of rs_flags. 1771 */ 1772 typedef struct { 1773 nfs4_server_t *rs_sp; 1774 int rs_flags; 1775 int rs_num_retry_despite_err; 1776 } nfs4_recov_state_t; 1777 1778 /* 1779 * Flags for nfs4_check_remap, nfs4_remap_file and nfs4_remap_root. 1780 */ 1781 1782 #define NFS4_REMAP_CKATTRS 1 1783 #define NFS4_REMAP_NEEDSOP 2 1784 1785 #ifdef _KERNEL 1786 1787 extern int nfs4_is_otw_open_necessary(nfs4_open_owner_t *, int, 1788 vnode_t *, int, int *, int, nfs4_recov_state_t *); 1789 extern void nfs4setclientid(struct mntinfo4 *, struct cred *, bool_t, 1790 nfs4_error_t *); 1791 extern void nfs4_reopen(vnode_t *, nfs4_open_stream_t *, nfs4_error_t *, 1792 open_claim_type4, bool_t, bool_t); 1793 extern void nfs4_remap_root(struct mntinfo4 *, nfs4_error_t *, int); 1794 extern void nfs4_check_remap(mntinfo4_t *mi, vnode_t *vp, int, 1795 nfs4_error_t *); 1796 extern void nfs4_remap_file(mntinfo4_t *mi, vnode_t *vp, int, 1797 nfs4_error_t *); 1798 extern int nfs4_make_dotdot(struct nfs4_sharedfh *, hrtime_t, 1799 vnode_t *, cred_t *, vnode_t **, int); 1800 extern void nfs4_fail_recov(vnode_t *, char *, int, nfsstat4); 1801 1802 extern int nfs4_needs_recovery(nfs4_error_t *, bool_t, vfs_t *); 1803 extern int nfs4_recov_marks_dead(nfsstat4); 1804 extern bool_t nfs4_start_recovery(nfs4_error_t *, struct mntinfo4 *, 1805 vnode_t *, vnode_t *, stateid4 *, 1806 nfs4_lost_rqst_t *, nfs_opnum4, nfs4_bseqid_entry_t *); 1807 extern int nfs4_start_op(struct mntinfo4 *, vnode_t *, vnode_t *, 1808 nfs4_recov_state_t *); 1809 extern void nfs4_end_op(struct mntinfo4 *, vnode_t *, vnode_t *, 1810 nfs4_recov_state_t *, bool_t); 1811 extern int nfs4_start_fop(struct mntinfo4 *, vnode_t *, vnode_t *, 1812 nfs4_op_hint_t, nfs4_recov_state_t *, bool_t *); 1813 extern void nfs4_end_fop(struct mntinfo4 *, vnode_t *, vnode_t *, 1814 nfs4_op_hint_t, nfs4_recov_state_t *, bool_t); 1815 extern char *nfs4_recov_action_to_str(nfs4_recov_t); 1816 1817 extern int wait_for_recall(vnode_t *, vnode_t *, nfs4_op_hint_t, 1818 nfs4_recov_state_t *); 1819 extern void nfs4_end_op_recall(vnode_t *, vnode_t *, nfs4_recov_state_t *); 1820 extern void nfs4_send_siglost(pid_t, mntinfo4_t *mi, vnode_t *vp, bool_t, 1821 int, nfsstat4); 1822 extern time_t nfs4err_delay_time; 1823 extern void nfs4_set_grace_wait(mntinfo4_t *); 1824 extern void nfs4_set_delay_wait(vnode_t *); 1825 extern int nfs4_wait_for_grace(mntinfo4_t *, nfs4_recov_state_t *); 1826 extern int nfs4_wait_for_delay(vnode_t *, nfs4_recov_state_t *); 1827 extern nfs4_bseqid_entry_t *nfs4_create_bseqid_entry(nfs4_open_owner_t *, 1828 nfs4_lock_owner_t *, vnode_t *, pid_t, nfs4_tag_type_t, 1829 seqid4); 1830 1831 extern void nfs4_resend_open_otw(vnode_t **, nfs4_lost_rqst_t *, 1832 nfs4_error_t *); 1833 extern void nfs4_resend_delegreturn(nfs4_lost_rqst_t *, nfs4_error_t *, 1834 nfs4_server_t *); 1835 extern int nfs4_rpc_retry_error(int); 1836 extern int nfs4_try_failover(nfs4_error_t *); 1837 extern void nfs4_free_msg(nfs4_debug_msg_t *); 1838 extern void nfs4_mnt_recov_kstat_init(vfs_t *); 1839 extern void nfs4_mi_kstat_inc_delay(mntinfo4_t *); 1840 extern void nfs4_mi_kstat_inc_no_grace(mntinfo4_t *); 1841 extern char *nfs4_stat_to_str(nfsstat4); 1842 extern char *nfs4_op_to_str(nfs_opnum4); 1843 1844 extern void nfs4_queue_event(nfs4_event_type_t, mntinfo4_t *, char *, 1845 uint_t, vnode_t *, vnode_t *, nfsstat4, char *, pid_t, 1846 nfs4_tag_type_t, nfs4_tag_type_t, seqid4, seqid4); 1847 extern void nfs4_queue_fact(nfs4_fact_type_t, mntinfo4_t *, nfsstat4, 1848 nfs4_recov_t, nfs_opnum4, bool_t, char *, int, vnode_t *); 1849 #pragma rarely_called(nfs4_queue_event) 1850 #pragma rarely_called(nfs4_queue_fact) 1851 1852 /* Used for preformed "." and ".." dirents */ 1853 extern char *nfs4_dot_entries; 1854 extern char *nfs4_dot_dot_entry; 1855 1856 #ifdef DEBUG 1857 extern uint_t nfs4_tsd_key; 1858 #endif 1859 1860 #endif /* _KERNEL */ 1861 1862 /* 1863 * Filehandle management. 1864 * 1865 * Filehandles can change in v4, so rather than storing the filehandle 1866 * directly in the rnode, etc., we manage the filehandle through one of 1867 * these objects. 1868 * Locking: sfh_fh and sfh_tree is protected by the filesystem's 1869 * mi_fh_lock. The reference count and flags are protected by sfh_lock. 1870 * sfh_mi is read-only. 1871 * 1872 * mntinfo4_t::mi_fh_lock > sfh_lock. 1873 */ 1874 1875 typedef struct nfs4_sharedfh { 1876 nfs_fh4 sfh_fh; /* key and current filehandle */ 1877 kmutex_t sfh_lock; 1878 uint_t sfh_refcnt; /* reference count */ 1879 uint_t sfh_flags; 1880 mntinfo4_t *sfh_mi; /* backptr to filesystem */ 1881 avl_node_t sfh_tree; /* used by avl package */ 1882 } nfs4_sharedfh_t; 1883 1884 #define SFH4_SAME(sfh1, sfh2) ((sfh1) == (sfh2)) 1885 1886 /* 1887 * Flags. 1888 */ 1889 #define SFH4_IN_TREE 0x1 /* currently in an AVL tree */ 1890 1891 #ifdef _KERNEL 1892 1893 extern void sfh4_createtab(avl_tree_t *); 1894 extern nfs4_sharedfh_t *sfh4_get(const nfs_fh4 *, mntinfo4_t *); 1895 extern nfs4_sharedfh_t *sfh4_put(const nfs_fh4 *, mntinfo4_t *, 1896 nfs4_sharedfh_t *); 1897 extern void sfh4_update(nfs4_sharedfh_t *, const nfs_fh4 *); 1898 extern void sfh4_copyval(const nfs4_sharedfh_t *, nfs4_fhandle_t *); 1899 extern void sfh4_hold(nfs4_sharedfh_t *); 1900 extern void sfh4_rele(nfs4_sharedfh_t **); 1901 extern void sfh4_printfhandle(const nfs4_sharedfh_t *); 1902 1903 #endif 1904 1905 /* 1906 * Path and file name management. 1907 * 1908 * This type stores the name of an entry in the filesystem and keeps enough 1909 * information that it can provide a complete path. All fields are 1910 * protected by fn_lock, except for the reference count, which is managed 1911 * using atomic add/subtract. 1912 * 1913 * Lock order: child and then parent. 1914 */ 1915 1916 typedef struct nfs4_fname { 1917 struct nfs4_fname *fn_parent; /* parent name; null if fs root */ 1918 char *fn_name; /* the actual name */ 1919 ssize_t fn_len; /* strlen(fn_name) */ 1920 uint32_t fn_refcnt; /* reference count */ 1921 kmutex_t fn_lock; 1922 avl_node_t fn_tree; 1923 avl_tree_t fn_children; /* children, if any */ 1924 } nfs4_fname_t; 1925 1926 #ifdef _KERNEL 1927 1928 extern vnode_t nfs4_xattr_notsupp_vnode; 1929 #define NFS4_XATTR_DIR_NOTSUPP &nfs4_xattr_notsupp_vnode 1930 1931 extern nfs4_fname_t *fn_get(nfs4_fname_t *, char *); 1932 extern void fn_hold(nfs4_fname_t *); 1933 extern void fn_rele(nfs4_fname_t **); 1934 extern char *fn_name(nfs4_fname_t *); 1935 extern char *fn_path(nfs4_fname_t *); 1936 extern void fn_move(nfs4_fname_t *, nfs4_fname_t *, char *); 1937 extern nfs4_fname_t *fn_parent(nfs4_fname_t *); 1938 1939 #endif 1940 1941 /* 1942 * Per-zone data for managing client handles, included in this file for the 1943 * benefit of MDB. 1944 */ 1945 struct nfs4_clnt { 1946 struct chhead *nfscl_chtable4; 1947 kmutex_t nfscl_chtable4_lock; 1948 zoneid_t nfscl_zoneid; 1949 list_node_t nfscl_node; 1950 struct clstat4 nfscl_stat; 1951 }; 1952 1953 #ifdef __cplusplus 1954 } 1955 #endif 1956 1957 #endif /* _NFS4_CLNT_H */ 1958