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