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