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