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>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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.
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
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
31 #include <sys/param.h>
32 #include <sys/fcntl.h>
34 #include <sys/kernel.h>
35 #include <sys/limits.h>
37 #include <sys/lockf.h>
38 #include <sys/malloc.h>
40 #include <sys/mount.h>
41 #include <sys/mutex.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>
49 #include <nfs/nfsproto.h>
50 #include <nfsclient/nfs.h>
51 #include <nfsclient/nfsmount.h>
53 #include <nlm/nlm_prot.h>
57 * We need to keep track of the svid values used for F_FLOCK locks.
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;
67 LIST_HEAD(nlm_file_svid_list, nlm_file_svid);
69 #define NLM_SVID_HASH_SIZE 256
70 struct nlm_file_svid_list nlm_file_svids[NLM_SVID_HASH_SIZE];
72 struct mtx nlm_svid_lock;
73 static struct unrhdr *nlm_svid_allocator;
74 static volatile u_int nlm_xid = 1;
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]);
96 nlm_client_init(void *dummy)
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]);
106 SYSINIT(nlm_client_init, SI_SUB_LOCK, SI_ORDER_FIRST, nlm_client_init, NULL);
109 nlm_msg(struct thread *td, const char *server, const char *msg, int error)
113 p = td ? td->td_proc : NULL;
115 tprintf(p, LOG_INFO, "nfs server %s: %s, error %d\n", server,
118 tprintf(p, LOG_INFO, "nfs server %s: %s\n", server, msg);
123 struct nlm_feedback_arg {
125 struct nfsmount *nf_nmp;
129 nlm_down(struct nlm_feedback_arg *nf, struct thread *td,
130 const char *msg, int error)
132 struct nfsmount *nmp = nf->nf_nmp;
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,
143 mtx_unlock(&nmp->nm_mtx);
146 nf->nf_printed = TRUE;
147 nlm_msg(td, nmp->nm_mountp->mnt_stat.f_mntfromname, msg, error);
151 nlm_up(struct nlm_feedback_arg *nf, struct thread *td,
154 struct nfsmount *nmp = nf->nf_nmp;
159 nlm_msg(td, nmp->nm_mountp->mnt_stat.f_mntfromname, msg, 0);
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,
168 mtx_unlock(&nmp->nm_mtx);
173 nlm_feedback(int type, int proc, void *arg)
175 struct thread *td = curthread;
176 struct nlm_feedback_arg *nf = (struct nlm_feedback_arg *) arg;
179 case FEEDBACK_REXMIT2:
180 case FEEDBACK_RECONNECT:
181 nlm_down(nf, td, "lockd not responding", 0);
185 nlm_up(nf, td, "lockd is alive again");
192 * NFS advisory byte-level locks.
195 nlm_advlock_internal(struct vnode *vp, void *id, int op, struct flock *fl,
196 int flags, bool_t reclaim, bool_t unlock_vp)
198 struct thread *td = curthread;
199 struct nfsmount *nmp;
204 struct sockaddr_storage ss;
205 char servername[MNAMELEN];
209 struct nlm_host *host;
210 struct rpc_callextra ext;
211 struct nlm_feedback_arg nf;
213 struct ucred *cred, *cred1;
214 struct nlm_file_svid *ns;
219 ASSERT_VOP_LOCKED(vp, "nlm_advlock_1");
221 nmp = VFSTONFS(vp->v_mount);
223 * Push any pending writes to the server and flush our cache
224 * so that if we are contending with another machine for a
225 * file, we get whatever they wrote and vice-versa.
227 if (op == F_SETLK || op == F_UNLCK)
228 nmp->nm_vinvalbuf(vp, V_SAVE, td, 1);
230 strcpy(servername, nmp->nm_hostname);
231 nmp->nm_getinfo(vp, fh.fh_bytes, &fhlen, &ss, &is_v3, &size, &timo);
232 sa = (struct sockaddr *) &ss;
238 if (nmp->nm_flag & NFSMNT_SOFT)
239 retries = nmp->nm_retry;
244 * We need to switch to mount-point creds so that we can send
245 * packets from a privileged port. Reference mnt_cred and
246 * switch to them before unlocking the vnode, since mount
247 * point could be unmounted right after unlock.
250 td->td_ucred = vp->v_mount->mnt_cred;
251 crhold(td->td_ucred);
255 host = nlm_find_host_by_name(servername, sa, vers);
256 auth = authunix_create(cred);
257 memset(&ext, 0, sizeof(ext));
259 nf.nf_printed = FALSE;
263 ext.rc_feedback = nlm_feedback;
264 ext.rc_feedback_arg = &nf;
265 ext.rc_timers = NULL;
268 if (flags & F_FLOCK) {
269 ns = nlm_find_svid(id);
270 KASSERT(fl->l_start == 0 && fl->l_len == 0,
271 ("F_FLOCK lock requests must be whole-file locks"));
274 * Remember the creds used for locking in case
275 * we need to recover the lock later.
277 ns->ns_ucred = crdup(cred);
280 } else if (flags & F_REMOTE) {
282 * If we are recovering after a server restart or
283 * trashing locks on a force unmount, use the same
288 svid = ((struct proc *) id)->p_pid;
293 if ((flags & (F_FLOCK|F_WAIT)) == (F_FLOCK|F_WAIT)
294 && fl->l_type == F_WRLCK) {
296 * The semantics for flock(2) require that any
297 * shared lock on the file must be released
298 * before an exclusive lock is granted. The
299 * local locking code interprets this by
300 * unlocking the file before sleeping on a
301 * blocked exclusive lock request. We
302 * approximate this by first attempting
303 * non-blocking and if that fails, we unlock
304 * the file and block.
306 error = nlm_setlock(host, &ext, vers, &timo, retries,
307 vp, F_SETLK, fl, flags & ~F_WAIT,
308 svid, fhlen, &fh.fh_bytes, size, reclaim);
309 if (error == EAGAIN) {
310 fl->l_type = F_UNLCK;
311 error = nlm_clearlock(host, &ext, vers, &timo,
312 retries, vp, F_UNLCK, fl, flags,
313 svid, fhlen, &fh.fh_bytes, size);
314 fl->l_type = F_WRLCK;
316 mtx_lock(&nlm_svid_lock);
319 ns->ns_active = FALSE;
321 mtx_unlock(&nlm_svid_lock);
323 error = nlm_setlock(host, &ext, vers,
324 &timo, retries, vp, F_SETLK, fl,
325 flags, svid, fhlen, &fh.fh_bytes,
330 error = nlm_setlock(host, &ext, vers, &timo, retries,
331 vp, op, fl, flags, svid, fhlen, &fh.fh_bytes,
335 mtx_lock(&nlm_svid_lock);
336 if (!ns->ns_active) {
338 * Add one to the reference count to
339 * hold onto the SVID for the lifetime
340 * of the lock. Note that since
341 * F_FLOCK only supports whole-file
342 * locks, there can only be one active
343 * lock for this SVID.
346 ns->ns_active = TRUE;
348 mtx_unlock(&nlm_svid_lock);
353 error = nlm_clearlock(host, &ext, vers, &timo, retries,
354 vp, op, fl, flags, svid, fhlen, &fh.fh_bytes, size);
356 mtx_lock(&nlm_svid_lock);
359 ns->ns_active = FALSE;
361 mtx_unlock(&nlm_svid_lock);
366 error = nlm_getlock(host, &ext, vers, &timo, retries,
367 vp, op, fl, flags, svid, fhlen, &fh.fh_bytes, size);
378 cred1 = td->td_ucred;
383 nlm_host_release(host);
389 nlm_advlock(struct vop_advlock_args *ap)
392 return (nlm_advlock_internal(ap->a_vp, ap->a_id, ap->a_op, ap->a_fl,
393 ap->a_flags, FALSE, TRUE));
397 * Set the creds of td to the creds of the given lock's owner. The new
398 * creds reference count will be incremented via crhold. The caller is
399 * responsible for calling crfree and restoring td's original creds.
402 nlm_set_creds_for_lock(struct thread *td, struct flock *fl)
405 struct nlm_file_svid *ns;
410 if (fl->l_pid > PID_MAX) {
412 * If this was originally a F_FLOCK-style lock, we
413 * recorded the creds used when it was originally
414 * locked in the nlm_file_svid structure.
416 mtx_lock(&nlm_svid_lock);
417 for (i = 0; i < NLM_SVID_HASH_SIZE; i++) {
418 for (ns = LIST_FIRST(&nlm_file_svids[i]); ns;
419 ns = LIST_NEXT(ns, ns_link)) {
420 if (ns->ns_svid == fl->l_pid) {
421 cred = crhold(ns->ns_ucred);
426 mtx_unlock(&nlm_svid_lock);
429 * This lock is owned by a process. Get a reference to
432 p = pfind(fl->l_pid);
434 cred = crhold(p->p_ucred);
440 * If we can't find a cred, fall back on the recovery
444 cred = crhold(td->td_ucred);
451 nlm_reclaim_free_lock(struct vnode *vp, struct flock *fl, void *arg)
454 struct thread *td = curthread;
455 struct ucred *oldcred;
459 newfl.l_type = F_UNLCK;
461 oldcred = td->td_ucred;
462 nlm_set_creds_for_lock(td, &newfl);
464 error = nlm_advlock_internal(vp, NULL, F_UNLCK, &newfl, F_REMOTE,
467 crfree(td->td_ucred);
468 td->td_ucred = oldcred;
474 nlm_reclaim(struct vop_reclaim_args *ap)
477 nlm_cancel_wait(ap->a_vp);
478 lf_iteratelocks_vnode(ap->a_vp, nlm_reclaim_free_lock, NULL);
482 struct nlm_recovery_context {
483 struct nlm_host *nr_host; /* host we are recovering */
484 int nr_state; /* remote NSM state for recovery */
488 nlm_client_recover_lock(struct vnode *vp, struct flock *fl, void *arg)
490 struct nlm_recovery_context *nr = (struct nlm_recovery_context *) arg;
491 struct thread *td = curthread;
492 struct ucred *oldcred;
496 * If the remote NSM state changes during recovery, the host
497 * must have rebooted a second time. In that case, we must
498 * restart the recovery.
500 state = nlm_host_get_state(nr->nr_host);
501 if (nr->nr_state != state)
504 error = vn_lock(vp, LK_SHARED);
508 oldcred = td->td_ucred;
509 nlm_set_creds_for_lock(td, fl);
511 error = nlm_advlock_internal(vp, NULL, F_SETLK, fl, F_REMOTE,
514 crfree(td->td_ucred);
515 td->td_ucred = oldcred;
521 nlm_client_recovery(struct nlm_host *host)
523 struct nlm_recovery_context nr;
526 sysid = NLM_SYSID_CLIENT | nlm_host_get_sysid(host);
529 nr.nr_state = nlm_host_get_state(host);
530 error = lf_iteratelocks_sysid(sysid,
531 nlm_client_recover_lock, &nr);
532 } while (error == ERESTART);
536 nlm_convert_to_nlm_lock(struct nlm_lock *dst, struct nlm4_lock *src)
539 dst->caller_name = src->caller_name;
542 dst->svid = src->svid;
543 dst->l_offset = src->l_offset;
544 dst->l_len = src->l_len;
548 nlm_convert_to_nlm4_holder(struct nlm4_holder *dst, struct nlm_holder *src)
551 dst->exclusive = src->exclusive;
552 dst->svid = src->svid;
554 dst->l_offset = src->l_offset;
555 dst->l_len = src->l_len;
559 nlm_convert_to_nlm4_res(struct nlm4_res *dst, struct nlm_res *src)
561 dst->cookie = src->cookie;
562 dst->stat.stat = (enum nlm4_stats) src->stat.stat;
565 static enum clnt_stat
566 nlm_test_rpc(rpcvers_t vers, nlm4_testargs *args, nlm4_testres *res, CLIENT *client,
567 struct rpc_callextra *ext, struct timeval timo)
569 if (vers == NLM_VERS4) {
570 return nlm4_test_4(args, res, client, ext, timo);
576 args1.cookie = args->cookie;
577 args1.exclusive = args->exclusive;
578 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
579 memset(&res1, 0, sizeof(res1));
581 stat = nlm_test_1(&args1, &res1, client, ext, timo);
583 if (stat == RPC_SUCCESS) {
584 res->cookie = res1.cookie;
585 res->stat.stat = (enum nlm4_stats) res1.stat.stat;
586 if (res1.stat.stat == nlm_denied)
587 nlm_convert_to_nlm4_holder(
588 &res->stat.nlm4_testrply_u.holder,
589 &res1.stat.nlm_testrply_u.holder);
596 static enum clnt_stat
597 nlm_lock_rpc(rpcvers_t vers, nlm4_lockargs *args, nlm4_res *res, CLIENT *client,
598 struct rpc_callextra *ext, struct timeval timo)
600 if (vers == NLM_VERS4) {
601 return nlm4_lock_4(args, res, client, ext, timo);
607 args1.cookie = args->cookie;
608 args1.block = args->block;
609 args1.exclusive = args->exclusive;
610 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
611 args1.reclaim = args->reclaim;
612 args1.state = args->state;
613 memset(&res1, 0, sizeof(res1));
615 stat = nlm_lock_1(&args1, &res1, client, ext, timo);
617 if (stat == RPC_SUCCESS) {
618 nlm_convert_to_nlm4_res(res, &res1);
625 static enum clnt_stat
626 nlm_cancel_rpc(rpcvers_t vers, nlm4_cancargs *args, nlm4_res *res, CLIENT *client,
627 struct rpc_callextra *ext, struct timeval timo)
629 if (vers == NLM_VERS4) {
630 return nlm4_cancel_4(args, res, client, ext, timo);
636 args1.cookie = args->cookie;
637 args1.block = args->block;
638 args1.exclusive = args->exclusive;
639 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
640 memset(&res1, 0, sizeof(res1));
642 stat = nlm_cancel_1(&args1, &res1, client, ext, timo);
644 if (stat == RPC_SUCCESS) {
645 nlm_convert_to_nlm4_res(res, &res1);
652 static enum clnt_stat
653 nlm_unlock_rpc(rpcvers_t vers, nlm4_unlockargs *args, nlm4_res *res, CLIENT *client,
654 struct rpc_callextra *ext, struct timeval timo)
656 if (vers == NLM_VERS4) {
657 return nlm4_unlock_4(args, res, client, ext, timo);
659 nlm_unlockargs args1;
663 args1.cookie = args->cookie;
664 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
665 memset(&res1, 0, sizeof(res1));
667 stat = nlm_unlock_1(&args1, &res1, client, ext, timo);
669 if (stat == RPC_SUCCESS) {
670 nlm_convert_to_nlm4_res(res, &res1);
678 * Called after a lock request (set or clear) succeeded. We record the
679 * details in the local lock manager. Note that since the remote
680 * server has granted the lock, we can be sure that it doesn't
681 * conflict with any other locks we have in the local lock manager.
683 * Since it is possible that host may also make NLM client requests to
684 * our NLM server, we use a different sysid value to record our own
687 * Note that since it is possible for us to receive replies from the
688 * server in a different order than the locks were granted (e.g. if
689 * many local threads are contending for the same lock), we must use a
690 * blocking operation when registering with the local lock manager.
691 * We expect that any actual wait will be rare and short hence we
692 * ignore signals for this.
695 nlm_record_lock(struct vnode *vp, int op, struct flock *fl,
696 int svid, int sysid, off_t size)
698 struct vop_advlockasync_args a;
706 a.a_flags = F_REMOTE|F_WAIT|F_NOINTR;
709 newfl.l_start = fl->l_start;
710 newfl.l_len = fl->l_len;
711 newfl.l_type = fl->l_type;
712 newfl.l_whence = fl->l_whence;
714 newfl.l_sysid = NLM_SYSID_CLIENT | sysid;
717 error = lf_advlockasync(&a, &vp->v_lockf, size);
718 if (error == EDEADLK) {
720 * Locks are associated with the processes and
721 * not with threads. Suppose we have two
722 * threads A1 A2 in one process, A1 locked
723 * file f1, A2 is locking file f2, and A1 is
724 * unlocking f1. Then remote server may
725 * already unlocked f1, while local still not
726 * yet scheduled A1 to make the call to local
727 * advlock manager. The process B owns lock on
728 * f2 and issued the lock on f1. Remote would
729 * grant B the request on f1, but local would
733 /* XXXKIB allow suspend */
734 } else if (error == EINTR) {
736 * lf_purgelocks() might wake up the lock
737 * waiter and removed our lock graph edges.
738 * There is no sense in re-trying recording
739 * the lock to the local manager after
747 KASSERT(error == 0 || error == ENOENT,
748 ("Failed to register NFS lock locally - error=%d", error));
752 nlm_setlock(struct nlm_host *host, struct rpc_callextra *ext,
753 rpcvers_t vers, struct timeval *timo, int retries,
754 struct vnode *vp, int op, struct flock *fl, int flags,
755 int svid, size_t fhlen, void *fh, off_t size, bool_t reclaim)
757 struct nlm4_lockargs args;
763 int retry, block, exclusive;
764 void *wait_handle = NULL;
767 memset(&args, 0, sizeof(args));
768 memset(&res, 0, sizeof(res));
770 block = (flags & F_WAIT) ? TRUE : FALSE;
771 exclusive = (fl->l_type == F_WRLCK);
773 error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size,
774 &args.alock, oh_space);
778 args.exclusive = exclusive;
779 args.reclaim = reclaim;
780 args.state = nlm_nsm_state;
784 client = nlm_host_get_rpc(host, FALSE);
786 return (ENOLCK); /* XXX retry? */
789 wait_handle = nlm_register_wait_lock(&args.alock, vp);
791 xid = atomic_fetchadd_int(&nlm_xid, 1);
792 args.cookie.n_len = sizeof(xid);
793 args.cookie.n_bytes = (char*) &xid;
795 stat = nlm_lock_rpc(vers, &args, &res, client, ext, *timo);
797 CLNT_RELEASE(client);
799 if (stat != RPC_SUCCESS) {
801 nlm_deregister_wait_lock(wait_handle);
812 xdr_free((xdrproc_t) xdr_nlm4_res, &res);
814 if (block && res.stat.stat != nlm4_blocked)
815 nlm_deregister_wait_lock(wait_handle);
817 if (res.stat.stat == nlm4_denied_grace_period) {
819 * The server has recently rebooted and is
820 * giving old clients a change to reclaim
821 * their locks. Wait for a few seconds and try
824 error = tsleep(&args, PCATCH, "nlmgrace", retry);
825 if (error && error != EWOULDBLOCK)
833 if (block && res.stat.stat == nlm4_blocked) {
835 * The server should call us back with a
836 * granted message when the lock succeeds. In
837 * order to deal with broken servers, lost
838 * granted messages and server reboots, we
839 * will also re-try every few seconds.
841 error = nlm_wait_lock(wait_handle, retry);
842 if (error == EWOULDBLOCK) {
850 * We need to call the server to
851 * cancel our lock request.
853 nlm4_cancargs cancel;
855 memset(&cancel, 0, sizeof(cancel));
857 xid = atomic_fetchadd_int(&nlm_xid, 1);
858 cancel.cookie.n_len = sizeof(xid);
859 cancel.cookie.n_bytes = (char*) &xid;
860 cancel.block = block;
861 cancel.exclusive = exclusive;
862 cancel.alock = args.alock;
865 client = nlm_host_get_rpc(host, FALSE);
870 stat = nlm_cancel_rpc(vers, &cancel,
871 &res, client, ext, *timo);
873 CLNT_RELEASE(client);
875 if (stat != RPC_SUCCESS) {
881 * reboots. This means
887 pause("nlmcancel", 10*hz);
889 } while (stat != RPC_SUCCESS);
894 xdr_free((xdrproc_t) xdr_nlm4_res, &res);
896 switch (res.stat.stat) {
908 case nlm4_denied_grace_period:
911 * recently rebooted -
937 error = nlm_map_status(res.stat.stat);
940 if (!error && !reclaim) {
941 nlm_record_lock(vp, op, fl, args.alock.svid,
942 nlm_host_get_sysid(host), size);
943 nlm_host_monitor(host, 0);
951 nlm_clearlock(struct nlm_host *host, struct rpc_callextra *ext,
952 rpcvers_t vers, struct timeval *timo, int retries,
953 struct vnode *vp, int op, struct flock *fl, int flags,
954 int svid, size_t fhlen, void *fh, off_t size)
956 struct nlm4_unlockargs args;
964 memset(&args, 0, sizeof(args));
965 memset(&res, 0, sizeof(res));
967 error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size,
968 &args.alock, oh_space);
973 client = nlm_host_get_rpc(host, FALSE);
975 return (ENOLCK); /* XXX retry? */
977 xid = atomic_fetchadd_int(&nlm_xid, 1);
978 args.cookie.n_len = sizeof(xid);
979 args.cookie.n_bytes = (char*) &xid;
981 stat = nlm_unlock_rpc(vers, &args, &res, client, ext, *timo);
983 CLNT_RELEASE(client);
985 if (stat != RPC_SUCCESS) {
996 xdr_free((xdrproc_t) xdr_nlm4_res, &res);
998 if (res.stat.stat == nlm4_denied_grace_period) {
1000 * The server has recently rebooted and is
1001 * giving old clients a change to reclaim
1002 * their locks. Wait for a few seconds and try
1005 error = tsleep(&args, PCATCH, "nlmgrace", 5*hz);
1006 if (error && error != EWOULDBLOCK)
1012 * If we are being called via nlm_reclaim (which will
1013 * use the F_REMOTE flag), don't record the lock
1014 * operation in the local lock manager since the vnode
1017 if (!(flags & F_REMOTE))
1018 nlm_record_lock(vp, op, fl, args.alock.svid,
1019 nlm_host_get_sysid(host), size);
1026 nlm_getlock(struct nlm_host *host, struct rpc_callextra *ext,
1027 rpcvers_t vers, struct timeval *timo, int retries,
1028 struct vnode *vp, int op, struct flock *fl, int flags,
1029 int svid, size_t fhlen, void *fh, off_t size)
1031 struct nlm4_testargs args;
1033 struct nlm4_testres res;
1036 enum clnt_stat stat;
1040 KASSERT(!(flags & F_FLOCK), ("unexpected F_FLOCK for F_GETLK"));
1042 memset(&args, 0, sizeof(args));
1043 memset(&res, 0, sizeof(res));
1045 exclusive = (fl->l_type == F_WRLCK);
1047 error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size,
1048 &args.alock, oh_space);
1051 args.exclusive = exclusive;
1054 client = nlm_host_get_rpc(host, FALSE);
1056 return (ENOLCK); /* XXX retry? */
1058 xid = atomic_fetchadd_int(&nlm_xid, 1);
1059 args.cookie.n_len = sizeof(xid);
1060 args.cookie.n_bytes = (char*) &xid;
1062 stat = nlm_test_rpc(vers, &args, &res, client, ext, *timo);
1064 CLNT_RELEASE(client);
1066 if (stat != RPC_SUCCESS) {
1074 if (res.stat.stat == nlm4_denied_grace_period) {
1076 * The server has recently rebooted and is
1077 * giving old clients a change to reclaim
1078 * their locks. Wait for a few seconds and try
1081 xdr_free((xdrproc_t) xdr_nlm4_testres, &res);
1082 error = tsleep(&args, PCATCH, "nlmgrace", 5*hz);
1083 if (error && error != EWOULDBLOCK)
1088 if (res.stat.stat == nlm4_denied) {
1089 struct nlm4_holder *h =
1090 &res.stat.nlm4_testrply_u.holder;
1091 fl->l_start = h->l_offset;
1092 fl->l_len = h->l_len;
1093 fl->l_pid = h->svid;
1095 fl->l_type = F_WRLCK;
1097 fl->l_type = F_RDLCK;
1098 fl->l_whence = SEEK_SET;
1101 fl->l_type = F_UNLCK;
1104 xdr_free((xdrproc_t) xdr_nlm4_testres, &res);
1111 nlm_map_status(nlm4_stats stat)
1120 case nlm4_denied_nolocks:
1143 static struct nlm_file_svid *
1144 nlm_find_svid(void *id)
1146 struct nlm_file_svid *ns, *newns;
1149 h = (((uintptr_t) id) >> 7) % NLM_SVID_HASH_SIZE;
1151 mtx_lock(&nlm_svid_lock);
1152 LIST_FOREACH(ns, &nlm_file_svids[h], ns_link) {
1153 if (ns->ns_id == id) {
1158 mtx_unlock(&nlm_svid_lock);
1160 int svid = alloc_unr(nlm_svid_allocator);
1161 newns = malloc(sizeof(struct nlm_file_svid), M_NLM,
1165 newns->ns_svid = svid;
1166 newns->ns_ucred = NULL;
1167 newns->ns_active = FALSE;
1170 * We need to check for a race with some other
1171 * thread allocating a svid for this file.
1173 mtx_lock(&nlm_svid_lock);
1174 LIST_FOREACH(ns, &nlm_file_svids[h], ns_link) {
1175 if (ns->ns_id == id) {
1181 mtx_unlock(&nlm_svid_lock);
1182 free_unr(nlm_svid_allocator, newns->ns_svid);
1185 LIST_INSERT_HEAD(&nlm_file_svids[h], newns,
1188 mtx_unlock(&nlm_svid_lock);
1196 nlm_free_svid(struct nlm_file_svid *ns)
1199 mtx_lock(&nlm_svid_lock);
1202 KASSERT(!ns->ns_active, ("Freeing active SVID"));
1203 LIST_REMOVE(ns, ns_link);
1204 mtx_unlock(&nlm_svid_lock);
1205 free_unr(nlm_svid_allocator, ns->ns_svid);
1207 crfree(ns->ns_ucred);
1210 mtx_unlock(&nlm_svid_lock);
1215 nlm_init_lock(struct flock *fl, int flags, int svid,
1216 rpcvers_t vers, size_t fhlen, void *fh, off_t size,
1217 struct nlm4_lock *lock, char oh_space[32])
1222 if (fl->l_whence == SEEK_END) {
1224 || (fl->l_start > 0 && size > OFF_MAX - fl->l_start))
1226 start = size + fl->l_start;
1227 } else if (fl->l_whence == SEEK_SET || fl->l_whence == SEEK_CUR) {
1228 start = fl->l_start;
1234 if (fl->l_len < 0) {
1243 if (vers == NLM_VERS) {
1245 * Enforce range limits on V1 locks
1247 if (start > 0xffffffffLL || len > 0xffffffffLL)
1251 snprintf(oh_space, 32, "%d@", svid);
1252 oh_len = strlen(oh_space);
1253 getcredhostname(NULL, oh_space + oh_len, 32 - oh_len);
1254 oh_len = strlen(oh_space);
1256 memset(lock, 0, sizeof(*lock));
1257 lock->caller_name = prison0.pr_hostname;
1258 lock->fh.n_len = fhlen;
1259 lock->fh.n_bytes = fh;
1260 lock->oh.n_len = oh_len;
1261 lock->oh.n_bytes = oh_space;
1263 lock->l_offset = start;