1 /* 2 * Copyright (c) 2008 Isilon Inc http://www.isilon.com/ 3 * Authors: Doug Rabson <dfr@rabson.org> 4 * Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org> 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * $FreeBSD$ 28 */ 29 30 /* 31 * Copyright 2012 Nexenta Systems, Inc. All rights reserved. 32 * Copyright (c) 2012 by Delphix. All rights reserved. 33 */ 34 35 /* 36 * NFS Lock Manager (NLM) private declarations, etc. 37 * 38 * Source code derived from FreeBSD nlm.h 39 */ 40 41 #ifndef _NLM_NLM_H_ 42 #define _NLM_NLM_H_ 43 44 #include <sys/cmn_err.h> 45 #include <sys/queue.h> 46 #include <sys/modhash.h> 47 #include <sys/avl.h> 48 49 #define RPC_MSGOUT(args...) cmn_err(CE_NOTE, args) 50 #define NLM_ERR(...) cmn_err(CE_NOTE, __VA_ARGS__) 51 #define NLM_WARN(...) cmn_err(CE_WARN, __VA_ARGS__) 52 53 #ifndef SEEK_SET 54 #define SEEK_SET 0 55 #endif 56 #ifndef SEEK_CUR 57 #define SEEK_CUR 1 58 #endif 59 #ifndef SEEK_END 60 #define SEEK_END 2 61 #endif 62 63 /* 64 * Maximum offset supported by NLM calls using the older 65 * (32-bit) versions of the protocol. 66 */ 67 #define MAX_UOFF32 0xffffffffULL 68 69 struct nlm_host; 70 struct vnode; 71 struct exportinfo; 72 struct shrlock; 73 struct _kthread; 74 75 /* 76 * How to read the code: probably the best point to start 77 * it the nlm_host structure that is sort of most major 78 * structure in klmmod. nlm_host is closely tied with all 79 * other NLM structures. 80 * 81 * There're three major locks we use inside NLM: 82 * 1) Global read-write lock (lm_lck) that is used to 83 * protect operations with sysid allocation and 84 * management of zone globals structures for each 85 * zone. 86 * 2) Zone global lock: (nlm_globals->lock) is a mutex 87 * used to protect all operations inside particular 88 * zone. 89 * 3) Host's lock: (nlm_host->nh_lock) is per-host mutex 90 * used to protect host's internal fields and all 91 * operations with the given host. 92 * 93 * Locks order _must_ obey the following scheme: 94 * lm_lck then nlm_globals->lock then nlm_host->nh_lock 95 * 96 * Locks: 97 * (g) locked by lm_lck 98 * (z) locked by nlm_globals->lock 99 * (l) locked by host->nh_lock 100 * (c) const until freeing 101 */ 102 103 /* 104 * Callback functions for nlm_do_lock() and others. 105 * 106 * Calls to nlm_do_lock are unusual, because it needs to handle 107 * the reply itself, instead of letting it happen the normal way. 108 * It also needs to make an RPC call _back_ to the client when a 109 * blocked lock request completes. 110 * 111 * We pass three callback functions to nlm_do_lock: 112 * nlm_reply_cb: send a normal RPC reply 113 * nlm_res_cb: do a _res (message style) RPC (call) 114 * nlm_testargs_cb: do a "granted" RPC call (after blocking) 115 * Only one of the 1st or 2nd is used. 116 * The 3rd is used only for blocking 117 * 118 * We also use callback functions for all the _msg variants 119 * of the NLM svc calls, where the reply is a reverse call. 120 * The nlm_testres_cb is used by the _test_msg svc calls. 121 * The nlm_res_cb type is used by the other _msg calls. 122 */ 123 typedef bool_t (*nlm_reply_cb)(SVCXPRT *, nlm4_res *); 124 typedef enum clnt_stat (*nlm_res_cb)(nlm4_res *, void *, CLIENT *); 125 typedef enum clnt_stat (*nlm_testargs_cb)(nlm4_testargs *, void *, CLIENT *); 126 typedef enum clnt_stat (*nlm_testres_cb)(nlm4_testres *, void *, CLIENT *); 127 128 /* 129 * NLM sleeping lock request. 130 * 131 * Sleeping lock requests are server side only objects 132 * that are created when client asks server to add new 133 * sleeping lock and when this lock needs to block. 134 * Server keeps a track of these requests in order to be 135 * able to cancel them or clean them up. 136 * 137 * Sleeping lock requests are closely tiled with particular 138 * vnode or, strictly speaking, NLM vhold object that holds 139 * the vnode. 140 * 141 * struct nlm_slreq: 142 * nsr_fl: an information about file lock 143 * nsr_link: a list node to store lock requests 144 * in vhold object. 145 */ 146 struct nlm_slreq { 147 struct flock64 nsr_fl; 148 TAILQ_ENTRY(nlm_slreq) nsr_link; 149 }; 150 TAILQ_HEAD(nlm_slreq_list, nlm_slreq); 151 152 /* 153 * NLM vhold object is a sort of wrapper on vnodes remote 154 * clients have locked (or added share reservation) 155 * on NLM server. Vhold keeps vnode held (by VN_HOLD()) 156 * while vnode has any locks or shares made by parent host. 157 * Vholds are used for two purposes: 158 * 1) Hold vnode (with VN_HOLD) while it has any locks; 159 * 2) Keep a track of all vnodes remote host touched 160 * with lock/share operations on NLM server, so that NLM 161 * can know what vnodes are potentially locked; 162 * 163 * Vholds are used on server side only. For server side it's really 164 * important to keep vnodes held while they potentially have 165 * any locks/shares. In contrast, it's not important for clinet 166 * side at all. When particular vnode comes to the NLM client side 167 * code, it's already held (VN_HOLD) by the process calling 168 * lock/share function (it's referenced because client calls open() 169 * before making locks or shares). 170 * 171 * Each NLM host object has a collection of vholds associated 172 * with vnodes host touched earlier by adding locks or shares. 173 * Having this collection allows us to decide if host is still 174 * in use. When it has any vhold objects it's considered to be 175 * in use. Otherwise we're free to destroy it. 176 * 177 * Vholds are destroyed by the NLM garbage collecter thread that 178 * periodically checks whether they have any locks or shares. 179 * Checking occures when parent host is untouched by client 180 * or server for some period of time. 181 * 182 * struct nlm_vhold: 183 * nv_vp: a pointer to vnode that is hold by given nlm_vhold 184 * nv_refcnt: reference counter (non zero when vhold is inuse) 185 * nv_slreqs: sleeping lock requests that were made on the nv_vp 186 * nv_link: list node to store vholds in host's nh_vnodes_list 187 */ 188 struct nlm_vhold { 189 vnode_t *nv_vp; /* (c) */ 190 int nv_refcnt; /* (l) */ 191 struct nlm_slreq_list nv_slreqs; /* (l) */ 192 TAILQ_ENTRY(nlm_vhold) nv_link; /* (l) */ 193 }; 194 TAILQ_HEAD(nlm_vhold_list, nlm_vhold); 195 196 /* 197 * Client side sleeping lock state. 198 * - NLM_SL_BLOCKED: some thread is blocked on this lock 199 * - NLM_SL_GRANTED: server granted us the lock 200 * - NLM_SL_CANCELLED: the lock is cancelled (i.e. invalid/inactive) 201 */ 202 typedef enum nlm_slock_state { 203 NLM_SL_UNKNOWN = 0, 204 NLM_SL_BLOCKED, 205 NLM_SL_GRANTED, 206 NLM_SL_CANCELLED 207 } nlm_slock_state_t; 208 209 /* 210 * A client side sleeping lock request (set by F_SETLKW) 211 * stored in nlm_slocks collection of nlm_globals. 212 * 213 * struct nlm_slock 214 * nsl_state: Sleeping lock state. 215 * (see nlm_slock_state for more information) 216 * nsl_cond: Condvar that is used when sleeping lock 217 * needs to wait for a GRANT callback 218 * or cancellation event. 219 * nsl_lock: nlm4_lock structure that is sent to the server 220 * nsl_fh: Filehandle that corresponds to nw_vp 221 * nsl_host: A host owning this sleeping lock 222 * nsl_vp: A vnode sleeping lock is waiting on. 223 * nsl_link: A list node for nlm_globals->nlm_slocks list. 224 */ 225 struct nlm_slock { 226 nlm_slock_state_t nsl_state; /* (z) */ 227 kcondvar_t nsl_cond; /* (z) */ 228 nlm4_lock nsl_lock; /* (c) */ 229 struct netobj nsl_fh; /* (c) */ 230 struct nlm_host *nsl_host; /* (c) */ 231 struct vnode *nsl_vp; /* (c) */ 232 TAILQ_ENTRY(nlm_slock) nsl_link; /* (z) */ 233 }; 234 TAILQ_HEAD(nlm_slock_list, nlm_slock); 235 236 /* 237 * Share reservation description. NLM tracks all active 238 * share reservations made by the client side, so that 239 * they can be easily recovered if remote NLM server 240 * reboots. Share reservations tracking is also useful 241 * when NLM needs to determine whether host owns any 242 * resources on the system and can't be destroyed. 243 * 244 * nlm_shres: 245 * ns_shr: share reservation description 246 * ns_vp: a pointer to vnode where share reservation is located 247 * ns_next: next nlm_shres instance (or NULL if next item isn't 248 * present). 249 */ 250 struct nlm_shres { 251 struct shrlock *ns_shr; 252 vnode_t *ns_vp; 253 struct nlm_shres *ns_next; 254 }; 255 256 /* 257 * NLM RPC handle object. 258 * 259 * In kRPC subsystem it's unsafe to use one RPC handle by 260 * several threads simultaneously. It was designed so that 261 * each thread has to create an RPC handle that it'll use. 262 * RPC handle creation can be quite expensive operation, especially 263 * with session oriented protocols (such as TCP) that need to 264 * establish session at first. NLM RPC handle object is a sort of 265 * wrapper on kRPC handle object that can be cached and used in 266 * future. We store all created RPC handles for given host in a 267 * host's RPC handles cache, so that to make new requests threads 268 * can simply take ready objects from the cache. That improves 269 * NLM performance. 270 * 271 * nlm_rpc_t: 272 * nr_handle: a kRPC handle itself. 273 * nr_vers: a version of NLM protocol kRPC handle was 274 * created for. 275 * nr_link: a list node to store NLM RPC handles in the host 276 * RPC handles cache. 277 */ 278 typedef struct nlm_rpc { 279 CLIENT *nr_handle; /* (l) */ 280 rpcvers_t nr_vers; /* (c) */ 281 TAILQ_ENTRY(nlm_rpc) nr_link; /* (l) */ 282 } nlm_rpc_t; 283 TAILQ_HEAD(nlm_rpch_list, nlm_rpc); 284 285 /* 286 * Describes the state of NLM host's RPC binding. 287 * RPC binding can be in one of three states: 288 * 1) NRPCB_NEED_UPDATE: 289 * Binding is either not initialized or stale. 290 * 2) NRPCB_UPDATE_INPROGRESS: 291 * When some thread updates host's RPC binding, 292 * it sets binding's state to NRPCB_UPDATE_INPROGRESS 293 * which denotes that other threads must wait until 294 * update process is finished. 295 * 3) NRPCB_UPDATED: 296 * Denotes that host's RPC binding is both initialized 297 * and fresh. 298 */ 299 enum nlm_rpcb_state { 300 NRPCB_NEED_UPDATE = 0, 301 NRPCB_UPDATE_INPROGRESS, 302 NRPCB_UPDATED 303 }; 304 305 /* 306 * NLM host flags 307 */ 308 #define NLM_NH_MONITORED 0x01 309 #define NLM_NH_RECLAIM 0x02 310 #define NLM_NH_INIDLE 0x04 311 #define NLM_NH_SUSPEND 0x08 312 313 /* 314 * NLM host object is the most major structure in NLM. 315 * It identifies remote client or remote server or both. 316 * NLM host object keep a track of all vnodes client/server 317 * locked and all sleeping locks it has. All lock/unlock 318 * operations are done using host object. 319 * 320 * nlm_host: 321 * nh_lock: a mutex protecting host object fields 322 * nh_refs: reference counter. Identifies how many threads 323 * uses this host object. 324 * nh_link: a list node for keeping host in zone-global list. 325 * nh_by_addr: an AVL tree node for keeping host in zone-global tree. 326 * Host can be looked up in the tree by <netid, address> 327 * pair. 328 * nh_name: host name. 329 * nh_netid: netid string identifying type of transport host uses. 330 * nh_knc: host's knetconfig (used by kRPC subsystem). 331 * nh_addr: host's address (either IPv4 or IPv6). 332 * nh_sysid: unique sysid associated with this host. 333 * nh_state: last seen host's state reported by NSM. 334 * nh_flags: ORed host flags. 335 * nh_idle_timeout: host idle timeout. When expired host is freed. 336 * nh_recl_cv: condition variable used for reporting that reclamation 337 * process is finished. 338 * nh_rpcb_cv: condition variable that is used to make sure 339 * that only one thread renews host's RPC binding. 340 * nh_rpcb_ustat: error code returned by RPC binding update operation. 341 * nh_rpcb_state: host's RPC binding state (see enum nlm_rpcb_state 342 * for more details). 343 * nh_rpchc: host's RPC handles cache. 344 * nh_vholds_by_vp: a hash table of all vholds host owns. (used for lookup) 345 * nh_vholds_list: a linked list of all vholds host owns. (used for iteration) 346 * nh_shrlist: a list of all active share resevations on the client side. 347 * nh_reclaimer: a pointer to reclamation thread (kthread_t) 348 * NULL if reclamation thread doesn't exist 349 */ 350 struct nlm_host { 351 kmutex_t nh_lock; /* (c) */ 352 volatile uint_t nh_refs; /* (z) */ 353 TAILQ_ENTRY(nlm_host) nh_link; /* (z) */ 354 avl_node_t nh_by_addr; /* (z) */ 355 char *nh_name; /* (c) */ 356 char *nh_netid; /* (c) */ 357 struct knetconfig nh_knc; /* (c) */ 358 struct netbuf nh_addr; /* (c) */ 359 sysid_t nh_sysid; /* (c) */ 360 int32_t nh_state; /* (z) */ 361 clock_t nh_idle_timeout; /* (z) */ 362 uint8_t nh_flags; /* (z) */ 363 kcondvar_t nh_recl_cv; /* (z) */ 364 kcondvar_t nh_rpcb_cv; /* (l) */ 365 enum clnt_stat nh_rpcb_ustat; /* (l) */ 366 enum nlm_rpcb_state nh_rpcb_state; /* (l) */ 367 struct nlm_rpch_list nh_rpchc; /* (l) */ 368 mod_hash_t *nh_vholds_by_vp; /* (l) */ 369 struct nlm_vhold_list nh_vholds_list; /* (l) */ 370 struct nlm_shres *nh_shrlist; /* (l) */ 371 kthread_t *nh_reclaimer; /* (l) */ 372 }; 373 TAILQ_HEAD(nlm_host_list, nlm_host); 374 375 /* 376 * nlm_nsm structure describes RPC client handle that can be 377 * used to communicate with local NSM via kRPC. 378 * 379 * We need to wrap handle with nlm_nsm structure because kRPC 380 * can not share one handle between several threads. It's assumed 381 * that NLM uses only one NSM handle per zone, thus all RPC operations 382 * on NSM's handle are serialized using nlm_nsm->sem semaphore. 383 * 384 * nlm_nsm also contains refcnt field used for reference counting. 385 * It's used because there exist a possibility of simultaneous 386 * execution of NLM shutdown operation and host monitor/unmonitor 387 * operations. 388 * 389 * struct nlm_nsm: 390 * ns_sem: a semaphore for serialization network operations to statd 391 * ns_knc: a kneconfig describing transport that is used for communication 392 * ns_addr: an address of local statd we're talking to 393 * ns_handle: an RPC handle used for talking to local statd using the status 394 * monitor protocol (SM_PROG) 395 * ns_addr_handle: an RPC handle used for talking to local statd using the 396 * address registration protocol (NSM_ADDR_PROGRAM) 397 */ 398 struct nlm_nsm { 399 ksema_t ns_sem; 400 struct knetconfig ns_knc; /* (c) */ 401 struct netbuf ns_addr; /* (c) */ 402 CLIENT *ns_handle; /* (c) */ 403 CLIENT *ns_addr_handle; /* (c) */ 404 }; 405 406 /* 407 * Could use flock.h flk_nlm_status_t instead, but 408 * prefer our own enum with initial zero... 409 */ 410 typedef enum { 411 NLM_ST_DOWN = 0, 412 NLM_ST_STOPPING, 413 NLM_ST_UP, 414 NLM_ST_STARTING 415 } nlm_run_status_t; 416 417 /* 418 * nlm_globals structure allows NLM be zone aware. The structure 419 * collects all "global variables" NLM has for each zone. 420 * 421 * struct nlm_globals: 422 * lock: mutex protecting all operations inside given zone 423 * grace_threshold: grace period expiration time (in ticks) 424 * lockd_pid: PID of lockd user space daemon 425 * run_status: run status of klmmod inside given zone 426 * nsm_state: state obtained from local statd during klmmod startup 427 * nlm_gc_thread: garbage collector thread 428 * nlm_gc_sched_cv: condvar that can be signalled to wakeup GC 429 * nlm_gc_finish_cv: condvar that is signalled just before GC thread exits 430 * nlm_nsm: an object describing RPC handle used for talking to local statd 431 * nlm_hosts_tree: an AVL tree of all hosts in the given zone 432 * (used for hosts lookup by <netid, address> pair) 433 * nlm_hosts_hash: a hash table of all hosts in the given zone 434 * (used for hosts lookup by sysid) 435 * nlm_idle_hosts: a list of all hosts that are idle state (i.e. unused) 436 * nlm_slocks: a list of all client-side sleeping locks in the zone 437 * cn_idle_tmo: a value of idle timeout (in seconds) obtained from lockd 438 * grace_period: a value of grace period (in seconds) obtained from lockd 439 * retrans_tmo: a value of retransmission timeout (in seconds) obtained 440 * from lockd. 441 * clean_lock: mutex used to serialize clear_locks calls. 442 * nlm_link: a list node used for keeping all nlm_globals objects 443 * in one global linked list. 444 */ 445 struct nlm_globals { 446 kmutex_t lock; 447 clock_t grace_threshold; /* (z) */ 448 pid_t lockd_pid; /* (z) */ 449 nlm_run_status_t run_status; /* (z) */ 450 int32_t nsm_state; /* (z) */ 451 kthread_t *nlm_gc_thread; /* (z) */ 452 kcondvar_t nlm_gc_sched_cv; /* (z) */ 453 kcondvar_t nlm_gc_finish_cv; /* (z) */ 454 struct nlm_nsm nlm_nsm; /* (z) */ 455 avl_tree_t nlm_hosts_tree; /* (z) */ 456 mod_hash_t *nlm_hosts_hash; /* (z) */ 457 struct nlm_host_list nlm_idle_hosts; /* (z) */ 458 struct nlm_slock_list nlm_slocks; /* (z) */ 459 int cn_idle_tmo; /* (z) */ 460 int grace_period; /* (z) */ 461 int retrans_tmo; /* (z) */ 462 kmutex_t clean_lock; /* (c) */ 463 TAILQ_ENTRY(nlm_globals) nlm_link; /* (g) */ 464 }; 465 TAILQ_HEAD(nlm_globals_list, nlm_globals); 466 467 468 /* 469 * This is what we pass as the "owner handle" for NLM_LOCK. 470 * This lets us find the blocked lock in NLM_GRANTED. 471 * It also exposes on the wire what we're using as the 472 * sysid for any server, which can be very helpful for 473 * problem diagnosis. (Observability is good). 474 */ 475 struct nlm_owner_handle { 476 sysid_t oh_sysid; /* of remote host */ 477 }; 478 479 /* 480 * Number retries NLM RPC call is repeatead in case of failure. 481 * (used in case of conectionless transport). 482 */ 483 #define NLM_RPC_RETRIES 5 484 485 /* 486 * Klmmod global variables 487 */ 488 extern krwlock_t lm_lck; 489 extern zone_key_t nlm_zone_key; 490 491 /* 492 * NLM interface functions (called directly by 493 * either klmmod or klmpos) 494 */ 495 extern int nlm_frlock(struct vnode *, int, struct flock64 *, int, u_offset_t, 496 struct cred *, struct netobj *, struct flk_callback *, int); 497 extern int nlm_shrlock(struct vnode *, int, struct shrlock *, int, 498 struct netobj *, int); 499 extern int nlm_safemap(const vnode_t *); 500 extern int nlm_safelock(vnode_t *, const struct flock64 *, cred_t *); 501 extern int nlm_has_sleep(const vnode_t *); 502 extern void nlm_register_lock_locally(struct vnode *, struct nlm_host *, 503 struct flock64 *, int, u_offset_t); 504 int nlm_vp_active(const vnode_t *vp); 505 void nlm_sysid_free(sysid_t); 506 int nlm_vp_active(const vnode_t *); 507 void nlm_unexport(struct exportinfo *); 508 509 /* 510 * NLM startup/shutdown 511 */ 512 int nlm_svc_starting(struct nlm_globals *, struct file *, 513 const char *, struct knetconfig *); 514 void nlm_svc_stopping(struct nlm_globals *); 515 int nlm_svc_add_ep(struct file *, const char *, struct knetconfig *); 516 517 /* 518 * NLM suspend/resume 519 */ 520 void nlm_cprsuspend(void); 521 void nlm_cprresume(void); 522 523 /* 524 * NLM internal functions for initialization. 525 */ 526 void nlm_init(void); 527 void nlm_rpc_init(void); 528 void nlm_rpc_cache_destroy(struct nlm_host *); 529 void nlm_globals_register(struct nlm_globals *); 530 void nlm_globals_unregister(struct nlm_globals *); 531 sysid_t nlm_sysid_alloc(void); 532 533 /* 534 * Client reclamation/cancelation 535 */ 536 void nlm_reclaim_client(struct nlm_globals *, struct nlm_host *); 537 void nlm_client_cancel_all(struct nlm_globals *, struct nlm_host *); 538 539 /* (nlm_rpc_clnt.c) */ 540 enum clnt_stat nlm_null_rpc(CLIENT *, rpcvers_t); 541 enum clnt_stat nlm_test_rpc(nlm4_testargs *, nlm4_testres *, 542 CLIENT *, rpcvers_t); 543 enum clnt_stat nlm_lock_rpc(nlm4_lockargs *, nlm4_res *, 544 CLIENT *, rpcvers_t); 545 enum clnt_stat nlm_cancel_rpc(nlm4_cancargs *, nlm4_res *, 546 CLIENT *, rpcvers_t); 547 enum clnt_stat nlm_unlock_rpc(nlm4_unlockargs *, nlm4_res *, 548 CLIENT *, rpcvers_t); 549 enum clnt_stat nlm_share_rpc(nlm4_shareargs *, nlm4_shareres *, 550 CLIENT *, rpcvers_t); 551 enum clnt_stat nlm_unshare_rpc(nlm4_shareargs *, nlm4_shareres *, 552 CLIENT *, rpcvers_t); 553 554 555 /* 556 * RPC service functions. 557 * nlm_dispatch.c 558 */ 559 void nlm_prog_3(struct svc_req *rqstp, SVCXPRT *transp); 560 void nlm_prog_4(struct svc_req *rqstp, SVCXPRT *transp); 561 562 /* 563 * Functions for working with knetconfigs (nlm_netconfig.c) 564 */ 565 const char *nlm_knc_to_netid(struct knetconfig *); 566 int nlm_knc_from_netid(const char *, struct knetconfig *); 567 568 /* 569 * NLM host functions (nlm_impl.c) 570 */ 571 struct nlm_host *nlm_host_findcreate(struct nlm_globals *, char *, 572 const char *, struct netbuf *); 573 struct nlm_host *nlm_host_find(struct nlm_globals *, 574 const char *, struct netbuf *); 575 struct nlm_host *nlm_host_find_by_sysid(struct nlm_globals *, sysid_t); 576 void nlm_host_release(struct nlm_globals *, struct nlm_host *); 577 578 void nlm_host_monitor(struct nlm_globals *, struct nlm_host *, int); 579 void nlm_host_unmonitor(struct nlm_globals *, struct nlm_host *); 580 581 void nlm_host_notify_server(struct nlm_host *, int32_t); 582 void nlm_host_notify_client(struct nlm_host *, int32_t); 583 584 int nlm_host_get_state(struct nlm_host *); 585 586 struct nlm_vhold *nlm_vhold_get(struct nlm_host *, vnode_t *); 587 void nlm_vhold_release(struct nlm_host *, struct nlm_vhold *); 588 struct nlm_vhold *nlm_vhold_find_locked(struct nlm_host *, const vnode_t *); 589 590 struct nlm_slock *nlm_slock_register(struct nlm_globals *, 591 struct nlm_host *, struct nlm4_lock *, struct vnode *); 592 void nlm_slock_unregister(struct nlm_globals *, struct nlm_slock *); 593 int nlm_slock_wait(struct nlm_globals *, struct nlm_slock *, uint_t); 594 int nlm_slock_grant(struct nlm_globals *, 595 struct nlm_host *, struct nlm4_lock *); 596 void nlm_host_cancel_slocks(struct nlm_globals *, struct nlm_host *); 597 598 int nlm_slreq_register(struct nlm_host *, 599 struct nlm_vhold *, struct flock64 *); 600 int nlm_slreq_unregister(struct nlm_host *, 601 struct nlm_vhold *, struct flock64 *); 602 603 void nlm_shres_track(struct nlm_host *, vnode_t *, struct shrlock *); 604 void nlm_shres_untrack(struct nlm_host *, vnode_t *, struct shrlock *); 605 struct nlm_shres *nlm_get_active_shres(struct nlm_host *); 606 void nlm_free_shrlist(struct nlm_shres *); 607 608 int nlm_host_wait_grace(struct nlm_host *); 609 int nlm_host_cmp(const void *, const void *); 610 void nlm_copy_netobj(struct netobj *, struct netobj *); 611 612 int nlm_host_get_rpc(struct nlm_host *, int, nlm_rpc_t **); 613 void nlm_host_rele_rpc(struct nlm_host *, nlm_rpc_t *); 614 615 /* 616 * NLM server functions (nlm_service.c) 617 */ 618 int nlm_vp_active(const vnode_t *vp); 619 void nlm_do_notify1(nlm_sm_status *, void *, struct svc_req *); 620 void nlm_do_notify2(nlm_sm_status *, void *, struct svc_req *); 621 void nlm_do_test(nlm4_testargs *, nlm4_testres *, 622 struct svc_req *, nlm_testres_cb); 623 void nlm_do_lock(nlm4_lockargs *, nlm4_res *, struct svc_req *, 624 nlm_reply_cb, nlm_res_cb, nlm_testargs_cb); 625 void nlm_do_cancel(nlm4_cancargs *, nlm4_res *, 626 struct svc_req *, nlm_res_cb); 627 void nlm_do_unlock(nlm4_unlockargs *, nlm4_res *, 628 struct svc_req *, nlm_res_cb); 629 void nlm_do_granted(nlm4_testargs *, nlm4_res *, 630 struct svc_req *, nlm_res_cb); 631 void nlm_do_share(nlm4_shareargs *, nlm4_shareres *, struct svc_req *); 632 void nlm_do_unshare(nlm4_shareargs *, nlm4_shareres *, struct svc_req *); 633 void nlm_do_free_all(nlm4_notify *, void *, struct svc_req *); 634 635 /* 636 * NLM RPC functions 637 */ 638 enum clnt_stat nlm_clnt_call(CLIENT *, rpcproc_t, xdrproc_t, 639 caddr_t, xdrproc_t, caddr_t, struct timeval); 640 bool_t nlm_caller_is_local(SVCXPRT *); 641 642 #endif /* _NLM_NLM_H_ */ 643