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 /*
29 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
30 * Copyright (c) 2012 by Delphix. All rights reserved.
31 */
32
33 /*
34 * NFS Lock Manager service functions (nlm_do_...)
35 * Called from nlm_rpc_svc.c wrappers.
36 *
37 * Source code derived from FreeBSD nlm_prot_impl.c
38 */
39
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/thread.h>
43 #include <sys/fcntl.h>
44 #include <sys/flock.h>
45 #include <sys/mount.h>
46 #include <sys/priv.h>
47 #include <sys/proc.h>
48 #include <sys/share.h>
49 #include <sys/socket.h>
50 #include <sys/syscall.h>
51 #include <sys/syslog.h>
52 #include <sys/systm.h>
53 #include <sys/taskq.h>
54 #include <sys/unistd.h>
55 #include <sys/vnode.h>
56 #include <sys/vfs.h>
57 #include <sys/queue.h>
58 #include <sys/sdt.h>
59 #include <netinet/in.h>
60
61 #include <rpc/rpc.h>
62 #include <rpc/xdr.h>
63 #include <rpc/pmap_prot.h>
64 #include <rpc/pmap_clnt.h>
65 #include <rpc/rpcb_prot.h>
66
67 #include <rpcsvc/nlm_prot.h>
68 #include <rpcsvc/sm_inter.h>
69
70 #include <nfs/nfs.h>
71 #include <nfs/nfs_clnt.h>
72 #include <nfs/export.h>
73 #include <nfs/rnode.h>
74
75 #include "nlm_impl.h"
76
77 #define NLM_IN_GRACE(g) (ddi_get_lbolt() < (g)->grace_threshold)
78
79 struct nlm_block_cb_data {
80 struct nlm_host *hostp;
81 struct nlm_vhold *nvp;
82 struct flock64 *flp;
83 };
84
85 /*
86 * Invoke an asyncronous RPC callbeck
87 * (used when NLM server needs to reply to MSG NLM procedure).
88 */
89 #define NLM_INVOKE_CALLBACK(descr, rpcp, resp, callb) \
90 do { \
91 enum clnt_stat _stat; \
92 \
93 _stat = (*(callb))(resp, NULL, (rpcp)->nr_handle); \
94 if (_stat != RPC_SUCCESS && _stat != RPC_TIMEDOUT) { \
95 struct rpc_err _err; \
96 \
97 CLNT_GETERR((rpcp)->nr_handle, &_err); \
98 NLM_ERR("NLM: %s callback failed: " \
99 "stat %d, err %d\n", descr, _stat, \
100 _err.re_errno); \
101 } \
102 \
103 _NOTE(CONSTCOND) } while (0)
104
105 static void nlm_block(
106 nlm4_lockargs *lockargs,
107 struct nlm_host *host,
108 struct nlm_vhold *nvp,
109 nlm_rpc_t *rpcp,
110 struct flock64 *fl,
111 nlm_testargs_cb grant_cb);
112
113 static vnode_t *nlm_fh_to_vp(struct netobj *);
114 static struct nlm_vhold *nlm_fh_to_vhold(struct nlm_host *, struct netobj *);
115 static void nlm_init_shrlock(struct shrlock *, nlm4_share *, struct nlm_host *);
116 static callb_cpr_t *nlm_block_callback(flk_cb_when_t, void *);
117 static int nlm_vop_frlock(vnode_t *, int, flock64_t *, int, offset_t,
118 struct flk_callback *, cred_t *, caller_context_t *);
119
120 /*
121 * Convert a lock from network to local form, and
122 * check for valid range (no overflow).
123 */
124 static int
125 nlm_init_flock(struct flock64 *fl, struct nlm4_lock *nl,
126 struct nlm_host *host, rpcvers_t vers, short type)
127 {
128 uint64_t off, len;
129
130 bzero(fl, sizeof (*fl));
131 off = nl->l_offset;
132 len = nl->l_len;
133
134 if (vers < NLM4_VERS) {
135 if (off > MAX_UOFF32 || len > MAX_UOFF32)
136 return (EINVAL);
137 if (off + len > MAX_UOFF32 + 1)
138 return (EINVAL);
139 } else {
140 /*
141 * Check range for 64-bit client (no overflow).
142 * Again allow len == ~0 to mean lock to EOF.
143 */
144 if (len == MAX_U_OFFSET_T)
145 len = 0;
146 if (len != 0 && off + (len - 1) < off)
147 return (EINVAL);
148 }
149
150 fl->l_type = type;
151 fl->l_whence = SEEK_SET;
152 fl->l_start = off;
153 fl->l_len = len;
154 fl->l_sysid = host->nh_sysid;
155 fl->l_pid = nl->svid;
156 /* l_pad */
157
158 return (0);
159 }
160
161 /*
162 * Gets vnode from client's filehandle
163 * NOTE: Holds vnode, it _must_ be explicitly
164 * released by VN_RELE().
165 */
166 static vnode_t *
167 nlm_fh_to_vp(struct netobj *fh)
168 {
169 fhandle_t *fhp;
170
171 /*
172 * Get a vnode pointer for the given NFS file handle.
173 * Note that it could be an NFSv2 for NFSv3 handle,
174 * which means the size might vary. (don't copy)
175 */
176 if (fh->n_len < sizeof (*fhp))
177 return (NULL);
178
179 /* We know this is aligned (kmem_alloc) */
180 /* LINTED E_BAD_PTR_CAST_ALIGN */
181 fhp = (fhandle_t *)fh->n_bytes;
182 return (lm_fhtovp(fhp));
183 }
184
185 /*
186 * Get vhold from client's filehandle, but in contrast to
187 * The function tries to check some access rights as well.
188 *
189 * NOTE: vhold object _must_ be explicitly released by
190 * nlm_vhold_release().
191 */
192 static struct nlm_vhold *
193 nlm_fh_to_vhold(struct nlm_host *hostp, struct netobj *fh)
194 {
195 vnode_t *vp;
196 struct nlm_vhold *nvp;
197
198 vp = nlm_fh_to_vp(fh);
199 if (vp == NULL)
200 return (NULL);
201
202
203 nvp = nlm_vhold_get(hostp, vp);
204
205 /*
206 * Both nlm_fh_to_vp() and nlm_vhold_get()
207 * do VN_HOLD(), so we need to drop one
208 * reference on vnode.
209 */
210 VN_RELE(vp);
211 return (nvp);
212 }
213
214 /* ******************************************************************* */
215
216 /*
217 * NLM implementation details, called from the RPC svc code.
218 */
219
220 /*
221 * Call-back from NFS statd, used to notify that one of our
222 * hosts had a status change. The host can be either an
223 * NFS client, NFS server or both.
224 * According to NSM protocol description, the state is a
225 * number that is increases monotonically each time the
226 * state of host changes. An even number indicates that
227 * the host is down, while an odd number indicates that
228 * the host is up.
229 *
230 * Here we ignore this even/odd difference of status number
231 * reported by the NSM, we launch notification handlers
232 * every time the state is changed. The reason we why do so
233 * is that client and server can talk to each other using
234 * connectionless transport and it's easy to lose packet
235 * containing NSM notification with status number update.
236 *
237 * In nlm_host_monitor(), we put the sysid in the private data
238 * that statd carries in this callback, so we can easliy find
239 * the host this call applies to.
240 */
241 /* ARGSUSED */
242 void
243 nlm_do_notify1(nlm_sm_status *argp, void *res, struct svc_req *sr)
244 {
245 struct nlm_globals *g;
246 struct nlm_host *host;
247 uint16_t sysid;
248
249 g = zone_getspecific(nlm_zone_key, curzone);
250 bcopy(&argp->priv, &sysid, sizeof (sysid));
251
252 DTRACE_PROBE2(nsm__notify, uint16_t, sysid,
253 int, argp->state);
254
255 host = nlm_host_find_by_sysid(g, (sysid_t)sysid);
256 if (host == NULL)
257 return;
258
259 nlm_host_notify_server(host, argp->state);
260 nlm_host_notify_client(host, argp->state);
261 nlm_host_release(g, host);
262 }
263
264 /*
265 * Another available call-back for NFS statd.
266 * Not currently used.
267 */
268 /* ARGSUSED */
269 void
270 nlm_do_notify2(nlm_sm_status *argp, void *res, struct svc_req *sr)
271 {
272 ASSERT(0);
273 }
274
275
276 /*
277 * NLM_TEST, NLM_TEST_MSG,
278 * NLM4_TEST, NLM4_TEST_MSG,
279 * Client inquiry about locks, non-blocking.
280 */
281 void
282 nlm_do_test(nlm4_testargs *argp, nlm4_testres *resp,
283 struct svc_req *sr, nlm_testres_cb cb)
284 {
285 struct nlm_globals *g;
286 struct nlm_host *host;
287 struct nlm4_holder *lh;
288 struct nlm_owner_handle *oh;
289 nlm_rpc_t *rpcp = NULL;
290 vnode_t *vp = NULL;
291 struct netbuf *addr;
292 char *netid;
293 char *name;
294 int error;
295 struct flock64 fl;
296
297 nlm_copy_netobj(&resp->cookie, &argp->cookie);
298
299 name = argp->alock.caller_name;
300 netid = svc_getnetid(sr->rq_xprt);
301 addr = svc_getrpccaller(sr->rq_xprt);
302
303 g = zone_getspecific(nlm_zone_key, curzone);
304 host = nlm_host_findcreate(g, name, netid, addr);
305 if (host == NULL) {
306 resp->stat.stat = nlm4_denied_nolocks;
307 return;
308 }
309 if (cb != NULL) {
310 error = nlm_host_get_rpc(host, sr->rq_vers, &rpcp);
311 if (error != 0) {
312 resp->stat.stat = nlm4_denied_nolocks;
313 goto out;
314 }
315 }
316
317 vp = nlm_fh_to_vp(&argp->alock.fh);
318 if (vp == NULL) {
319 resp->stat.stat = nlm4_stale_fh;
320 goto out;
321 }
322
323 if (NLM_IN_GRACE(g)) {
324 resp->stat.stat = nlm4_denied_grace_period;
325 goto out;
326 }
327
328 /* Convert to local form. */
329 error = nlm_init_flock(&fl, &argp->alock, host, sr->rq_vers,
330 (argp->exclusive) ? F_WRLCK : F_RDLCK);
331 if (error) {
332 resp->stat.stat = nlm4_failed;
333 goto out;
334 }
335
336 /* BSD: VOP_ADVLOCK(nv->nv_vp, NULL, F_GETLK, &fl, F_REMOTE); */
337 error = nlm_vop_frlock(vp, F_GETLK, &fl,
338 F_REMOTELOCK | FREAD | FWRITE,
339 (u_offset_t)0, NULL, CRED(), NULL);
340 if (error) {
341 resp->stat.stat = nlm4_failed;
342 goto out;
343 }
344
345 if (fl.l_type == F_UNLCK) {
346 resp->stat.stat = nlm4_granted;
347 goto out;
348 }
349 resp->stat.stat = nlm4_denied;
350
351 /*
352 * This lock "test" fails due to a conflicting lock.
353 *
354 * If this is a v1 client, make sure the conflicting
355 * lock range we report can be expressed with 32-bit
356 * offsets. The lock range requested was expressed
357 * as 32-bit offset and length, so at least part of
358 * the conflicting lock should lie below MAX_UOFF32.
359 * If the conflicting lock extends past that, we'll
360 * trim the range to end at MAX_UOFF32 so this lock
361 * can be represented in a 32-bit response. Check
362 * the start also (paranoid, but a low cost check).
363 */
364 if (sr->rq_vers < NLM4_VERS) {
365 uint64 maxlen;
366 if (fl.l_start > MAX_UOFF32)
367 fl.l_start = MAX_UOFF32;
368 maxlen = MAX_UOFF32 + 1 - fl.l_start;
369 if (fl.l_len > maxlen)
370 fl.l_len = maxlen;
371 }
372
373 /*
374 * Build the nlm4_holder result structure.
375 *
376 * Note that lh->oh is freed via xdr_free,
377 * xdr_nlm4_holder, xdr_netobj, xdr_bytes.
378 */
379 oh = kmem_zalloc(sizeof (*oh), KM_SLEEP);
380 oh->oh_sysid = (sysid_t)fl.l_sysid;
381 lh = &resp->stat.nlm4_testrply_u.holder;
382 lh->exclusive = (fl.l_type == F_WRLCK);
383 lh->svid = fl.l_pid;
384 lh->oh.n_len = sizeof (*oh);
385 lh->oh.n_bytes = (void *)oh;
386 lh->l_offset = fl.l_start;
387 lh->l_len = fl.l_len;
388
389 out:
390 /*
391 * If we have a callback funtion, use that to
392 * deliver the response via another RPC call.
393 */
394 if (cb != NULL && rpcp != NULL)
395 NLM_INVOKE_CALLBACK("test", rpcp, resp, cb);
396
397 if (vp != NULL)
398 VN_RELE(vp);
399 if (rpcp != NULL)
400 nlm_host_rele_rpc(host, rpcp);
401
402 nlm_host_release(g, host);
403 }
404
405 /*
406 * NLM_LOCK, NLM_LOCK_MSG, NLM_NM_LOCK
407 * NLM4_LOCK, NLM4_LOCK_MSG, NLM4_NM_LOCK
408 *
409 * Client request to set a lock, possibly blocking.
410 *
411 * If the lock needs to block, we return status blocked to
412 * this RPC call, and then later call back the client with
413 * a "granted" callback. Tricky aspects of this include:
414 * sending a reply before this function returns, and then
415 * borrowing this thread from the RPC service pool for the
416 * wait on the lock and doing the later granted callback.
417 *
418 * We also have to keep a list of locks (pending + granted)
419 * both to handle retransmitted requests, and to keep the
420 * vnodes for those locks active.
421 */
422 void
423 nlm_do_lock(nlm4_lockargs *argp, nlm4_res *resp, struct svc_req *sr,
424 nlm_reply_cb reply_cb, nlm_res_cb res_cb, nlm_testargs_cb grant_cb)
425 {
426 struct nlm_globals *g;
427 struct flock64 fl;
428 struct nlm_host *host = NULL;
429 struct netbuf *addr;
430 struct nlm_vhold *nvp = NULL;
431 nlm_rpc_t *rpcp = NULL;
432 char *netid;
433 char *name;
434 int error, flags;
435 bool_t do_blocking = FALSE;
436 bool_t do_mon_req = FALSE;
437 enum nlm4_stats status;
438
439 nlm_copy_netobj(&resp->cookie, &argp->cookie);
440
441 name = argp->alock.caller_name;
442 netid = svc_getnetid(sr->rq_xprt);
443 addr = svc_getrpccaller(sr->rq_xprt);
444
445 g = zone_getspecific(nlm_zone_key, curzone);
446 host = nlm_host_findcreate(g, name, netid, addr);
447 if (host == NULL) {
448 DTRACE_PROBE4(no__host, struct nlm_globals *, g,
449 char *, name, char *, netid, struct netbuf *, addr);
450 status = nlm4_denied_nolocks;
451 goto doreply;
452 }
453
454 DTRACE_PROBE3(start, struct nlm_globals *, g,
455 struct nlm_host *, host, nlm4_lockargs *, argp);
456
457 /*
458 * If we may need to do _msg_ call needing an RPC
459 * callback, get the RPC client handle now,
460 * so we know if we can bind to the NLM service on
461 * this client.
462 *
463 * Note: host object carries transport type.
464 * One client using multiple transports gets
465 * separate sysids for each of its transports.
466 */
467 if (res_cb != NULL || (grant_cb != NULL && argp->block == TRUE)) {
468 error = nlm_host_get_rpc(host, sr->rq_vers, &rpcp);
469 if (error != 0) {
470 status = nlm4_denied_nolocks;
471 goto doreply;
472 }
473 }
474
475 /*
476 * During the "grace period", only allow reclaim.
477 */
478 if (argp->reclaim == 0 && NLM_IN_GRACE(g)) {
479 status = nlm4_denied_grace_period;
480 goto doreply;
481 }
482
483 /*
484 * Check whether we missed host shutdown event
485 */
486 if (nlm_host_get_state(host) != argp->state)
487 nlm_host_notify_server(host, argp->state);
488
489 /*
490 * Get a hold on the vnode for a lock operation.
491 * Only lock() and share() need vhold objects.
492 */
493 nvp = nlm_fh_to_vhold(host, &argp->alock.fh);
494 if (nvp == NULL) {
495 status = nlm4_stale_fh;
496 goto doreply;
497 }
498
499 /* Convert to local form. */
500 error = nlm_init_flock(&fl, &argp->alock, host, sr->rq_vers,
501 (argp->exclusive) ? F_WRLCK : F_RDLCK);
502 if (error) {
503 status = nlm4_failed;
504 goto doreply;
505 }
506
507 /*
508 * Try to lock non-blocking first. If we succeed
509 * getting the lock, we can reply with the granted
510 * status directly and avoid the complications of
511 * making the "granted" RPC callback later.
512 *
513 * This also let's us find out now about some
514 * possible errors like EROFS, etc.
515 */
516 flags = F_REMOTELOCK | FREAD | FWRITE;
517 error = nlm_vop_frlock(nvp->nv_vp, F_SETLK, &fl, flags,
518 (u_offset_t)0, NULL, CRED(), NULL);
519
520 DTRACE_PROBE3(setlk__res, struct flock64 *, &fl,
521 int, flags, int, error);
522
523 switch (error) {
524 case 0:
525 /* Got it without waiting! */
526 status = nlm4_granted;
527 do_mon_req = TRUE;
528 break;
529
530 /* EINPROGRESS too? */
531 case EAGAIN:
532 /* We did not get the lock. Should we block? */
533 if (argp->block == FALSE || grant_cb == NULL) {
534 status = nlm4_denied;
535 break;
536 }
537 /*
538 * Should block. Try to reserve this thread
539 * so we can use it to wait for the lock and
540 * later send the granted message. If this
541 * reservation fails, say "no resources".
542 */
543 if (!svc_reserve_thread(sr->rq_xprt)) {
544 status = nlm4_denied_nolocks;
545 break;
546 }
547 /*
548 * OK, can detach this thread, so this call
549 * will block below (after we reply).
550 */
551 status = nlm4_blocked;
552 do_blocking = TRUE;
553 do_mon_req = TRUE;
554 break;
555
556 case ENOLCK:
557 /* Failed for lack of resources. */
558 status = nlm4_denied_nolocks;
559 break;
560
561 case EROFS:
562 /* read-only file system */
563 status = nlm4_rofs;
564 break;
565
566 case EFBIG:
567 /* file too big */
568 status = nlm4_fbig;
569 break;
570
571 case EDEADLK:
572 /* dead lock condition */
573 status = nlm4_deadlck;
574 break;
575
576 default:
577 status = nlm4_denied;
578 break;
579 }
580
581 doreply:
582 resp->stat.stat = status;
583
584 /*
585 * We get one of two function pointers; one for a
586 * normal RPC reply, and another for doing an RPC
587 * "callback" _res reply for a _msg function.
588 * Use either of those to send the reply now.
589 *
590 * If sending this reply fails, just leave the
591 * lock in the list for retransmitted requests.
592 * Cleanup is via unlock or host rele (statmon).
593 */
594 if (reply_cb != NULL) {
595 /* i.e. nlm_lock_1_reply */
596 if (!(*reply_cb)(sr->rq_xprt, resp))
597 svcerr_systemerr(sr->rq_xprt);
598 }
599 if (res_cb != NULL && rpcp != NULL)
600 NLM_INVOKE_CALLBACK("lock", rpcp, resp, res_cb);
601
602 /*
603 * The reply has been sent to the client.
604 * Start monitoring this client (maybe).
605 *
606 * Note that the non-monitored (NM) calls pass grant_cb=NULL
607 * indicating that the client doesn't support RPC callbacks.
608 * No monitoring for these (lame) clients.
609 */
610 if (do_mon_req && grant_cb != NULL)
611 nlm_host_monitor(g, host, argp->state);
612
613 if (do_blocking) {
614 /*
615 * We need to block on this lock, and when that
616 * completes, do the granted RPC call. Note that
617 * we "reserved" this thread above, so we can now
618 * "detach" it from the RPC SVC pool, allowing it
619 * to block indefinitely if needed.
620 */
621 ASSERT(rpcp != NULL);
622 (void) svc_detach_thread(sr->rq_xprt);
623 nlm_block(argp, host, nvp, rpcp, &fl, grant_cb);
624 }
625
626 DTRACE_PROBE3(lock__end, struct nlm_globals *, g,
627 struct nlm_host *, host, nlm4_res *, resp);
628
629 if (rpcp != NULL)
630 nlm_host_rele_rpc(host, rpcp);
631
632 nlm_vhold_release(host, nvp);
633 nlm_host_release(g, host);
634 }
635
636 /*
637 * Helper for nlm_do_lock(), partly for observability,
638 * (we'll see a call blocked in this function) and
639 * because nlm_do_lock() was getting quite long.
640 */
641 static void
642 nlm_block(nlm4_lockargs *lockargs,
643 struct nlm_host *host,
644 struct nlm_vhold *nvp,
645 nlm_rpc_t *rpcp,
646 struct flock64 *flp,
647 nlm_testargs_cb grant_cb)
648 {
649 nlm4_testargs args;
650 int error;
651 flk_callback_t flk_cb;
652 struct nlm_block_cb_data cb_data;
653
654 /*
655 * Keep a list of blocked locks on nh_pending, and use it
656 * to cancel these threads in nlm_destroy_client_pending.
657 *
658 * Check to see if this lock is already in the list
659 * and if not, add an entry for it. Allocate first,
660 * then if we don't insert, free the new one.
661 * Caller already has vp held.
662 */
663
664 error = nlm_slreq_register(host, nvp, flp);
665 if (error != 0) {
666 /*
667 * Sleeping lock request with given fl is already
668 * registered by someone else. This means that
669 * some other thread is handling the request, let
670 * him to do its work.
671 */
672 ASSERT(error == EEXIST);
673 return;
674 }
675
676 cb_data.hostp = host;
677 cb_data.nvp = nvp;
678 cb_data.flp = flp;
679 flk_init_callback(&flk_cb, nlm_block_callback, &cb_data);
680
681 /* BSD: VOP_ADVLOCK(vp, NULL, F_SETLK, fl, F_REMOTE); */
682 error = nlm_vop_frlock(nvp->nv_vp, F_SETLKW, flp,
683 F_REMOTELOCK | FREAD | FWRITE,
684 (u_offset_t)0, &flk_cb, CRED(), NULL);
685
686 if (error != 0) {
687 /*
688 * We failed getting the lock, but have no way to
689 * tell the client about that. Let 'em time out.
690 */
691 (void) nlm_slreq_unregister(host, nvp, flp);
692 return;
693 }
694
695 /*
696 * Do the "granted" call-back to the client.
697 */
698 args.cookie = lockargs->cookie;
699 args.exclusive = lockargs->exclusive;
700 args.alock = lockargs->alock;
701
702 NLM_INVOKE_CALLBACK("grant", rpcp, &args, grant_cb);
703 }
704
705 /*
706 * The function that is used as flk callback when NLM server
707 * sets new sleeping lock. The function unregisters NLM
708 * sleeping lock request (nlm_slreq) associated with the
709 * sleeping lock _before_ lock becomes active. It prevents
710 * potential race condition between nlm_block() and
711 * nlm_do_cancel().
712 */
713 static callb_cpr_t *
714 nlm_block_callback(flk_cb_when_t when, void *data)
715 {
716 struct nlm_block_cb_data *cb_data;
717
718 cb_data = (struct nlm_block_cb_data *)data;
719 if (when == FLK_AFTER_SLEEP) {
720 (void) nlm_slreq_unregister(cb_data->hostp,
721 cb_data->nvp, cb_data->flp);
722 }
723
724 return (0);
725 }
726
727 /*
728 * NLM_CANCEL, NLM_CANCEL_MSG,
729 * NLM4_CANCEL, NLM4_CANCEL_MSG,
730 * Client gives up waiting for a blocking lock.
731 */
732 void
733 nlm_do_cancel(nlm4_cancargs *argp, nlm4_res *resp,
734 struct svc_req *sr, nlm_res_cb cb)
735 {
736 struct nlm_globals *g;
737 struct nlm_host *host;
738 struct netbuf *addr;
739 struct nlm_vhold *nvp = NULL;
740 nlm_rpc_t *rpcp = NULL;
741 char *netid;
742 char *name;
743 int error;
744 struct flock64 fl;
745
746 nlm_copy_netobj(&resp->cookie, &argp->cookie);
747 netid = svc_getnetid(sr->rq_xprt);
748 addr = svc_getrpccaller(sr->rq_xprt);
749 name = argp->alock.caller_name;
750
751 g = zone_getspecific(nlm_zone_key, curzone);
752 host = nlm_host_findcreate(g, name, netid, addr);
753 if (host == NULL) {
754 resp->stat.stat = nlm4_denied_nolocks;
755 return;
756 }
757 if (cb != NULL) {
758 error = nlm_host_get_rpc(host, sr->rq_vers, &rpcp);
759 if (error != 0) {
760 resp->stat.stat = nlm4_denied_nolocks;
761 return;
762 }
763 }
764
765 DTRACE_PROBE3(start, struct nlm_globals *, g,
766 struct nlm_host *, host, nlm4_cancargs *, argp);
767
768 if (NLM_IN_GRACE(g)) {
769 resp->stat.stat = nlm4_denied_grace_period;
770 goto out;
771 }
772
773 nvp = nlm_fh_to_vhold(host, &argp->alock.fh);
774 if (nvp == NULL) {
775 resp->stat.stat = nlm4_stale_fh;
776 goto out;
777 }
778
779 /* Convert to local form. */
780 error = nlm_init_flock(&fl, &argp->alock, host, sr->rq_vers,
781 (argp->exclusive) ? F_WRLCK : F_RDLCK);
782 if (error) {
783 resp->stat.stat = nlm4_failed;
784 goto out;
785 }
786
787 error = nlm_slreq_unregister(host, nvp, &fl);
788 if (error != 0) {
789 /*
790 * There's no sleeping lock request corresponding
791 * to the lock. Then requested sleeping lock
792 * doesn't exist.
793 */
794 resp->stat.stat = nlm4_denied;
795 goto out;
796 }
797
798 fl.l_type = F_UNLCK;
799 error = nlm_vop_frlock(nvp->nv_vp, F_SETLK, &fl,
800 F_REMOTELOCK | FREAD | FWRITE,
801 (u_offset_t)0, NULL, CRED(), NULL);
802
803 resp->stat.stat = (error == 0) ?
804 nlm4_granted : nlm4_denied;
805
806 out:
807 /*
808 * If we have a callback funtion, use that to
809 * deliver the response via another RPC call.
810 */
811 if (cb != NULL && rpcp != NULL)
812 NLM_INVOKE_CALLBACK("cancel", rpcp, resp, cb);
813
814 DTRACE_PROBE3(cancel__end, struct nlm_globals *, g,
815 struct nlm_host *, host, nlm4_res *, resp);
816
817 if (rpcp != NULL)
818 nlm_host_rele_rpc(host, rpcp);
819
820 nlm_vhold_release(host, nvp);
821 nlm_host_release(g, host);
822 }
823
824 /*
825 * NLM_UNLOCK, NLM_UNLOCK_MSG,
826 * NLM4_UNLOCK, NLM4_UNLOCK_MSG,
827 * Client removes one of their locks.
828 */
829 void
830 nlm_do_unlock(nlm4_unlockargs *argp, nlm4_res *resp,
831 struct svc_req *sr, nlm_res_cb cb)
832 {
833 struct nlm_globals *g;
834 struct nlm_host *host;
835 struct netbuf *addr;
836 nlm_rpc_t *rpcp = NULL;
837 vnode_t *vp = NULL;
838 char *netid;
839 char *name;
840 int error;
841 struct flock64 fl;
842
843 nlm_copy_netobj(&resp->cookie, &argp->cookie);
844
845 netid = svc_getnetid(sr->rq_xprt);
846 addr = svc_getrpccaller(sr->rq_xprt);
847 name = argp->alock.caller_name;
848
849 /*
850 * NLM_UNLOCK operation doesn't have an error code
851 * denoting that operation failed, so we always
852 * return nlm4_granted except when the server is
853 * in a grace period.
854 */
855 resp->stat.stat = nlm4_granted;
856
857 g = zone_getspecific(nlm_zone_key, curzone);
858 host = nlm_host_findcreate(g, name, netid, addr);
859 if (host == NULL)
860 return;
861
862 if (cb != NULL) {
863 error = nlm_host_get_rpc(host, sr->rq_vers, &rpcp);
864 if (error != 0)
865 goto out;
866 }
867
868 DTRACE_PROBE3(start, struct nlm_globals *, g,
869 struct nlm_host *, host, nlm4_unlockargs *, argp);
870
871 if (NLM_IN_GRACE(g)) {
872 resp->stat.stat = nlm4_denied_grace_period;
873 goto out;
874 }
875
876 vp = nlm_fh_to_vp(&argp->alock.fh);
877 if (vp == NULL)
878 goto out;
879
880 /* Convert to local form. */
881 error = nlm_init_flock(&fl, &argp->alock, host, sr->rq_vers, F_UNLCK);
882 if (error)
883 goto out;
884
885 /* BSD: VOP_ADVLOCK(nv->nv_vp, NULL, F_UNLCK, &fl, F_REMOTE); */
886 error = nlm_vop_frlock(vp, F_SETLK, &fl,
887 F_REMOTELOCK | FREAD | FWRITE,
888 (u_offset_t)0, NULL, CRED(), NULL);
889
890 DTRACE_PROBE1(unlock__res, int, error);
891 out:
892 /*
893 * If we have a callback funtion, use that to
894 * deliver the response via another RPC call.
895 */
896 if (cb != NULL && rpcp != NULL)
897 NLM_INVOKE_CALLBACK("unlock", rpcp, resp, cb);
898
899 DTRACE_PROBE3(unlock__end, struct nlm_globals *, g,
900 struct nlm_host *, host, nlm4_res *, resp);
901
902 if (vp != NULL)
903 VN_RELE(vp);
904 if (rpcp != NULL)
905 nlm_host_rele_rpc(host, rpcp);
906
907 nlm_host_release(g, host);
908 }
909
910 /*
911 * NLM_GRANTED, NLM_GRANTED_MSG,
912 * NLM4_GRANTED, NLM4_GRANTED_MSG,
913 *
914 * This service routine is special. It's the only one that's
915 * really part of our NLM _client_ support, used by _servers_
916 * to "call back" when a blocking lock from this NLM client
917 * is granted by the server. In this case, we _know_ there is
918 * already an nlm_host allocated and held by the client code.
919 * We want to find that nlm_host here.
920 *
921 * Over in nlm_call_lock(), the client encoded the sysid for this
922 * server in the "owner handle" netbuf sent with our lock request.
923 * We can now use that to find the nlm_host object we used there.
924 * (NB: The owner handle is opaque to the server.)
925 */
926 void
927 nlm_do_granted(nlm4_testargs *argp, nlm4_res *resp,
928 struct svc_req *sr, nlm_res_cb cb)
929 {
930 struct nlm_globals *g;
931 struct nlm_owner_handle *oh;
932 struct nlm_host *host;
933 nlm_rpc_t *rpcp = NULL;
934 int error;
935
936 nlm_copy_netobj(&resp->cookie, &argp->cookie);
937 resp->stat.stat = nlm4_denied;
938
939 g = zone_getspecific(nlm_zone_key, curzone);
940 oh = (void *) argp->alock.oh.n_bytes;
941 if (oh == NULL)
942 return;
943
944 host = nlm_host_find_by_sysid(g, oh->oh_sysid);
945 if (host == NULL)
946 return;
947
948 if (cb != NULL) {
949 error = nlm_host_get_rpc(host, sr->rq_vers, &rpcp);
950 if (error != 0)
951 goto out;
952 }
953
954 if (NLM_IN_GRACE(g)) {
955 resp->stat.stat = nlm4_denied_grace_period;
956 goto out;
957 }
958
959 error = nlm_slock_grant(g, host, &argp->alock);
960 if (error == 0)
961 resp->stat.stat = nlm4_granted;
962
963 out:
964 /*
965 * If we have a callback funtion, use that to
966 * deliver the response via another RPC call.
967 */
968 if (cb != NULL && rpcp != NULL)
969 NLM_INVOKE_CALLBACK("do_granted", rpcp, resp, cb);
970
971 if (rpcp != NULL)
972 nlm_host_rele_rpc(host, rpcp);
973
974 nlm_host_release(g, host);
975 }
976
977 /*
978 * NLM_FREE_ALL, NLM4_FREE_ALL
979 *
980 * Destroy all lock state for the calling client.
981 */
982 void
983 nlm_do_free_all(nlm4_notify *argp, void *res, struct svc_req *sr)
984 {
985 struct nlm_globals *g;
986 struct nlm_host_list host_list;
987 struct nlm_host *hostp;
988
989 TAILQ_INIT(&host_list);
990 g = zone_getspecific(nlm_zone_key, curzone);
991
992 /* Serialize calls to clean locks. */
993 mutex_enter(&g->clean_lock);
994
995 /*
996 * Find all hosts that have the given node name and put them on a
997 * local list.
998 */
999 mutex_enter(&g->lock);
1000 for (hostp = avl_first(&g->nlm_hosts_tree); hostp != NULL;
1001 hostp = AVL_NEXT(&g->nlm_hosts_tree, hostp)) {
1002 if (strcasecmp(hostp->nh_name, argp->name) == 0) {
1003 /*
1004 * If needed take the host out of the idle list since
1005 * we are taking a reference.
1006 */
1007 if (hostp->nh_flags & NLM_NH_INIDLE) {
1008 TAILQ_REMOVE(&g->nlm_idle_hosts, hostp,
1009 nh_link);
1010 hostp->nh_flags &= ~NLM_NH_INIDLE;
1011 }
1012 hostp->nh_refs++;
1013
1014 TAILQ_INSERT_TAIL(&host_list, hostp, nh_link);
1015 }
1016 }
1017 mutex_exit(&g->lock);
1018
1019 /* Free locks for all hosts on the local list. */
1020 while (!TAILQ_EMPTY(&host_list)) {
1021 hostp = TAILQ_FIRST(&host_list);
1022 TAILQ_REMOVE(&host_list, hostp, nh_link);
1023
1024 /*
1025 * Note that this does not do client-side cleanup.
1026 * We want to do that ONLY if statd tells us the
1027 * server has restarted.
1028 */
1029 nlm_host_notify_server(hostp, argp->state);
1030 nlm_host_release(g, hostp);
1031 }
1032
1033 mutex_exit(&g->clean_lock);
1034
1035 (void) res;
1036 (void) sr;
1037 }
1038
1039 static void
1040 nlm_init_shrlock(struct shrlock *shr,
1041 nlm4_share *nshare, struct nlm_host *host)
1042 {
1043
1044 switch (nshare->access) {
1045 default:
1046 case fsa_NONE:
1047 shr->s_access = 0;
1048 break;
1049 case fsa_R:
1050 shr->s_access = F_RDACC;
1051 break;
1052 case fsa_W:
1053 shr->s_access = F_WRACC;
1054 break;
1055 case fsa_RW:
1056 shr->s_access = F_RWACC;
1057 break;
1058 }
1059
1060 switch (nshare->mode) {
1061 default:
1062 case fsm_DN:
1063 shr->s_deny = F_NODNY;
1064 break;
1065 case fsm_DR:
1066 shr->s_deny = F_RDDNY;
1067 break;
1068 case fsm_DW:
1069 shr->s_deny = F_WRDNY;
1070 break;
1071 case fsm_DRW:
1072 shr->s_deny = F_RWDNY;
1073 break;
1074 }
1075
1076 shr->s_sysid = host->nh_sysid;
1077 shr->s_pid = 0;
1078 shr->s_own_len = nshare->oh.n_len;
1079 shr->s_owner = nshare->oh.n_bytes;
1080 }
1081
1082 /*
1083 * NLM_SHARE, NLM4_SHARE
1084 *
1085 * Request a DOS-style share reservation
1086 */
1087 void
1088 nlm_do_share(nlm4_shareargs *argp, nlm4_shareres *resp, struct svc_req *sr)
1089 {
1090 struct nlm_globals *g;
1091 struct nlm_host *host;
1092 struct netbuf *addr;
1093 struct nlm_vhold *nvp = NULL;
1094 char *netid;
1095 char *name;
1096 int error;
1097 struct shrlock shr;
1098
1099 nlm_copy_netobj(&resp->cookie, &argp->cookie);
1100
1101 name = argp->share.caller_name;
1102 netid = svc_getnetid(sr->rq_xprt);
1103 addr = svc_getrpccaller(sr->rq_xprt);
1104
1105 g = zone_getspecific(nlm_zone_key, curzone);
1106 host = nlm_host_findcreate(g, name, netid, addr);
1107 if (host == NULL) {
1108 resp->stat = nlm4_denied_nolocks;
1109 return;
1110 }
1111
1112 DTRACE_PROBE3(share__start, struct nlm_globals *, g,
1113 struct nlm_host *, host, nlm4_shareargs *, argp);
1114
1115 if (argp->reclaim == 0 && NLM_IN_GRACE(g)) {
1116 resp->stat = nlm4_denied_grace_period;
1117 goto out;
1118 }
1119
1120 /*
1121 * Get holded vnode when on lock operation.
1122 * Only lock() and share() need vhold objects.
1123 */
1124 nvp = nlm_fh_to_vhold(host, &argp->share.fh);
1125 if (nvp == NULL) {
1126 resp->stat = nlm4_stale_fh;
1127 goto out;
1128 }
1129
1130 /* Convert to local form. */
1131 nlm_init_shrlock(&shr, &argp->share, host);
1132 error = VOP_SHRLOCK(nvp->nv_vp, F_SHARE, &shr,
1133 FREAD | FWRITE, CRED(), NULL);
1134
1135 if (error == 0) {
1136 resp->stat = nlm4_granted;
1137 nlm_host_monitor(g, host, 0);
1138 } else {
1139 resp->stat = nlm4_denied;
1140 }
1141
1142 out:
1143 DTRACE_PROBE3(share__end, struct nlm_globals *, g,
1144 struct nlm_host *, host, nlm4_shareres *, resp);
1145
1146 nlm_vhold_release(host, nvp);
1147 nlm_host_release(g, host);
1148 }
1149
1150 /*
1151 * NLM_UNSHARE, NLM4_UNSHARE
1152 *
1153 * Release a DOS-style share reservation
1154 */
1155 void
1156 nlm_do_unshare(nlm4_shareargs *argp, nlm4_shareres *resp, struct svc_req *sr)
1157 {
1158 struct nlm_globals *g;
1159 struct nlm_host *host;
1160 struct netbuf *addr;
1161 vnode_t *vp = NULL;
1162 char *netid;
1163 int error;
1164 struct shrlock shr;
1165
1166 nlm_copy_netobj(&resp->cookie, &argp->cookie);
1167
1168 netid = svc_getnetid(sr->rq_xprt);
1169 addr = svc_getrpccaller(sr->rq_xprt);
1170
1171 g = zone_getspecific(nlm_zone_key, curzone);
1172 host = nlm_host_find(g, netid, addr);
1173 if (host == NULL) {
1174 resp->stat = nlm4_denied_nolocks;
1175 return;
1176 }
1177
1178 DTRACE_PROBE3(unshare__start, struct nlm_globals *, g,
1179 struct nlm_host *, host, nlm4_shareargs *, argp);
1180
1181 if (NLM_IN_GRACE(g)) {
1182 resp->stat = nlm4_denied_grace_period;
1183 goto out;
1184 }
1185
1186 vp = nlm_fh_to_vp(&argp->share.fh);
1187 if (vp == NULL) {
1188 resp->stat = nlm4_stale_fh;
1189 goto out;
1190 }
1191
1192 /* Convert to local form. */
1193 nlm_init_shrlock(&shr, &argp->share, host);
1194 error = VOP_SHRLOCK(vp, F_UNSHARE, &shr,
1195 FREAD | FWRITE, CRED(), NULL);
1196
1197 (void) error;
1198 resp->stat = nlm4_granted;
1199
1200 out:
1201 DTRACE_PROBE3(unshare__end, struct nlm_globals *, g,
1202 struct nlm_host *, host, nlm4_shareres *, resp);
1203
1204 if (vp != NULL)
1205 VN_RELE(vp);
1206
1207 nlm_host_release(g, host);
1208 }
1209
1210 /*
1211 * NLM wrapper to VOP_FRLOCK that checks the validity of the lock before
1212 * invoking the vnode operation.
1213 */
1214 static int
1215 nlm_vop_frlock(vnode_t *vp, int cmd, flock64_t *bfp, int flag, offset_t offset,
1216 struct flk_callback *flk_cbp, cred_t *cr, caller_context_t *ct)
1217 {
1218 if (bfp->l_len != 0 && bfp->l_start + (bfp->l_len - 1) < bfp->l_start) {
1219 return (EOVERFLOW);
1220 }
1221
1222 return (VOP_FRLOCK(vp, cmd, bfp, flag, offset, flk_cbp, cr, ct));
1223 }