1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy is of the CDDL is also available via the Internet 9 * at http://www.illumos.org/license/CDDL. 10 */ 11 12 /* 13 * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 14 * Copyright (c) 2012 by Delphix. All rights reserved. 15 */ 16 17 /* 18 * NFS Lock Manager, server-side and common. 19 * 20 * This file contains all the external entry points of klmmod. 21 * Basically, this is the "glue" to the BSD nlm code. 22 */ 23 24 #include <sys/types.h> 25 #include <sys/errno.h> 26 #include <sys/modctl.h> 27 #include <sys/flock.h> 28 29 #include <nfs/nfs.h> 30 #include <nfs/nfssys.h> 31 #include <nfs/lm.h> 32 #include <rpcsvc/nlm_prot.h> 33 #include "nlm_impl.h" 34 35 static struct modlmisc modlmisc = { 36 &mod_miscops, "lock mgr common module" 37 }; 38 39 static struct modlinkage modlinkage = { 40 MODREV_1, &modlmisc, NULL 41 }; 42 43 /* 44 * Cluster node ID. Zero unless we're part of a cluster. 45 * Set by lm_set_nlmid_flk. Pass to lm_set_nlm_status. 46 * We're not yet doing "clustered" NLM stuff. 47 */ 48 int lm_global_nlmid = 0; 49 50 /* 51 * Call-back hook for clusters: Set lock manager status. 52 * If this hook is set, call this instead of the ususal 53 * flk_set_lockmgr_status(FLK_LOCKMGR_UP / DOWN); 54 */ 55 void (*lm_set_nlm_status)(int nlm_id, flk_nlm_status_t) = NULL; 56 57 /* 58 * Call-back hook for clusters: Delete all locks held by sysid. 59 * Call from code that drops all client locks (for which we're 60 * the server) i.e. after the SM tells us a client has crashed. 61 */ 62 void (*lm_remove_file_locks)(int) = NULL; 63 64 krwlock_t lm_lck; 65 zone_key_t nlm_zone_key; 66 67 /* 68 * Init/fini per-zone stuff for klm 69 */ 70 /* ARGSUSED */ 71 void * 72 lm_zone_init(zoneid_t zoneid) 73 { 74 struct nlm_globals *g; 75 76 g = kmem_zalloc(sizeof (*g), KM_SLEEP); 77 78 avl_create(&g->nlm_hosts_tree, nlm_host_cmp, 79 sizeof (struct nlm_host), 80 offsetof(struct nlm_host, nh_by_addr)); 81 82 g->nlm_hosts_hash = mod_hash_create_idhash("nlm_host_by_sysid", 83 64, mod_hash_null_valdtor); 84 85 TAILQ_INIT(&g->nlm_idle_hosts); 86 TAILQ_INIT(&g->nlm_slocks); 87 88 mutex_init(&g->lock, NULL, MUTEX_DEFAULT, NULL); 89 cv_init(&g->nlm_gc_sched_cv, NULL, CV_DEFAULT, NULL); 90 cv_init(&g->nlm_gc_finish_cv, NULL, CV_DEFAULT, NULL); 91 mutex_init(&g->clean_lock, NULL, MUTEX_DEFAULT, NULL); 92 93 g->lockd_pid = 0; 94 g->run_status = NLM_ST_DOWN; 95 96 nlm_globals_register(g); 97 return (g); 98 } 99 100 /* ARGSUSED */ 101 void 102 lm_zone_fini(zoneid_t zoneid, void *data) 103 { 104 struct nlm_globals *g = data; 105 106 ASSERT(avl_is_empty(&g->nlm_hosts_tree)); 107 avl_destroy(&g->nlm_hosts_tree); 108 mod_hash_destroy_idhash(g->nlm_hosts_hash); 109 110 ASSERT(g->nlm_gc_thread == NULL); 111 mutex_destroy(&g->lock); 112 cv_destroy(&g->nlm_gc_sched_cv); 113 cv_destroy(&g->nlm_gc_finish_cv); 114 mutex_destroy(&g->clean_lock); 115 116 nlm_globals_unregister(g); 117 kmem_free(g, sizeof (*g)); 118 } 119 120 121 122 /* 123 * **************************************************************** 124 * module init, fini, info 125 */ 126 int 127 _init() 128 { 129 int retval; 130 131 rw_init(&lm_lck, NULL, RW_DEFAULT, NULL); 132 nlm_init(); 133 134 zone_key_create(&nlm_zone_key, lm_zone_init, NULL, lm_zone_fini); 135 /* Per-zone lockmgr data. See: os/flock.c */ 136 zone_key_create(&flock_zone_key, flk_zone_init, NULL, flk_zone_fini); 137 138 retval = mod_install(&modlinkage); 139 if (retval == 0) 140 return (0); 141 142 /* 143 * mod_install failed! undo above, reverse order 144 */ 145 146 (void) zone_key_delete(flock_zone_key); 147 flock_zone_key = ZONE_KEY_UNINITIALIZED; 148 (void) zone_key_delete(nlm_zone_key); 149 rw_destroy(&lm_lck); 150 151 return (retval); 152 } 153 154 int 155 _fini() 156 { 157 /* Don't unload. */ 158 return (EBUSY); 159 } 160 161 int 162 _info(struct modinfo *modinfop) 163 { 164 return (mod_info(&modlinkage, modinfop)); 165 } 166 167 168 169 /* 170 * **************************************************************** 171 * Stubs listed in modstubs.s 172 */ 173 174 /* 175 * klm system calls. Start service on some endpoint. 176 * Called by nfssys() LM_SVC, from lockd. 177 */ 178 int 179 lm_svc(struct lm_svc_args *args) 180 { 181 struct knetconfig knc; 182 const char *netid; 183 struct nlm_globals *g; 184 struct file *fp = NULL; 185 int err = 0; 186 187 /* Get our "globals" */ 188 g = zone_getspecific(nlm_zone_key, curzone); 189 190 /* 191 * Check version of lockd calling. 192 */ 193 if (args->version != LM_SVC_CUR_VERS) { 194 NLM_ERR("lm_svc: Version mismatch " 195 "(given 0x%x, expected 0x%x)\n", 196 args->version, LM_SVC_CUR_VERS); 197 return (EINVAL); 198 } 199 200 /* 201 * Build knetconfig, checking arg values. 202 * Also come up with the "netid" string. 203 * (With some knowledge of /etc/netconfig) 204 */ 205 bzero(&knc, sizeof (knc)); 206 switch (args->n_proto) { 207 case LM_TCP: 208 knc.knc_semantics = NC_TPI_COTS_ORD; 209 knc.knc_proto = NC_TCP; 210 break; 211 case LM_UDP: 212 knc.knc_semantics = NC_TPI_CLTS; 213 knc.knc_proto = NC_UDP; 214 break; 215 default: 216 NLM_ERR("nlm_build_knetconfig: Unknown " 217 "lm_proto=0x%x\n", args->n_proto); 218 return (EINVAL); 219 } 220 221 switch (args->n_fmly) { 222 case LM_INET: 223 knc.knc_protofmly = NC_INET; 224 break; 225 case LM_INET6: 226 knc.knc_protofmly = NC_INET6; 227 break; 228 case LM_LOOPBACK: 229 knc.knc_protofmly = NC_LOOPBACK; 230 /* Override what we set above. */ 231 knc.knc_proto = NC_NOPROTO; 232 break; 233 default: 234 NLM_ERR("nlm_build_knetconfig: Unknown " 235 "lm_fmly=0x%x\n", args->n_fmly); 236 return (EINVAL); 237 } 238 239 knc.knc_rdev = args->n_rdev; 240 netid = nlm_knc_to_netid(&knc); 241 if (!netid) 242 return (EINVAL); 243 244 /* 245 * Setup service on the passed transport. 246 * NB: must releasef(fp) after this. 247 */ 248 if ((fp = getf(args->fd)) == NULL) 249 return (EBADF); 250 251 mutex_enter(&g->lock); 252 /* 253 * Don't try to start while still shutting down, 254 * or lots of things will fail... 255 */ 256 if (g->run_status == NLM_ST_STOPPING) { 257 err = EAGAIN; 258 goto out; 259 } 260 261 /* 262 * There is no separate "initialize" sub-call for nfssys, 263 * and we want to do some one-time work when the first 264 * binding comes in from lockd. 265 */ 266 if (g->run_status == NLM_ST_DOWN) { 267 g->run_status = NLM_ST_STARTING; 268 g->lockd_pid = curproc->p_pid; 269 270 /* Save the options. */ 271 g->cn_idle_tmo = args->timout; 272 g->grace_period = args->grace; 273 g->retrans_tmo = args->retransmittimeout; 274 275 /* See nfs_sys.c (not yet per-zone) */ 276 if (INGLOBALZONE(curproc)) { 277 rfs4_grace_period = args->grace; 278 rfs4_lease_time = args->grace; 279 } 280 281 mutex_exit(&g->lock); 282 err = nlm_svc_starting(g, fp, netid, &knc); 283 mutex_enter(&g->lock); 284 } else { 285 /* 286 * If KLM is not started and the very first endpoint lockd 287 * tries to add is not a loopback device, report an error. 288 */ 289 if (g->run_status != NLM_ST_UP) { 290 err = ENOTACTIVE; 291 goto out; 292 } 293 if (g->lockd_pid != curproc->p_pid) { 294 /* Check if caller has the same PID lockd does */ 295 err = EPERM; 296 goto out; 297 } 298 299 err = nlm_svc_add_ep(fp, netid, &knc); 300 } 301 302 out: 303 mutex_exit(&g->lock); 304 if (fp != NULL) 305 releasef(args->fd); 306 307 return (err); 308 } 309 310 /* 311 * klm system calls. Kill the lock manager. 312 * Called by nfssys() KILL_LOCKMGR, 313 * liblm:lm_shutdown() <- unused? 314 */ 315 int 316 lm_shutdown(void) 317 { 318 struct nlm_globals *g; 319 proc_t *p; 320 pid_t pid; 321 322 /* Get our "globals" */ 323 g = zone_getspecific(nlm_zone_key, curzone); 324 325 mutex_enter(&g->lock); 326 if (g->run_status != NLM_ST_UP) { 327 mutex_exit(&g->lock); 328 return (EBUSY); 329 } 330 331 g->run_status = NLM_ST_STOPPING; 332 pid = g->lockd_pid; 333 mutex_exit(&g->lock); 334 nlm_svc_stopping(g); 335 336 mutex_enter(&pidlock); 337 p = prfind(pid); 338 if (p != NULL) 339 psignal(p, SIGTERM); 340 341 mutex_exit(&pidlock); 342 return (0); 343 } 344 345 /* 346 * Cleanup remote locks on FS un-export. 347 * 348 * NOTE: called from nfs_export.c:unexport() 349 * right before the share is going to 350 * be unexported. 351 */ 352 void 353 lm_unexport(struct exportinfo *exi) 354 { 355 nlm_unexport(exi); 356 } 357 358 /* 359 * CPR suspend/resume hooks. 360 * See:cpr_suspend, cpr_resume 361 * 362 * Before suspend, get current state from "statd" on 363 * all remote systems for which we have locks. 364 * 365 * After resume, check with those systems again, 366 * and either reclaim locks, or do SIGLOST. 367 */ 368 void 369 lm_cprsuspend(void) 370 { 371 nlm_cprsuspend(); 372 } 373 374 void 375 lm_cprresume(void) 376 { 377 nlm_cprresume(); 378 } 379 380 /* 381 * Add the nlm_id bits to the sysid (by ref). 382 */ 383 void 384 lm_set_nlmid_flk(int *new_sysid) 385 { 386 if (lm_global_nlmid != 0) 387 *new_sysid |= (lm_global_nlmid << BITS_IN_SYSID); 388 } 389 390 /* 391 * It seems that closed source klmmod used 392 * this function to release knetconfig stored 393 * in mntinfo structure (see mntinfo's mi_klmconfig 394 * field). 395 * We store knetconfigs differently, thus we don't 396 * need this function. 397 */ 398 void 399 lm_free_config(struct knetconfig *knc) 400 { 401 _NOTE(ARGUNUSED(knc)); 402 } 403 404 /* 405 * Called by NFS4 delegation code to check if there are any 406 * NFSv2/v3 locks for the file, so it should not delegate. 407 * 408 * NOTE: called from NFSv4 code 409 * (see nfs4_srv_deleg.c:rfs4_bgrant_delegation()) 410 */ 411 int 412 lm_vp_active(const vnode_t *vp) 413 { 414 return (nlm_vp_active(vp)); 415 } 416 417 /* 418 * Find or create a "sysid" for given knc+addr. 419 * name is optional. Sets nc_changed if the 420 * found knc_proto is different from passed. 421 * Increments the reference count. 422 * 423 * Called internally, and in nfs4_find_sysid() 424 */ 425 struct lm_sysid * 426 lm_get_sysid(struct knetconfig *knc, struct netbuf *addr, 427 char *name, bool_t *nc_changed) 428 { 429 struct nlm_globals *g; 430 const char *netid; 431 struct nlm_host *hostp; 432 433 _NOTE(ARGUNUSED(nc_changed)); 434 netid = nlm_knc_to_netid(knc); 435 if (netid == NULL) 436 return (NULL); 437 438 g = zone_getspecific(nlm_zone_key, curzone); 439 440 hostp = nlm_host_findcreate(g, name, netid, addr); 441 if (hostp == NULL) 442 return (NULL); 443 444 return ((struct lm_sysid *)hostp); 445 } 446 447 /* 448 * Release a reference on a "sysid". 449 */ 450 void 451 lm_rel_sysid(struct lm_sysid *sysid) 452 { 453 struct nlm_globals *g; 454 455 g = zone_getspecific(nlm_zone_key, curzone); 456 nlm_host_release(g, (struct nlm_host *)sysid); 457 } 458 459 /* 460 * Alloc/free a sysid_t (a unique number between 461 * LM_SYSID and LM_SYSID_MAX). 462 * 463 * Used by NFSv4 rfs4_op_lockt and smbsrv/smb_fsop_frlock, 464 * both to represent non-local locks outside of klm. 465 * 466 * NOTE: called from NFSv4 and SMBFS to allocate unique 467 * sysid. 468 */ 469 sysid_t 470 lm_alloc_sysidt(void) 471 { 472 return (nlm_sysid_alloc()); 473 } 474 475 void 476 lm_free_sysidt(sysid_t sysid) 477 { 478 nlm_sysid_free(sysid); 479 } 480 481 /* Access private member lms->sysid */ 482 sysid_t 483 lm_sysidt(struct lm_sysid *lms) 484 { 485 return (((struct nlm_host *)lms)->nh_sysid); 486 } 487 488 /* 489 * Called by nfs_frlock to check lock constraints. 490 * Return non-zero if the lock request is "safe", i.e. 491 * the range is not mapped, not MANDLOCK, etc. 492 * 493 * NOTE: callde from NFSv3/NFSv2 frlock() functions to 494 * determine whether it's safe to add new lock. 495 */ 496 int 497 lm_safelock(vnode_t *vp, const struct flock64 *fl, cred_t *cr) 498 { 499 return (nlm_safelock(vp, fl, cr)); 500 } 501 502 /* 503 * Called by nfs_lockcompletion to check whether it's "safe" 504 * to map the file (and cache it's data). Walks the list of 505 * file locks looking for any that are not "whole file". 506 * 507 * NOTE: called from nfs_client.c:nfs_lockcompletion() 508 */ 509 int 510 lm_safemap(const vnode_t *vp) 511 { 512 return (nlm_safemap(vp)); 513 } 514 515 /* 516 * Called by nfs_map() for the MANDLOCK case. 517 * Return non-zero if the file has any locks with a 518 * blocked request (sleep). 519 * 520 * NOTE: called from NFSv3/NFSv2 map() functions in 521 * order to determine whether it's safe to add new 522 * mapping. 523 */ 524 int 525 lm_has_sleep(const vnode_t *vp) 526 { 527 return (nlm_has_sleep(vp)); 528 } 529 530 /* 531 * **************************************************************** 532 * Stuff needed by klmops? 533 */ 534