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