FreeBSD/Linux Kernel Cross Reference
sys/nlm/nlm_advlock.c
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: src/sys/nlm/nlm_advlock.c,v 1.3 2008/11/03 10:38:00 dfr Exp $");
30
31 #include <sys/param.h>
32 #include <sys/fcntl.h>
33 #include <sys/kernel.h>
34 #include <sys/limits.h>
35 #include <sys/lock.h>
36 #include <sys/lockf.h>
37 #include <sys/malloc.h>
38 #include <sys/mount.h>
39 #include <sys/mutex.h>
40 #include <sys/proc.h>
41 #include <sys/syslog.h>
42 #include <sys/systm.h>
43 #include <sys/unistd.h>
44 #include <sys/vnode.h>
45
46 #include <rpc/rpcclnt.h>
47 #include <nfs/nfsproto.h>
48 #include <nfsclient/nfs.h>
49 #include <nfsclient/nfsnode.h>
50 #include <nfsclient/nfsmount.h>
51
52 #include <nlm/nlm_prot.h>
53 #include <nlm/nlm.h>
54
55 /*
56 * We need to keep track of the svid values used for F_FLOCK locks.
57 */
58 struct nlm_file_svid {
59 int ns_refs; /* thread count + 1 if active */
60 int ns_svid; /* on-the-wire SVID for this file */
61 struct ucred *ns_ucred; /* creds to use for lock recovery */
62 void *ns_id; /* local struct file pointer */
63 bool_t ns_active; /* TRUE if we own a lock */
64 LIST_ENTRY(nlm_file_svid) ns_link;
65 };
66 LIST_HEAD(nlm_file_svid_list, nlm_file_svid);
67
68 #define NLM_SVID_HASH_SIZE 256
69 struct nlm_file_svid_list nlm_file_svids[NLM_SVID_HASH_SIZE];
70
71 struct mtx nlm_svid_lock;
72 static struct unrhdr *nlm_svid_allocator;
73 static volatile u_int nlm_xid = 1;
74
75 static int nlm_setlock(struct nlm_host *host, struct rpc_callextra *ext,
76 rpcvers_t vers, struct timeval *timo, int retries,
77 struct vnode *vp, int op, struct flock *fl, int flags,
78 int svid, size_t fhlen, void *fh, off_t size, bool_t reclaim);
79 static int nlm_clearlock(struct nlm_host *host, struct rpc_callextra *ext,
80 rpcvers_t vers, struct timeval *timo, int retries,
81 struct vnode *vp, int op, struct flock *fl, int flags,
82 int svid, size_t fhlen, void *fh, off_t size);
83 static int nlm_getlock(struct nlm_host *host, struct rpc_callextra *ext,
84 rpcvers_t vers, struct timeval *timo, int retries,
85 struct vnode *vp, int op, struct flock *fl, int flags,
86 int svid, size_t fhlen, void *fh, off_t size);
87 static int nlm_map_status(nlm4_stats stat);
88 static struct nlm_file_svid *nlm_find_svid(void *id);
89 static void nlm_free_svid(struct nlm_file_svid *nf);
90 static int nlm_init_lock(struct flock *fl, int flags, int svid,
91 rpcvers_t vers, size_t fhlen, void *fh, off_t size,
92 struct nlm4_lock *lock, char oh_space[32]);
93
94 static void
95 nlm_client_init(void *dummy)
96 {
97 int i;
98
99 mtx_init(&nlm_svid_lock, "NLM svid lock", NULL, MTX_DEF);
100 nlm_svid_allocator = new_unrhdr(PID_MAX + 2, INT_MAX, &nlm_svid_lock);
101 for (i = 0; i < NLM_SVID_HASH_SIZE; i++)
102 LIST_INIT(&nlm_file_svids[i]);
103 }
104 SYSINIT(nlm_client_init, SI_SUB_LOCK, SI_ORDER_FIRST, nlm_client_init, NULL);
105
106 static int
107 nlm_msg(struct thread *td, const char *server, const char *msg, int error)
108 {
109 struct proc *p;
110
111 p = td ? td->td_proc : NULL;
112 if (error) {
113 tprintf(p, LOG_INFO, "nfs server %s: %s, error %d\n", server,
114 msg, error);
115 } else {
116 tprintf(p, LOG_INFO, "nfs server %s: %s\n", server, msg);
117 }
118 return (0);
119 }
120
121 struct nlm_feedback_arg {
122 bool_t nf_printed;
123 struct nfsmount *nf_nmp;
124 };
125
126 static void
127 nlm_down(struct nlm_feedback_arg *nf, struct thread *td,
128 const char *msg, int error)
129 {
130 struct nfsmount *nmp = nf->nf_nmp;
131
132 if (nmp == NULL)
133 return;
134 mtx_lock(&nmp->nm_mtx);
135 if (!(nmp->nm_state & NFSSTA_LOCKTIMEO)) {
136 nmp->nm_state |= NFSSTA_LOCKTIMEO;
137 mtx_unlock(&nmp->nm_mtx);
138 vfs_event_signal(&nmp->nm_mountp->mnt_stat.f_fsid,
139 VQ_NOTRESPLOCK, 0);
140 } else {
141 mtx_unlock(&nmp->nm_mtx);
142 }
143
144 nf->nf_printed = TRUE;
145 nlm_msg(td, nmp->nm_mountp->mnt_stat.f_mntfromname, msg, error);
146 }
147
148 static void
149 nlm_up(struct nlm_feedback_arg *nf, struct thread *td,
150 const char *msg)
151 {
152 struct nfsmount *nmp = nf->nf_nmp;
153
154 if (!nf->nf_printed)
155 return;
156
157 nlm_msg(td, nmp->nm_mountp->mnt_stat.f_mntfromname, msg, 0);
158
159 mtx_lock(&nmp->nm_mtx);
160 if (nmp->nm_state & NFSSTA_LOCKTIMEO) {
161 nmp->nm_state &= ~NFSSTA_LOCKTIMEO;
162 mtx_unlock(&nmp->nm_mtx);
163 vfs_event_signal(&nmp->nm_mountp->mnt_stat.f_fsid,
164 VQ_NOTRESPLOCK, 1);
165 } else {
166 mtx_unlock(&nmp->nm_mtx);
167 }
168 }
169
170 static void
171 nlm_feedback(int type, int proc, void *arg)
172 {
173 struct thread *td = curthread;
174 struct nlm_feedback_arg *nf = (struct nlm_feedback_arg *) arg;
175
176 switch (type) {
177 case FEEDBACK_REXMIT2:
178 case FEEDBACK_RECONNECT:
179 nlm_down(nf, td, "lockd not responding", 0);
180 break;
181
182 case FEEDBACK_OK:
183 nlm_up(nf, td, "lockd is alive again");
184 break;
185 }
186 }
187
188 /*
189 * nlm_advlock --
190 * NFS advisory byte-level locks.
191 */
192 static int
193 nlm_advlock_internal(struct vnode *vp, void *id, int op, struct flock *fl,
194 int flags, bool_t reclaim, bool_t unlock_vp)
195 {
196 struct thread *td = curthread;
197 struct nfsmount *nmp;
198 struct nfsnode *np;
199 off_t size;
200 size_t fhlen;
201 union nfsfh fh;
202 struct sockaddr *sa;
203 struct sockaddr_storage ss;
204 char servername[MNAMELEN];
205 struct timeval timo;
206 int retries;
207 rpcvers_t vers;
208 struct nlm_host *host;
209 struct rpc_callextra ext;
210 struct nlm_feedback_arg nf;
211 AUTH *auth;
212 struct ucred *cred;
213 struct nlm_file_svid *ns;
214 int svid;
215 int error;
216
217 ASSERT_VOP_LOCKED(vp, "nlm_advlock_1");
218
219 /*
220 * Push any pending writes to the server and flush our cache
221 * so that if we are contending with another machine for a
222 * file, we get whatever they wrote and vice-versa.
223 */
224 if (op == F_SETLK || op == F_UNLCK)
225 nfs_vinvalbuf(vp, V_SAVE, td, 1);
226
227 np = VTONFS(vp);
228 nmp = VFSTONFS(vp->v_mount);
229 size = np->n_size;
230 sa = nmp->nm_nam;
231 memcpy(&ss, sa, sa->sa_len);
232 sa = (struct sockaddr *) &ss;
233 mtx_lock(&hostname_mtx);
234 strcpy(servername, nmp->nm_hostname);
235 mtx_unlock(&hostname_mtx);
236 fhlen = np->n_fhsize;
237 memcpy(&fh.fh_bytes, np->n_fhp, fhlen);
238 timo.tv_sec = nmp->nm_timeo / NFS_HZ;
239 timo.tv_usec = (nmp->nm_timeo % NFS_HZ) * (1000000 / NFS_HZ);
240 if (NFS_ISV3(vp))
241 vers = NLM_VERS4;
242 else
243 vers = NLM_VERS;
244
245 if (nmp->nm_flag & NFSMNT_SOFT)
246 retries = nmp->nm_retry;
247 else
248 retries = INT_MAX;
249
250 if (unlock_vp)
251 VOP_UNLOCK(vp, 0);
252
253 /*
254 * We need to switch to mount-point creds so that we can send
255 * packets from a privileged port.
256 */
257 cred = td->td_ucred;
258 td->td_ucred = vp->v_mount->mnt_cred;
259
260 host = nlm_find_host_by_name(servername, sa, vers);
261 auth = authunix_create(cred);
262 memset(&ext, 0, sizeof(ext));
263
264 nf.nf_printed = FALSE;
265 nf.nf_nmp = nmp;
266 ext.rc_auth = auth;
267
268 ext.rc_feedback = nlm_feedback;
269 ext.rc_feedback_arg = &nf;
270 ext.rc_timers = NULL;
271
272 ns = NULL;
273 if (flags & F_FLOCK) {
274 ns = nlm_find_svid(id);
275 KASSERT(fl->l_start == 0 && fl->l_len == 0,
276 ("F_FLOCK lock requests must be whole-file locks"));
277 if (!ns->ns_ucred) {
278 /*
279 * Remember the creds used for locking in case
280 * we need to recover the lock later.
281 */
282 ns->ns_ucred = crdup(cred);
283 }
284 svid = ns->ns_svid;
285 } else if (flags & F_REMOTE) {
286 /*
287 * If we are recovering after a server restart or
288 * trashing locks on a force unmount, use the same
289 * svid as last time.
290 */
291 svid = fl->l_pid;
292 } else {
293 svid = ((struct proc *) id)->p_pid;
294 }
295
296 switch(op) {
297 case F_SETLK:
298 if ((flags & (F_FLOCK|F_WAIT)) == (F_FLOCK|F_WAIT)
299 && fl->l_type == F_WRLCK) {
300 /*
301 * The semantics for flock(2) require that any
302 * shared lock on the file must be released
303 * before an exclusive lock is granted. The
304 * local locking code interprets this by
305 * unlocking the file before sleeping on a
306 * blocked exclusive lock request. We
307 * approximate this by first attempting
308 * non-blocking and if that fails, we unlock
309 * the file and block.
310 */
311 error = nlm_setlock(host, &ext, vers, &timo, retries,
312 vp, F_SETLK, fl, flags & ~F_WAIT,
313 svid, fhlen, &fh.fh_bytes, size, reclaim);
314 if (error == EAGAIN) {
315 fl->l_type = F_UNLCK;
316 error = nlm_clearlock(host, &ext, vers, &timo,
317 retries, vp, F_UNLCK, fl, flags,
318 svid, fhlen, &fh.fh_bytes, size);
319 fl->l_type = F_WRLCK;
320 if (!error) {
321 mtx_lock(&nlm_svid_lock);
322 if (ns->ns_active) {
323 ns->ns_refs--;
324 ns->ns_active = FALSE;
325 }
326 mtx_unlock(&nlm_svid_lock);
327 flags |= F_WAIT;
328 error = nlm_setlock(host, &ext, vers,
329 &timo, retries, vp, F_SETLK, fl,
330 flags, svid, fhlen, &fh.fh_bytes,
331 size, reclaim);
332 }
333 }
334 } else {
335 error = nlm_setlock(host, &ext, vers, &timo, retries,
336 vp, op, fl, flags, svid, fhlen, &fh.fh_bytes,
337 size, reclaim);
338 }
339 if (!error && ns) {
340 mtx_lock(&nlm_svid_lock);
341 if (!ns->ns_active) {
342 /*
343 * Add one to the reference count to
344 * hold onto the SVID for the lifetime
345 * of the lock. Note that since
346 * F_FLOCK only supports whole-file
347 * locks, there can only be one active
348 * lock for this SVID.
349 */
350 ns->ns_refs++;
351 ns->ns_active = TRUE;
352 }
353 mtx_unlock(&nlm_svid_lock);
354 }
355 break;
356
357 case F_UNLCK:
358 error = nlm_clearlock(host, &ext, vers, &timo, retries,
359 vp, op, fl, flags, svid, fhlen, &fh.fh_bytes, size);
360 if (!error && ns) {
361 mtx_lock(&nlm_svid_lock);
362 if (ns->ns_active) {
363 ns->ns_refs--;
364 ns->ns_active = FALSE;
365 }
366 mtx_unlock(&nlm_svid_lock);
367 }
368 break;
369
370 case F_GETLK:
371 error = nlm_getlock(host, &ext, vers, &timo, retries,
372 vp, op, fl, flags, svid, fhlen, &fh.fh_bytes, size);
373 break;
374
375 default:
376 error = EINVAL;
377 break;
378 }
379
380 if (ns)
381 nlm_free_svid(ns);
382
383 td->td_ucred = cred;
384 AUTH_DESTROY(auth);
385
386 nlm_host_release(host);
387
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 int error;
704
705 a.a_vp = vp;
706 a.a_id = NULL;
707 a.a_op = op;
708 a.a_fl = &newfl;
709 a.a_flags = F_REMOTE|F_WAIT|F_NOINTR;
710 a.a_task = NULL;
711 a.a_cookiep = NULL;
712 newfl.l_start = fl->l_start;
713 newfl.l_len = fl->l_len;
714 newfl.l_type = fl->l_type;
715 newfl.l_whence = fl->l_whence;
716 newfl.l_pid = svid;
717 newfl.l_sysid = NLM_SYSID_CLIENT | sysid;
718
719 error = lf_advlockasync(&a, &vp->v_lockf, size);
720 KASSERT(error == 0, ("Failed to register NFS lock locally - error=%d",
721 error));
722 }
723
724 static int
725 nlm_setlock(struct nlm_host *host, struct rpc_callextra *ext,
726 rpcvers_t vers, struct timeval *timo, int retries,
727 struct vnode *vp, int op, struct flock *fl, int flags,
728 int svid, size_t fhlen, void *fh, off_t size, bool_t reclaim)
729 {
730 struct nlm4_lockargs args;
731 char oh_space[32];
732 struct nlm4_res res;
733 u_int xid;
734 CLIENT *client;
735 enum clnt_stat stat;
736 int retry, block, exclusive;
737 void *wait_handle = NULL;
738 int error;
739
740 memset(&args, 0, sizeof(args));
741 memset(&res, 0, sizeof(res));
742
743 block = (flags & F_WAIT) ? TRUE : FALSE;
744 exclusive = (fl->l_type == F_WRLCK);
745
746 error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size,
747 &args.alock, oh_space);
748 if (error)
749 return (error);
750 args.block = block;
751 args.exclusive = exclusive;
752 args.reclaim = reclaim;
753 args.state = nlm_nsm_state;
754
755 retry = 5*hz;
756 for (;;) {
757 client = nlm_host_get_rpc(host, FALSE);
758 if (!client)
759 return (ENOLCK); /* XXX retry? */
760
761 if (block)
762 wait_handle = nlm_register_wait_lock(&args.alock, vp);
763
764 xid = atomic_fetchadd_int(&nlm_xid, 1);
765 args.cookie.n_len = sizeof(xid);
766 args.cookie.n_bytes = (char*) &xid;
767
768 stat = nlm_lock_rpc(vers, &args, &res, client, ext, *timo);
769
770 CLNT_RELEASE(client);
771
772 if (stat != RPC_SUCCESS) {
773 if (block)
774 nlm_deregister_wait_lock(wait_handle);
775 if (retries) {
776 retries--;
777 continue;
778 }
779 return (EINVAL);
780 }
781
782 /*
783 * Free res.cookie.
784 */
785 xdr_free((xdrproc_t) xdr_nlm4_res, &res);
786
787 if (block && res.stat.stat != nlm4_blocked)
788 nlm_deregister_wait_lock(wait_handle);
789
790 if (res.stat.stat == nlm4_denied_grace_period) {
791 /*
792 * The server has recently rebooted and is
793 * giving old clients a change to reclaim
794 * their locks. Wait for a few seconds and try
795 * again.
796 */
797 error = tsleep(&args, PCATCH, "nlmgrace", retry);
798 if (error && error != EWOULDBLOCK)
799 return (error);
800 retry = 2*retry;
801 if (retry > 30*hz)
802 retry = 30*hz;
803 continue;
804 }
805
806 if (block && res.stat.stat == nlm4_blocked) {
807 /*
808 * The server should call us back with a
809 * granted message when the lock succeeds. In
810 * order to deal with broken servers, lost
811 * granted messages and server reboots, we
812 * will also re-try every few seconds.
813 */
814 error = nlm_wait_lock(wait_handle, retry);
815 if (error == EWOULDBLOCK) {
816 retry = 2*retry;
817 if (retry > 30*hz)
818 retry = 30*hz;
819 continue;
820 }
821 if (error) {
822 /*
823 * We need to call the server to
824 * cancel our lock request.
825 */
826 nlm4_cancargs cancel;
827
828 memset(&cancel, 0, sizeof(cancel));
829
830 xid = atomic_fetchadd_int(&nlm_xid, 1);
831 cancel.cookie.n_len = sizeof(xid);
832 cancel.cookie.n_bytes = (char*) &xid;
833 cancel.block = block;
834 cancel.exclusive = exclusive;
835 cancel.alock = args.alock;
836
837 do {
838 client = nlm_host_get_rpc(host, FALSE);
839 if (!client)
840 /* XXX retry? */
841 return (ENOLCK);
842
843 stat = nlm_cancel_rpc(vers, &cancel,
844 &res, client, ext, *timo);
845
846 CLNT_RELEASE(client);
847
848 if (stat != RPC_SUCCESS) {
849 /*
850 * We need to cope
851 * with temporary
852 * network partitions
853 * as well as server
854 * reboots. This means
855 * we have to keep
856 * trying to cancel
857 * until the server
858 * wakes up again.
859 */
860 pause("nlmcancel", 10*hz);
861 }
862 } while (stat != RPC_SUCCESS);
863
864 /*
865 * Free res.cookie.
866 */
867 xdr_free((xdrproc_t) xdr_nlm4_res, &res);
868
869 switch (res.stat.stat) {
870 case nlm_denied:
871 /*
872 * There was nothing
873 * to cancel. We are
874 * going to go ahead
875 * and assume we got
876 * the lock.
877 */
878 error = 0;
879 break;
880
881 case nlm4_denied_grace_period:
882 /*
883 * The server has
884 * recently rebooted -
885 * treat this as a
886 * successful
887 * cancellation.
888 */
889 break;
890
891 case nlm4_granted:
892 /*
893 * We managed to
894 * cancel.
895 */
896 break;
897
898 default:
899 /*
900 * Broken server
901 * implementation -
902 * can't really do
903 * anything here.
904 */
905 break;
906 }
907
908 }
909 } else {
910 error = nlm_map_status(res.stat.stat);
911 }
912
913 if (!error && !reclaim) {
914 nlm_record_lock(vp, op, fl, args.alock.svid,
915 nlm_host_get_sysid(host), size);
916 nlm_host_monitor(host, 0);
917 }
918
919 return (error);
920 }
921 }
922
923 static int
924 nlm_clearlock(struct nlm_host *host, struct rpc_callextra *ext,
925 rpcvers_t vers, struct timeval *timo, int retries,
926 struct vnode *vp, int op, struct flock *fl, int flags,
927 int svid, size_t fhlen, void *fh, off_t size)
928 {
929 struct nlm4_unlockargs args;
930 char oh_space[32];
931 struct nlm4_res res;
932 u_int xid;
933 CLIENT *client;
934 enum clnt_stat stat;
935 int error;
936
937 memset(&args, 0, sizeof(args));
938 memset(&res, 0, sizeof(res));
939
940 error = nlm_init_lock(fl, flags, svid, vers, fhlen, fh, size,
941 &args.alock, oh_space);
942 if (error)
943 return (error);
944
945 for (;;) {
946 client = nlm_host_get_rpc(host, FALSE);
947 if (!client)
948 return (ENOLCK); /* XXX retry? */
949
950 xid = atomic_fetchadd_int(&nlm_xid, 1);
951 args.cookie.n_len = sizeof(xid);
952 args.cookie.n_bytes = (char*) &xid;
953
954 stat = nlm_unlock_rpc(vers, &args, &res, client, ext, *timo);
955
956 CLNT_RELEASE(client);
957
958 if (stat != RPC_SUCCESS) {
959 if (retries) {
|