1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2008 Isilon Inc http://www.isilon.com/ 5 * Authors: Doug Rabson <dfr@rabson.org> 6 * Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org> 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #include <sys/cdefs.h> 31 #include <sys/param.h> 32 #include <sys/fcntl.h> 33 #include <sys/jail.h> 34 #include <sys/kernel.h> 35 #include <sys/limits.h> 36 #include <sys/lock.h> 37 #include <sys/lockf.h> 38 #include <sys/malloc.h> 39 #include <sys/mbuf.h> 40 #include <sys/mount.h> 41 #include <sys/mutex.h> 42 #include <sys/proc.h> 43 #include <sys/socket.h> 44 #include <sys/syslog.h> 45 #include <sys/systm.h> 46 #include <sys/unistd.h> 47 #include <sys/vnode.h> 48 49 #include <nfs/nfsproto.h> 50 #include <nfsclient/nfs.h> 51 #include <nfsclient/nfsmount.h> 52 53 #include <nlm/nlm_prot.h> 54 #include <nlm/nlm.h> 55 56 /* 57 * We need to keep track of the svid values used for F_FLOCK locks. 58 */ 59 struct nlm_file_svid { 60 int ns_refs; /* thread count + 1 if active */ 61 int ns_svid; /* on-the-wire SVID for this file */ 62 struct ucred *ns_ucred; /* creds to use for lock recovery */ 63 void *ns_id; /* local struct file pointer */ 64 bool_t ns_active; /* TRUE if we own a lock */ 65 LIST_ENTRY(nlm_file_svid) ns_link; 66 }; 67 LIST_HEAD(nlm_file_svid_list, nlm_file_svid); 68 69 #define NLM_SVID_HASH_SIZE 256 70 struct nlm_file_svid_list nlm_file_svids[NLM_SVID_HASH_SIZE]; 71 72 struct mtx nlm_svid_lock; 73 static struct unrhdr *nlm_svid_allocator; 74 static volatile u_int nlm_xid = 1; 75 76 static int nlm_setlock(struct nlm_host *host, struct rpc_callextra *ext, 77 rpcvers_t vers, struct timeval *timo, int retries, 78 struct vnode *vp, int op, struct flock *fl, int flags, 79 int svid, size_t fhlen, void *fh, off_t size, bool_t reclaim); 80 static int nlm_clearlock(struct nlm_host *host, struct rpc_callextra *ext, 81 rpcvers_t vers, struct timeval *timo, int retries, 82 struct vnode *vp, int op, struct flock *fl, int flags, 83 int svid, size_t fhlen, void *fh, off_t size); 84 static int nlm_getlock(struct nlm_host *host, struct rpc_callextra *ext, 85 rpcvers_t vers, struct timeval *timo, int retries, 86 struct vnode *vp, int op, struct flock *fl, int flags, 87 int svid, size_t fhlen, void *fh, off_t size); 88 static int nlm_map_status(nlm4_stats stat); 89 static struct nlm_file_svid *nlm_find_svid(void *id); 90 static void nlm_free_svid(struct nlm_file_svid *nf); 91 static int nlm_init_lock(struct flock *fl, int flags, int svid, 92 rpcvers_t vers, size_t fhlen, void *fh, off_t size, 93 struct nlm4_lock *lock, char oh_space[32]); 94 95 static void 96 nlm_client_init(void *dummy) 97 { 98 int i; 99 100 mtx_init(&nlm_svid_lock, "NLM svid lock", NULL, MTX_DEF); 101 /* pid_max cannot be greater than PID_MAX */ 102 nlm_svid_allocator = new_unrhdr(PID_MAX + 2, INT_MAX, &nlm_svid_lock); 103 for (i = 0; i < NLM_SVID_HASH_SIZE; i++) 104 LIST_INIT(&nlm_file_svids[i]); 105 } 106 SYSINIT(nlm_client_init, SI_SUB_LOCK, SI_ORDER_FIRST, nlm_client_init, NULL); 107 108 static int 109 nlm_msg(struct thread *td, const char *server, const char *msg, int error) 110 { 111 struct proc *p; 112 113 p = td ? td->td_proc : NULL; 114 if (error) { 115 tprintf(p, LOG_INFO, "nfs server %s: %s, error %d\n", server, 116 msg, error); 117 } else { 118 tprintf(p, LOG_INFO, "nfs server %s: %s\n", server, msg); 119 } 120 return (0); 121 } 122 123 struct nlm_feedback_arg { 124 bool_t nf_printed; 125 struct nfsmount *nf_nmp; 126 }; 127 128 static void 129 nlm_down(struct nlm_feedback_arg *nf, struct thread *td, 130 const char *msg, int error) 131 { 132 struct nfsmount *nmp = nf->nf_nmp; 133 134 if (nmp == NULL) 135 return; 136 mtx_lock(&nmp->nm_mtx); 137 if (!(nmp->nm_state & NFSSTA_LOCKTIMEO)) { 138 nmp->nm_state |= NFSSTA_LOCKTIMEO; 139 mtx_unlock(&nmp->nm_mtx); 140 vfs_event_signal(&nmp->nm_mountp->mnt_stat.f_fsid, 141 VQ_NOTRESPLOCK, 0); 142 } else { 143 mtx_unlock(&nmp->nm_mtx); 144 } 145 146 nf->nf_printed = TRUE; 147 nlm_msg(td, nmp->nm_mountp->mnt_stat.f_mntfromname, msg, error); 148 } 149 150 static void 151 nlm_up(struct nlm_feedback_arg *nf, struct thread *td, 152 const char *msg) 153 { 154 struct nfsmount *nmp = nf->nf_nmp; 155 156 if (!nf->nf_printed) 157 return; 158 159 nlm_msg(td, nmp->nm_mountp->mnt_stat.f_mntfromname, msg, 0); 160 161 mtx_lock(&nmp->nm_mtx); 162 if (nmp->nm_state & NFSSTA_LOCKTIMEO) { 163 nmp->nm_state &= ~NFSSTA_LOCKTIMEO; 164 mtx_unlock(&nmp->nm_mtx); 165 vfs_event_signal(&nmp->nm_mountp->mnt_stat.f_fsid, 166 VQ_NOTRESPLOCK, 1); 167 } else { 168 mtx_unlock(&nmp->nm_mtx); 169 } 170 } 171 172 static void 173 nlm_feedback(int type, int proc, void *arg) 174 { 175 struct thread *td = curthread; 176 struct nlm_feedback_arg *nf = (struct nlm_feedback_arg *) arg; 177 178 switch (type) { 179 case FEEDBACK_REXMIT2: 180 case FEEDBACK_RECONNECT: 181 nlm_down(nf, td, "lockd not responding", 0); 182 break; 183 184 case FEEDBACK_OK: 185 nlm_up(nf, td, "lockd is alive again"); 186 break; 187 } 188 } 189 190 /* 191 * nlm_advlock -- 192 * NFS advisory byte-level locks. 193 */ 194 static int 195 nlm_advlock_internal(struct vnode *vp, void *id, int op, struct flock *fl, 196 int flags, bool_t reclaim, bool_t unlock_vp) 197 { 198 struct thread *td = curthread; 199 struct nfsmount *nmp; 200 off_t size; 201 size_t fhlen; 202 union nfsfh fh; 203 struct sockaddr *sa; 204 struct sockaddr_storage ss; 205 char *servername; 206 struct timeval timo; 207 int retries; 208 rpcvers_t vers; 209 struct nlm_host *host; 210 struct rpc_callextra ext; 211 struct nlm_feedback_arg nf; 212 AUTH *auth; 213 struct ucred *cred, *cred1; 214 struct nlm_file_svid *ns; 215 int svid; 216 int error; 217 int is_v3; 218 219 ASSERT_VOP_LOCKED(vp, "nlm_advlock_1"); 220 221 servername = malloc(MNAMELEN, M_TEMP, M_WAITOK); /* XXXKIB vp locked */ 222 nmp = VFSTONFS(vp->v_mount); 223 /* 224 * Push any pending writes to the server and flush our cache 225 * so that if we are contending with another machine for a 226 * file, we get whatever they wrote and vice-versa. 227 */ 228 if (op == F_SETLK || op == F_UNLCK) 229 nmp->nm_vinvalbuf(vp, V_SAVE, td, 1); 230 231 strcpy(servername, nmp->nm_hostname); 232 nmp->nm_getinfo(vp, fh.fh_bytes, &fhlen, &ss, &is_v3, &size, &timo); 233 sa = (struct sockaddr *) &ss; 234 if (is_v3 != 0) 235 vers = NLM_VERS4; 236 else 237 vers = NLM_VERS; 238 239 if (nmp->nm_flag & NFSMNT_SOFT) 240 retries = nmp->nm_retry; 241 else 242 retries = INT_MAX; 243 244 /* 245 * We need to switch to mount-point creds so that we can send 246 * packets from a privileged port. Reference mnt_cred and 247 * switch to them before unlocking the vnode, since mount 248 * point could be unmounted right after unlock. 249 */ 250 cred = td->td_ucred; 251 td->td_ucred = vp->v_mount->mnt_cred; 252 crhold(td->td_ucred); 253 if (unlock_vp) 254 VOP_UNLOCK(vp); 255 256 host = nlm_find_host_by_name(servername, sa, vers); 257 auth = authunix_create(cred); 258 memset(&ext, 0, sizeof(ext)); 259 260 nf.nf_printed = FALSE; 261 nf.nf_nmp = nmp; 262 ext.rc_auth = auth; 263 264 ext.rc_feedback = nlm_feedback; 265 ext.rc_feedback_arg = &nf; 266 ext.rc_timers = NULL; 267 268 ns = NULL; 269 if (flags & F_FLOCK) { 270 ns = nlm_find_svid(id); 271 KASSERT(fl->l_start == 0 && fl->l_len == 0, 272 ("F_FLOCK lock requests must be whole-file locks")); 273 if (!ns->ns_ucred) { 274 /* 275 * Remember the creds used for locking in case 276 * we need to recover the lock later. 277 */ 278 ns->ns_ucred = crdup(cred); 279 } 280 svid = ns->ns_svid; 281 } else if (flags & F_REMOTE) { 282 /* 283 * If we are recovering after a server restart or 284 * trashing locks on a force unmount, use the same 285 * svid as last time. 286 */ 287 svid = fl->l_pid; 288 } else { 289 svid = ((struct proc *) id)->p_pid; 290 } 291 292 switch(op) { 293 case F_SETLK: 294 if ((flags & (F_FLOCK|F_WAIT)) == (F_FLOCK|F_WAIT) 295 && fl->l_type == F_WRLCK) { 296 /* 297 * The semantics for flock(2) require that any 298 * shared lock on the file must be released 299 * before an exclusive lock is granted. The 300 * local locking code interprets this by 301 * unlocking the file before sleeping on a 302 * blocked exclusive lock request. We 303 * approximate this by first attempting 304 * non-blocking and if that fails, we unlock 305 * the file and block. 306 */ 307 error = nlm_setlock(host, &ext, vers, &timo, retries, 308 vp, F_SETLK, fl, flags & ~F_WAIT, 309 svid, fhlen, &fh.fh_bytes, size, reclaim); 310 if (error == EAGAIN) { 311 fl->l_type = F_UNLCK; 312 error = nlm_clearlock(host, &ext, vers, &timo, 313 retries, vp, F_UNLCK, fl, flags, 314 svid, fhlen, &fh.fh_bytes, size); 315 fl->l_type = F_WRLCK; 316 if (!error) { 317 mtx_lock(&nlm_svid_lock); 318 if (ns->ns_active) { 319 ns->ns_refs--; 320 ns->ns_active = FALSE; 321 } 322 mtx_unlock(&nlm_svid_lock); 323 flags |= F_WAIT; 324 error = nlm_setlock(host, &ext, vers, 325 &timo, retries, vp, F_SETLK, fl, 326 flags, svid, fhlen, &fh.fh_bytes, 327 size, reclaim); 328 } 329 } 330 } else { 331 error = nlm_setlock(host, &ext, vers, &timo, retries, 332 vp, op, fl, flags, svid, fhlen, &fh.fh_bytes, 333 size, reclaim); 334 } 335 if (!error && ns) { 336 mtx_lock(&nlm_svid_lock); 337 if (!ns->ns_active) { 338 /* 339 * Add one to the reference count to 340 * hold onto the SVID for the lifetime 341 * of the lock. Note that since 342 * F_FLOCK only supports whole-file 343 * locks, there can only be one active 344 * lock for this SVID. 345 */ 346 ns->ns_refs++; 347 ns->ns_active = TRUE; 348 } 349 mtx_unlock(&nlm_svid_lock); 350 } 351 break; 352 353 case F_UNLCK: 354 error = nlm_clearlock(host, &ext, vers, &timo, retries, 355 vp, op, fl, flags, svid, fhlen, &fh.fh_bytes, size); 356 if (!error && ns) { 357 mtx_lock(&nlm_svid_lock); 358 if (ns->ns_active) { 359 ns->ns_refs--; 360 ns->ns_active = FALSE; 361 } 362 mtx_unlock(&nlm_svid_lock); 363 } 364 break; 365 366 case F_GETLK: 367 error = nlm_getlock(host, &ext, vers, &timo, retries, 368 vp, op, fl, flags, svid, fhlen, &fh.fh_bytes, size); 369 break; 370 371 default: 372 error = EINVAL; 373 break; 374 } 375 376 if (ns) 377 nlm_free_svid(ns); 378 379 cred1 = td->td_ucred; 380 td->td_ucred = cred; 381 crfree(cred1); 382 AUTH_DESTROY(auth); 383 384 nlm_host_release(host); 385 free(servername, M_TEMP); 386 return (error); 387 } 388 389 int 390 nlm_advlock(struct vop_advlock_args *ap) 391 { 392 393 return (nlm_advlock_internal(ap->a_vp, ap->a_id, ap->a_op, ap->a_fl, 394 ap->a_flags, FALSE, TRUE)); 395 } 396 397 /* 398 * Set the creds of td to the creds of the given lock's owner. The new 399 * creds reference count will be incremented via crhold. The caller is 400 * responsible for calling crfree and restoring td's original creds. 401 */ 402 static void 403 nlm_set_creds_for_lock(struct thread *td, struct flock *fl) 404 { 405 int i; 406 struct nlm_file_svid *ns; 407 struct proc *p; 408 struct ucred *cred; 409 410 cred = NULL; 411 if (fl->l_pid > PID_MAX) { 412 /* 413 * If this was originally a F_FLOCK-style lock, we 414 * recorded the creds used when it was originally 415 * locked in the nlm_file_svid structure. 416 */ 417 mtx_lock(&nlm_svid_lock); 418 for (i = 0; i < NLM_SVID_HASH_SIZE; i++) { 419 for (ns = LIST_FIRST(&nlm_file_svids[i]); ns; 420 ns = LIST_NEXT(ns, ns_link)) { 421 if (ns->ns_svid == fl->l_pid) { 422 cred = crhold(ns->ns_ucred); 423 break; 424 } 425 } 426 } 427 mtx_unlock(&nlm_svid_lock); 428 } else { 429 /* 430 * This lock is owned by a process. Get a reference to 431 * the process creds. 432 */ 433 p = pfind(fl->l_pid); 434 if (p) { 435 cred = crhold(p->p_ucred); 436 PROC_UNLOCK(p); 437 } 438 } 439 440 /* 441 * If we can't find a cred, fall back on the recovery 442 * thread's cred. 443 */ 444 if (!cred) { 445 cred = crhold(td->td_ucred); 446 } 447 448 td->td_ucred = cred; 449 } 450 451 static int 452 nlm_reclaim_free_lock(struct vnode *vp, struct flock *fl, void *arg) 453 { 454 struct flock newfl; 455 struct thread *td = curthread; 456 struct ucred *oldcred; 457 int error; 458 459 newfl = *fl; 460 newfl.l_type = F_UNLCK; 461 462 oldcred = td->td_ucred; 463 nlm_set_creds_for_lock(td, &newfl); 464 465 error = nlm_advlock_internal(vp, NULL, F_UNLCK, &newfl, F_REMOTE, 466 FALSE, FALSE); 467 468 crfree(td->td_ucred); 469 td->td_ucred = oldcred; 470 471 return (error); 472 } 473 474 int 475 nlm_reclaim(struct vop_reclaim_args *ap) 476 { 477 478 nlm_cancel_wait(ap->a_vp); 479 lf_iteratelocks_vnode(ap->a_vp, nlm_reclaim_free_lock, NULL); 480 return (0); 481 } 482 483 struct nlm_recovery_context { 484 struct nlm_host *nr_host; /* host we are recovering */ 485 int nr_state; /* remote NSM state for recovery */ 486 }; 487 488 static int 489 nlm_client_recover_lock(struct vnode *vp, struct flock *fl, void *arg) 490 { 491 struct nlm_recovery_context *nr = (struct nlm_recovery_context *) arg; 492 struct thread *td = curthread; 493 struct ucred *oldcred; 494 int state, error; 495 496 /* 497 * If the remote NSM state changes during recovery, the host 498 * must have rebooted a second time. In that case, we must 499 * restart the recovery. 500 */ 501 state = nlm_host_get_state(nr->nr_host); 502 if (nr->nr_state != state) 503 return (ERESTART); 504 505 error = vn_lock(vp, LK_SHARED); 506 if (error) 507 return (error); 508 509 oldcred = td->td_ucred; 510 nlm_set_creds_for_lock(td, fl); 511 512 error = nlm_advlock_internal(vp, NULL, F_SETLK, fl, F_REMOTE, 513 TRUE, TRUE); 514 515 crfree(td->td_ucred); 516 td->td_ucred = oldcred; 517 518 return (error); 519 } 520 521 void 522 nlm_client_recovery(struct nlm_host *host) 523 { 524 struct nlm_recovery_context nr; 525 int sysid, error; 526 527 sysid = NLM_SYSID_CLIENT | nlm_host_get_sysid(host); 528 do { 529 nr.nr_host = host; 530 nr.nr_state = nlm_host_get_state(host); 531 error = lf_iteratelocks_sysid(sysid, 532 nlm_client_recover_lock, &nr); 533 } while (error == ERESTART); 534 } 535 536 static void 537 nlm_convert_to_nlm_lock(struct nlm_lock *dst, struct nlm4_lock *src) 538 { 539 540 dst->caller_name = src->caller_name; 541 dst->fh = src->fh; 542 dst->oh = src->oh; 543 dst->svid = src->svid; 544 dst->l_offset = src->l_offset; 545 dst->l_len = src->l_len; 546 } 547 548 static void 549 nlm_convert_to_nlm4_holder(struct nlm4_holder *dst, struct nlm_holder *src) 550 { 551 552 dst->exclusive = src->exclusive; 553 dst->svid = src->svid; 554 dst->oh = src->oh; 555 dst->l_offset = src->l_offset; 556 dst->l_len = src->l_len; 557 } 558 559 static void 560 nlm_convert_to_nlm4_res(struct nlm4_res *dst, struct nlm_res *src) 561 { 562 dst->cookie = src->cookie; 563 dst->stat.stat = (enum nlm4_stats) src->stat.stat; 564 } 565 566 static enum clnt_stat 567 nlm_test_rpc(rpcvers_t vers, nlm4_testargs *args, nlm4_testres *res, CLIENT *client, 568 struct rpc_callextra *ext, struct timeval timo) 569 { 570 if (vers == NLM_VERS4) { 571 return nlm4_test_4(args, res, client, ext, timo); 572 } else { 573 nlm_testargs args1; 574 nlm_testres res1; 575 enum clnt_stat stat; 576 577 args1.cookie = args->cookie; 578 args1.exclusive = args->exclusive; 579 nlm_convert_to_nlm_lock(&args1.alock, &args->alock); 580 memset(&res1, 0, sizeof(res1)); 581 582 stat = nlm_test_1(&args1, &res1, client, ext, timo); 583 584 if (stat == RPC_SUCCESS) { 585 res->cookie = res1.cookie; 586 res->stat.stat = (enum nlm4_stats) res1.stat.stat; 587 if (res1.stat.stat == nlm_denied) 588 nlm_convert_to_nlm4_holder( 589 &res->stat.nlm4_testrply_u.holder, 590 &res1.stat.nlm_testrply_u.holder); 591 } 592 593 return (stat); 594 } 595 } 596 597 static enum clnt_stat 598 nlm_lock_rpc(rpcvers_t vers, nlm4_lockargs *args, nlm4_res *res, CLIENT *client, 599 struct rpc_callextra *ext, struct timeval timo) 600 { 601 if (vers == NLM_VERS4) { 602 return nlm4_lock_4(args, res, client, ext, timo); 603 } else { 604 nlm_lockargs args1; 605 nlm_res res1; 606 enum clnt_stat stat; 607 608 args1.cookie = args->cookie; 609 args1.block = args->block; 610 args1.exclusive = args->exclusive; 611 nlm_convert_to_nlm_lock(&args1.alock, &args->alock); 612 args1.reclaim = args->reclaim; 613 args1.state = args->state; 614 memset(&res1, 0, sizeof(res1)); 615 616 stat = nlm_lock_1(&args1, &res1, client, ext, timo); 617 618 if (stat == RPC_SUCCESS) { 619 nlm_convert_to_nlm4_res(res, &res1); 620 } 621 622 return (stat); 623 } 624 } 625 626 static enum clnt_stat 627 nlm_cancel_rpc(rpcvers_t vers, nlm4_cancargs *args, nlm4_res *res, CLIENT *client, 628 struct rpc_callextra *ext, struct timeval timo) 629 { 630 if (vers == NLM_VERS4) { 631 return nlm4_cancel_4(args, res, client, ext, timo); 632 } else { 633 nlm_cancargs args1; 634 nlm_res res1; 635 enum clnt_stat stat; 636 637 args1.cookie = args->cookie; 638 args1.block = args->block; 639 args1.exclusive = args->exclusive; 640 nlm_convert_to_nlm_lock(&args1.alock, &args->alock); 641 memset(&res1, 0, sizeof(res1)); 642 643 stat = nlm_cancel_1(&args1, &res1, client, ext, timo); 644 645 if (stat == RPC_SUCCESS) { 646 nlm_convert_to_nlm4_res(res, &res1); 647 } 648 649 return (stat); 650 } 651 } 652 653 static enum clnt_stat 654 nlm_unlock_rpc(rpcvers_t vers, nlm4_unlockargs *args, nlm4_res *res, CLIENT *client, 655 struct rpc_callextra *ext, struct timeval timo) 656 { 657 if (vers == NLM_VERS4) { 658 return nlm4_unlock_4(args, res, client, ext, timo); 659 } else { 660 nlm_unlockargs args1; 661 nlm_res res1; 662 enum clnt_stat stat; 663 664 args1.cookie = args->cookie; 665 nlm_convert_to_nlm_lock(&args1.alock, &args->alock); 666 memset(&res1, 0, sizeof(res1)); 667 668 stat = nlm_unlock_1(&args1, &res1, client, ext, timo); 669 670 if (stat == RPC_SUCCESS) { 671 nlm_convert_to_nlm4_res(res, &res1); 672 } 673 674 return (stat); 675 } 676 } 677 678 /* 679 * Called after a lock request (set or clear) succeeded. We record the 680 * details in the local lock manager. Note that since the remote 681 * server has granted the lock, we can be sure that it doesn't 682 * conflict with any other locks we have in the local lock manager. 683 * 684 * Since it is possible that host may also make NLM client requests to 685 * our NLM server, we use a different sysid value to record our own 686 * client locks. 687 * 688 * Note that since it is possible for us to receive replies from the 689 * server in a different order than the locks were granted (e.g. if 690 * many local threads are contending for the same lock), we must use a 691 * blocking operation when registering with the local lock manager. 692 * We expect that any actual wait will be rare and short hence we 693 * ignore signals for this. 694 */ 695 static void 696 nlm_record_lock(struct vnode *vp, int op, struct flock *fl, 697 int svid, int sysid, off_t size) 698 { 699 struct vop_advlockasync_args a; 700 struct flock newfl; 701 struct proc *p; 702 int error, stops_deferred; 703 704 a.a_vp = vp; 705 a.a_id = NULL; 706 a.a_op = op; 707 a.a_fl = &newfl; 708 a.a_flags = F_REMOTE|F_WAIT|F_NOINTR; 709 a.a_task = NULL; 710 a.a_cookiep = NULL; 711 newfl.l_start = fl->l_start; 712 newfl.l_len = fl->l_len; 713 newfl.l_type = fl->l_type; 714 newfl.l_whence = fl->l_whence; 715 newfl.l_pid = svid; 716 newfl.l_sysid = NLM_SYSID_CLIENT | sysid; 717 718 for (;;) { 719 error = lf_advlockasync(&a, &vp->v_lockf, size); 720 if (error == EDEADLK) { 721 /* 722 * Locks are associated with the processes and 723 * not with threads. Suppose we have two 724 * threads A1 A2 in one process, A1 locked 725 * file f1, A2 is locking file f2, and A1 is 726 * unlocking f1. Then remote server may 727 * already unlocked f1, while local still not 728 * yet scheduled A1 to make the call to local 729 * advlock manager. The process B owns lock on 730 * f2 and issued the lock on f1. Remote would 731 * grant B the request on f1, but local would 732 * return EDEADLK. 733 */ 734 pause("nlmdlk", 1); 735 p = curproc; 736 stops_deferred = sigdeferstop(SIGDEFERSTOP_OFF); 737 PROC_LOCK(p); 738 thread_suspend_check(0); 739 PROC_UNLOCK(p); 740 sigallowstop(stops_deferred); 741 } else if (error == EINTR) { 742 /* 743 * lf_purgelocks() might wake up the lock 744 * waiter and removed our lock graph edges. 745 * There is no sense in re-trying recording 746 * the lock to the local manager after 747 * reclaim. 748 */ 749 error = 0; 750 break; 751 } else 752 break; 753 } 754 KASSERT(error == 0 || error == ENOENT, 755 ("Failed to register NFS lock locally - error=%d", error)); 756 } 757 758 static int 759 nlm_setlock(struct nlm_host *host, struct rpc_callextra *ext, 760 rpcvers_t vers, struct timeval *timo, int retries, 761 struct vnode *vp, int op, struct flock *fl, int flags, 762 int svid, size_t fhlen, void *fh, off_t size, bool_t reclaim) 763 { 764 struct nlm4_lockargs args; 765 char oh_space[32]; 766 struct nlm4_res res; 767 u_int xid; 768 CLIENT *client; 769 enum clnt_stat stat; 770 int retry, block, exclusive; 771 void *wait_handle = NULL; 772 int error; 773 774 memset(&args, 0, sizeof(args)); 775 memset(&res, 0, sizeof(res)); 776 777 block = (flags & F_WAIT) ? TRUE : FALSE; 778 exclusive = (fl->l_type == F_WRLCK); 779 780 error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size, 781 &args.alock, oh_space); 782 if (error) 783 return (error); 784 args.block = block; 785 args.exclusive = exclusive; 786 args.reclaim = reclaim; 787 args.state = nlm_nsm_state; 788 789 retry = 5*hz; 790 for (;;) { 791 client = nlm_host_get_rpc(host, FALSE); 792 if (!client) 793 return (ENOLCK); /* XXX retry? */ 794 795 if (block) 796 wait_handle = nlm_register_wait_lock(&args.alock, vp); 797 798 xid = atomic_fetchadd_int(&nlm_xid, 1); 799 args.cookie.n_len = sizeof(xid); 800 args.cookie.n_bytes = (char*) &xid; 801 802 stat = nlm_lock_rpc(vers, &args, &res, client, ext, *timo); 803 804 CLNT_RELEASE(client); 805 806 if (stat != RPC_SUCCESS) { 807 if (block) 808 nlm_deregister_wait_lock(wait_handle); 809 if (retries) { 810 retries--; 811 continue; 812 } 813 return (EINVAL); 814 } 815 816 /* 817 * Free res.cookie. 818 */ 819 xdr_free((xdrproc_t) xdr_nlm4_res, &res); 820 821 if (block && res.stat.stat != nlm4_blocked) 822 nlm_deregister_wait_lock(wait_handle); 823 824 if (res.stat.stat == nlm4_denied_grace_period) { 825 /* 826 * The server has recently rebooted and is 827 * giving old clients a change to reclaim 828 * their locks. Wait for a few seconds and try 829 * again. 830 */ 831 error = tsleep(&args, PCATCH, "nlmgrace", retry); 832 if (error && error != EWOULDBLOCK) 833 return (error); 834 retry = 2*retry; 835 if (retry > 30*hz) 836 retry = 30*hz; 837 continue; 838 } 839 840 if (block && res.stat.stat == nlm4_blocked) { 841 /* 842 * The server should call us back with a 843 * granted message when the lock succeeds. In 844 * order to deal with broken servers, lost 845 * granted messages and server reboots, we 846 * will also re-try every few seconds. 847 */ 848 error = nlm_wait_lock(wait_handle, retry); 849 if (error == EWOULDBLOCK) { 850 retry = 2*retry; 851 if (retry > 30*hz) 852 retry = 30*hz; 853 continue; 854 } 855 if (error) { 856 /* 857 * We need to call the server to 858 * cancel our lock request. 859 */ 860 nlm4_cancargs cancel; 861 862 memset(&cancel, 0, sizeof(cancel)); 863 864 xid = atomic_fetchadd_int(&nlm_xid, 1); 865 cancel.cookie.n_len = sizeof(xid); 866 cancel.cookie.n_bytes = (char*) &xid; 867 cancel.block = block; 868 cancel.exclusive = exclusive; 869 cancel.alock = args.alock; 870 871 do { 872 client = nlm_host_get_rpc(host, FALSE); 873 if (!client) 874 /* XXX retry? */ 875 return (ENOLCK); 876 877 stat = nlm_cancel_rpc(vers, &cancel, 878 &res, client, ext, *timo); 879 880 CLNT_RELEASE(client); 881 882 if (stat != RPC_SUCCESS) { 883 /* 884 * We need to cope 885 * with temporary 886 * network partitions 887 * as well as server 888 * reboots. This means 889 * we have to keep 890 * trying to cancel 891 * until the server 892 * wakes up again. 893 */ 894 pause("nlmcancel", 10*hz); 895 } 896 } while (stat != RPC_SUCCESS); 897 898 /* 899 * Free res.cookie. 900 */ 901 xdr_free((xdrproc_t) xdr_nlm4_res, &res); 902 903 switch (res.stat.stat) { 904 case nlm_denied: 905 /* 906 * There was nothing 907 * to cancel. We are 908 * going to go ahead 909 * and assume we got 910 * the lock. 911 */ 912 error = 0; 913 break; 914 915 case nlm4_denied_grace_period: 916 /* 917 * The server has 918 * recently rebooted - 919 * treat this as a 920 * successful 921 * cancellation. 922 */ 923 break; 924 925 case nlm4_granted: 926 /* 927 * We managed to 928 * cancel. 929 */ 930 break; 931 932 default: 933 /* 934 * Broken server 935 * implementation - 936 * can't really do 937 * anything here. 938 */ 939 break; 940 } 941 } 942 } else { 943 error = nlm_map_status(res.stat.stat); 944 } 945 946 if (!error && !reclaim) { 947 nlm_record_lock(vp, op, fl, args.alock.svid, 948 nlm_host_get_sysid(host), size); 949 nlm_host_monitor(host, 0); 950 } 951 952 return (error); 953 } 954 } 955 956 static int 957 nlm_clearlock(struct nlm_host *host, struct rpc_callextra *ext, 958 rpcvers_t vers, struct timeval *timo, int retries, 959 struct vnode *vp, int op, struct flock *fl, int flags, 960 int svid, size_t fhlen, void *fh, off_t size) 961 { 962 struct nlm4_unlockargs args; 963 char oh_space[32]; 964 struct nlm4_res res; 965 u_int xid; 966 CLIENT *client; 967 enum clnt_stat stat; 968 int error; 969 970 memset(&args, 0, sizeof(args)); 971 memset(&res, 0, sizeof(res)); 972 973 error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size, 974 &args.alock, oh_space); 975 if (error) 976 return (error); 977 978 for (;;) { 979 client = nlm_host_get_rpc(host, FALSE); 980 if (!client) 981 return (ENOLCK); /* XXX retry? */ 982 983 xid = atomic_fetchadd_int(&nlm_xid, 1); 984 args.cookie.n_len = sizeof(xid); 985 args.cookie.n_bytes = (char*) &xid; 986 987 stat = nlm_unlock_rpc(vers, &args, &res, client, ext, *timo); 988 989 CLNT_RELEASE(client); 990 991 if (stat != RPC_SUCCESS) { 992 if (retries) { 993 retries--; 994 continue; 995 } 996 return (EINVAL); 997 } 998 999 /* 1000 * Free res.cookie. 1001 */ 1002 xdr_free((xdrproc_t) xdr_nlm4_res, &res); 1003 1004 if (res.stat.stat == nlm4_denied_grace_period) { 1005 /* 1006 * The server has recently rebooted and is 1007 * giving old clients a change to reclaim 1008 * their locks. Wait for a few seconds and try 1009 * again. 1010 */ 1011 error = tsleep(&args, PCATCH, "nlmgrace", 5*hz); 1012 if (error && error != EWOULDBLOCK) 1013 return (error); 1014 continue; 1015 } 1016 1017 /* 1018 * If we are being called via nlm_reclaim (which will 1019 * use the F_REMOTE flag), don't record the lock 1020 * operation in the local lock manager since the vnode 1021 * is going away. 1022 */ 1023 if (!(flags & F_REMOTE)) 1024 nlm_record_lock(vp, op, fl, args.alock.svid, 1025 nlm_host_get_sysid(host), size); 1026 1027 return (0); 1028 } 1029 } 1030 1031 static int 1032 nlm_getlock(struct nlm_host *host, struct rpc_callextra *ext, 1033 rpcvers_t vers, struct timeval *timo, int retries, 1034 struct vnode *vp, int op, struct flock *fl, int flags, 1035 int svid, size_t fhlen, void *fh, off_t size) 1036 { 1037 struct nlm4_testargs args; 1038 char oh_space[32]; 1039 struct nlm4_testres res; 1040 u_int xid; 1041 CLIENT *client; 1042 enum clnt_stat stat; 1043 int exclusive; 1044 int error; 1045 1046 KASSERT(!(flags & F_FLOCK), ("unexpected F_FLOCK for F_GETLK")); 1047 1048 memset(&args, 0, sizeof(args)); 1049 memset(&res, 0, sizeof(res)); 1050 1051 exclusive = (fl->l_type == F_WRLCK); 1052 1053 error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size, 1054 &args.alock, oh_space); 1055 if (error) 1056 return (error); 1057 args.exclusive = exclusive; 1058 1059 for (;;) { 1060 client = nlm_host_get_rpc(host, FALSE); 1061 if (!client) 1062 return (ENOLCK); /* XXX retry? */ 1063 1064 xid = atomic_fetchadd_int(&nlm_xid, 1); 1065 args.cookie.n_len = sizeof(xid); 1066 args.cookie.n_bytes = (char*) &xid; 1067 1068 stat = nlm_test_rpc(vers, &args, &res, client, ext, *timo); 1069 1070 CLNT_RELEASE(client); 1071 1072 if (stat != RPC_SUCCESS) { 1073 if (retries) { 1074 retries--; 1075 continue; 1076 } 1077 return (EINVAL); 1078 } 1079 1080 if (res.stat.stat == nlm4_denied_grace_period) { 1081 /* 1082 * The server has recently rebooted and is 1083 * giving old clients a change to reclaim 1084 * their locks. Wait for a few seconds and try 1085 * again. 1086 */ 1087 xdr_free((xdrproc_t) xdr_nlm4_testres, &res); 1088 error = tsleep(&args, PCATCH, "nlmgrace", 5*hz); 1089 if (error && error != EWOULDBLOCK) 1090 return (error); 1091 continue; 1092 } 1093 1094 if (res.stat.stat == nlm4_denied) { 1095 struct nlm4_holder *h = 1096 &res.stat.nlm4_testrply_u.holder; 1097 fl->l_start = h->l_offset; 1098 fl->l_len = h->l_len; 1099 fl->l_pid = h->svid; 1100 if (h->exclusive) 1101 fl->l_type = F_WRLCK; 1102 else 1103 fl->l_type = F_RDLCK; 1104 fl->l_whence = SEEK_SET; 1105 fl->l_sysid = 0; 1106 } else { 1107 fl->l_type = F_UNLCK; 1108 } 1109 1110 xdr_free((xdrproc_t) xdr_nlm4_testres, &res); 1111 1112 return (0); 1113 } 1114 } 1115 1116 static int 1117 nlm_map_status(nlm4_stats stat) 1118 { 1119 switch (stat) { 1120 case nlm4_granted: 1121 return (0); 1122 1123 case nlm4_denied: 1124 return (EAGAIN); 1125 1126 case nlm4_denied_nolocks: 1127 return (ENOLCK); 1128 1129 case nlm4_deadlck: 1130 return (EDEADLK); 1131 1132 case nlm4_rofs: 1133 return (EROFS); 1134 1135 case nlm4_stale_fh: 1136 return (ESTALE); 1137 1138 case nlm4_fbig: 1139 return (EFBIG); 1140 1141 case nlm4_failed: 1142 return (EACCES); 1143 1144 default: 1145 return (EINVAL); 1146 } 1147 } 1148 1149 static struct nlm_file_svid * 1150 nlm_find_svid(void *id) 1151 { 1152 struct nlm_file_svid *ns, *newns; 1153 int h; 1154 1155 h = (((uintptr_t) id) >> 7) % NLM_SVID_HASH_SIZE; 1156 1157 mtx_lock(&nlm_svid_lock); 1158 LIST_FOREACH(ns, &nlm_file_svids[h], ns_link) { 1159 if (ns->ns_id == id) { 1160 ns->ns_refs++; 1161 break; 1162 } 1163 } 1164 mtx_unlock(&nlm_svid_lock); 1165 if (!ns) { 1166 int svid = alloc_unr(nlm_svid_allocator); 1167 newns = malloc(sizeof(struct nlm_file_svid), M_NLM, 1168 M_WAITOK); 1169 newns->ns_refs = 1; 1170 newns->ns_id = id; 1171 newns->ns_svid = svid; 1172 newns->ns_ucred = NULL; 1173 newns->ns_active = FALSE; 1174 1175 /* 1176 * We need to check for a race with some other 1177 * thread allocating a svid for this file. 1178 */ 1179 mtx_lock(&nlm_svid_lock); 1180 LIST_FOREACH(ns, &nlm_file_svids[h], ns_link) { 1181 if (ns->ns_id == id) { 1182 ns->ns_refs++; 1183 break; 1184 } 1185 } 1186 if (ns) { 1187 mtx_unlock(&nlm_svid_lock); 1188 free_unr(nlm_svid_allocator, newns->ns_svid); 1189 free(newns, M_NLM); 1190 } else { 1191 LIST_INSERT_HEAD(&nlm_file_svids[h], newns, 1192 ns_link); 1193 ns = newns; 1194 mtx_unlock(&nlm_svid_lock); 1195 } 1196 } 1197 1198 return (ns); 1199 } 1200 1201 static void 1202 nlm_free_svid(struct nlm_file_svid *ns) 1203 { 1204 1205 mtx_lock(&nlm_svid_lock); 1206 ns->ns_refs--; 1207 if (!ns->ns_refs) { 1208 KASSERT(!ns->ns_active, ("Freeing active SVID")); 1209 LIST_REMOVE(ns, ns_link); 1210 mtx_unlock(&nlm_svid_lock); 1211 free_unr(nlm_svid_allocator, ns->ns_svid); 1212 if (ns->ns_ucred) 1213 crfree(ns->ns_ucred); 1214 free(ns, M_NLM); 1215 } else { 1216 mtx_unlock(&nlm_svid_lock); 1217 } 1218 } 1219 1220 static int 1221 nlm_init_lock(struct flock *fl, int flags, int svid, 1222 rpcvers_t vers, size_t fhlen, void *fh, off_t size, 1223 struct nlm4_lock *lock, char oh_space[32]) 1224 { 1225 size_t oh_len; 1226 off_t start, len; 1227 1228 if (fl->l_whence == SEEK_END) { 1229 if (size > OFF_MAX 1230 || (fl->l_start > 0 && size > OFF_MAX - fl->l_start)) 1231 return (EOVERFLOW); 1232 start = size + fl->l_start; 1233 } else if (fl->l_whence == SEEK_SET || fl->l_whence == SEEK_CUR) { 1234 start = fl->l_start; 1235 } else { 1236 return (EINVAL); 1237 } 1238 if (start < 0) 1239 return (EINVAL); 1240 if (fl->l_len < 0) { 1241 len = -fl->l_len; 1242 start -= len; 1243 if (start < 0) 1244 return (EINVAL); 1245 } else { 1246 len = fl->l_len; 1247 } 1248 1249 if (vers == NLM_VERS) { 1250 /* 1251 * Enforce range limits on V1 locks 1252 */ 1253 if (start > 0xffffffffLL || len > 0xffffffffLL) 1254 return (EOVERFLOW); 1255 } 1256 1257 snprintf(oh_space, 32, "%d@", svid); 1258 oh_len = strlen(oh_space); 1259 getcredhostname(NULL, oh_space + oh_len, 32 - oh_len); 1260 oh_len = strlen(oh_space); 1261 1262 memset(lock, 0, sizeof(*lock)); 1263 lock->caller_name = prison0.pr_hostname; 1264 lock->fh.n_len = fhlen; 1265 lock->fh.n_bytes = fh; 1266 lock->oh.n_len = oh_len; 1267 lock->oh.n_bytes = oh_space; 1268 lock->svid = svid; 1269 lock->l_offset = start; 1270 lock->l_len = len; 1271 1272 return (0); 1273 } 1274