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