usr/src/uts/common/klm/nlm_rpc_svc.c

   1 /*
   2  * Copyright (c) 2008 Isilon Inc http://www.isilon.com/
   3  * Authors: Doug Rabson <dfr@rabson.org>
   4  * Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 /*
  29  * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
  30  * Copyright (c) 2012 by Delphix. All rights reserved.
  31  */
  32
  33 /*
  34  * NFS Lock Manager, RPC service functions (nlm_..._svc)
  35  * Called via nlm_dispatch.c tables.
  36  *
  37  * Source code derived from FreeBSD nlm_prot_server.c
  38  *
  39  * The real service functions all use nlm4_... args and return
  40  * data types.  These wrappers convert older forms to and from
  41  * the new forms and call the nlm_do_... service functions.
  42  */
  43
  44 #include <sys/param.h>
  45 #include <sys/systm.h>
  46
  47 #include <rpcsvc/nlm_prot.h>
  48 #include "nlm_impl.h"
  49
  50 /*
  51  * Convert between various versions of the protocol structures.
  52  */
  53
  54 /*
  55  * Down-convert, for granted_1 call
  56  *
  57  * This converts a 64-bit lock to 32-bit form for our granted
  58  * call-back when we're dealing with a 32-bit NLM client.
  59  * Our NLM_LOCK handler ensures that any lock we grant to a
  60  * 32-bit client can be represented in 32-bits.  If the
  61  * ASSERTs here fire, then the call to nlm_init_flock in
  62  * nlm_do_lock has failed to restrict a 32-bit client to
  63  * 32-bit lock ranges.
  64  */
  65 static void
  66 nlm_convert_to_nlm_lock(struct nlm_lock *dst, struct nlm4_lock *src)
  67 {
  68         dst->caller_name = src->caller_name;
  69         dst->fh = src->fh;
  70         dst->oh = src->oh;
  71         dst->svid = src->svid;
  72         ASSERT(src->l_offset <= MAX_UOFF32);
  73         dst->l_offset = (uint32_t)src->l_offset;
  74         ASSERT(src->l_len <= MAX_UOFF32);
  75         dst->l_len = (uint32_t)src->l_len;
  76 }
  77
  78 /*
  79  * Up-convert for v1 svc functions with a 32-bit lock range arg.
  80  * Note that lock range checks (like overflow) are done later,
  81  * in nlm_init_flock().
  82  */
  83 static void
  84 nlm_convert_to_nlm4_lock(struct nlm4_lock *dst, struct nlm_lock *src)
  85 {
  86
  87         dst->caller_name = src->caller_name;
  88         dst->fh = src->fh;
  89         dst->oh = src->oh;
  90         dst->svid = src->svid;
  91         dst->l_offset = src->l_offset;
  92         dst->l_len = src->l_len;
  93 }
  94
  95 static void
  96 nlm_convert_to_nlm4_share(struct nlm4_share *dst, struct nlm_share *src)
  97 {
  98
  99         dst->caller_name = src->caller_name;
 100         dst->fh = src->fh;
 101         dst->oh = src->oh;
 102         dst->mode = src->mode;
 103         dst->access = src->access;
 104 }
 105
 106 /*
 107  * Down-convert for v1 NLM_TEST or NLM_TEST_MSG response.
 108  * Note that nlm_do_test is careful to give us lock ranges
 109  * that can be represented with 32-bit values.  If the
 110  * ASSERTs here fire, then the code in nlm_do_test that
 111  * builds an nlm4_holder for a 32-bit client has failed to
 112  * restrict the reported conflicting lock range so it's a
 113  * valid 32-bit lock range.
 114  */
 115 static void
 116 nlm_convert_to_nlm_holder(struct nlm_holder *dst, struct nlm4_holder *src)
 117 {
 118         dst->exclusive = src->exclusive;
 119         dst->svid = src->svid;
 120         dst->oh = src->oh;
 121         ASSERT(src->l_offset <= MAX_UOFF32);
 122         dst->l_offset = (uint32_t)src->l_offset;
 123         ASSERT(src->l_len <= MAX_UOFF32);
 124         dst->l_len = (uint32_t)src->l_len;
 125 }
 126
 127 static enum nlm_stats
 128 nlm_convert_to_nlm_stats(enum nlm4_stats src)
 129 {
 130         if (src > nlm4_deadlck)
 131                 return (nlm_denied);
 132         return ((enum nlm_stats)src);
 133 }
 134
 135 static void
 136 nlm_convert_to_nlm_res(struct nlm_res *dst, struct nlm4_res *src)
 137 {
 138         dst->cookie = src->cookie;
 139         dst->stat.stat = nlm_convert_to_nlm_stats(src->stat.stat);
 140 }
 141
 142 /* ******************************************************************** */
 143
 144 /*
 145  * Version 1 svc functions
 146  */
 147
 148 bool_t
 149 nlm_test_1_svc(struct nlm_testargs *argp, nlm_testres *resp,
 150     struct svc_req *sr)
 151 {
 152         nlm4_testargs args4;
 153         nlm4_testres res4;
 154
 155         bzero(&args4, sizeof (args4));
 156         bzero(&res4, sizeof (res4));
 157
 158         args4.cookie = argp->cookie;
 159         args4.exclusive = argp->exclusive;
 160         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 161
 162         nlm_do_test(&args4, &res4, sr, NULL);
 163
 164         resp->cookie = res4.cookie;
 165         resp->stat.stat = nlm_convert_to_nlm_stats(res4.stat.stat);
 166         if (resp->stat.stat == nlm_denied)
 167                 nlm_convert_to_nlm_holder(
 168                     &resp->stat.nlm_testrply_u.holder,
 169                     &res4.stat.nlm4_testrply_u.holder);
 170
 171         return (TRUE);
 172 }
 173
 174 /*
 175  * Callback functions for nlm_lock_1_svc
 176  */
 177 static bool_t nlm_lock_1_reply(SVCXPRT *, nlm4_res *);
 178 static enum clnt_stat nlm_granted_1_cb(nlm4_testargs *, void *, CLIENT *);
 179
 180 bool_t
 181 nlm_lock_1_svc(nlm_lockargs *argp, nlm_res *resp,
 182     struct svc_req *sr)
 183 {
 184         nlm4_lockargs args4;
 185         nlm4_res res4;
 186
 187         bzero(&res4, sizeof (res4));
 188
 189         args4.cookie = argp->cookie;
 190         args4.block = argp->block;
 191         args4.exclusive = argp->exclusive;
 192         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 193         args4.reclaim = argp->reclaim;
 194         args4.state = argp->state;
 195
 196         /* NLM_LOCK */
 197         nlm_do_lock(&args4, &res4, sr,
 198             nlm_lock_1_reply, NULL,
 199             nlm_granted_1_cb);
 200
 201         /* for freeresult */
 202         nlm_convert_to_nlm_res(resp, &res4);
 203
 204         /* above does its own reply */
 205         return (FALSE);
 206 }
 207
 208 static bool_t
 209 nlm_lock_1_reply(SVCXPRT *transp, nlm4_res *resp)
 210 {
 211         nlm_res res1;
 212
 213         nlm_convert_to_nlm_res(&res1, resp);
 214         return (svc_sendreply(transp, xdr_nlm_res, (char *)&res1));
 215 }
 216
 217 static enum clnt_stat
 218 nlm_granted_1_cb(nlm4_testargs *argp, void *resp, CLIENT *clnt)
 219 {
 220         nlm_testargs args1;
 221         nlm_res res1;
 222         int rv;
 223
 224         bzero(&res1, sizeof (res1));
 225
 226         args1.cookie = argp->cookie;
 227         args1.exclusive = argp->exclusive;
 228         nlm_convert_to_nlm_lock(&args1.alock, &argp->alock);
 229
 230         rv = nlm_granted_1(&args1, &res1, clnt);
 231
 232         /* NB: We have a result our caller will not free. */
 233         xdr_free((xdrproc_t)xdr_nlm_res, (void *)&res1);
 234         (void) resp;
 235
 236         return (rv);
 237 }
 238
 239 bool_t
 240 nlm_cancel_1_svc(struct nlm_cancargs *argp, nlm_res *resp,
 241     struct svc_req *sr)
 242 {
 243         nlm4_cancargs args4;
 244         nlm4_res res4;
 245
 246         bzero(&res4, sizeof (res4));
 247
 248         args4.cookie = argp->cookie;
 249         args4.block = argp->block;
 250         args4.exclusive = argp->exclusive;
 251         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 252
 253         nlm_do_cancel(&args4, &res4, sr, NULL);
 254
 255         nlm_convert_to_nlm_res(resp, &res4);
 256
 257         return (TRUE);
 258 }
 259
 260 bool_t
 261 nlm_unlock_1_svc(struct nlm_unlockargs *argp, nlm_res *resp,
 262     struct svc_req *sr)
 263 {
 264         nlm4_unlockargs args4;
 265         nlm4_res res4;
 266
 267         bzero(&res4, sizeof (res4));
 268
 269         args4.cookie = argp->cookie;
 270         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 271
 272         nlm_do_unlock(&args4, &res4, sr, NULL);
 273
 274         nlm_convert_to_nlm_res(resp, &res4);
 275
 276         return (TRUE);
 277 }
 278
 279 bool_t
 280 nlm_granted_1_svc(struct nlm_testargs *argp, nlm_res *resp,
 281     struct svc_req *sr)
 282 {
 283         nlm4_testargs args4;
 284         nlm4_res res4;
 285
 286         bzero(&res4, sizeof (res4));
 287
 288         args4.cookie = argp->cookie;
 289         args4.exclusive = argp->exclusive;
 290         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 291
 292         nlm_do_granted(&args4, &res4, sr, NULL);
 293
 294         nlm_convert_to_nlm_res(resp, &res4);
 295
 296         return (TRUE);
 297 }
 298
 299 /*
 300  * The _msg_ calls get no reply.  Instead, these callers
 301  * expect an RPC call to the corresponding _res function.
 302  * We pass this callback function to nlm_do_test so it will
 303  * use it to do the RPC callback, with the correct res type.
 304  *
 305  * The callback functions have nearly the same arg signature
 306  * as the client call functions so that many of those can be
 307  * optimized to nothing by the compiler.  Also, passing the
 308  * null result arg for these just to reduce warnings.
 309  *
 310  * See similar callbacks for other _msg functions below.
 311  */
 312
 313 static enum clnt_stat nlm_test_res_1_cb(nlm4_testres *, void *, CLIENT *);
 314
 315 bool_t
 316 nlm_test_msg_1_svc(struct nlm_testargs *argp, void *resp,
 317     struct svc_req *sr)
 318 {
 319         nlm4_testargs args4;
 320         nlm4_testres res4;
 321
 322         bzero(&res4, sizeof (res4));
 323
 324         args4.cookie = argp->cookie;
 325         args4.exclusive = argp->exclusive;
 326         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 327
 328         nlm_do_test(&args4, &res4, sr,
 329             nlm_test_res_1_cb);
 330
 331         /* NB: We have a result our caller will not free. */
 332         xdr_free((xdrproc_t)xdr_nlm4_testres, (void *)&res4);
 333         (void) resp;
 334
 335         /* The _msg_ calls get no reply. */
 336         return (FALSE);
 337 }
 338
 339 static enum clnt_stat
 340 nlm_test_res_1_cb(nlm4_testres *res4, void *null, CLIENT *clnt)
 341 {
 342         nlm_testres res1;
 343
 344         res1.cookie = res4->cookie;
 345         res1.stat.stat = nlm_convert_to_nlm_stats(res4->stat.stat);
 346         if (res1.stat.stat == nlm_denied)
 347                 nlm_convert_to_nlm_holder(
 348                     &res1.stat.nlm_testrply_u.holder,
 349                     &res4->stat.nlm4_testrply_u.holder);
 350
 351         return (nlm_test_res_1(&res1, null, clnt));
 352 }
 353
 354 /*
 355  * Callback functions for nlm_lock_msg_1_svc
 356  */
 357 static enum clnt_stat nlm_lock_res_1_cb(nlm4_res *, void *, CLIENT *);
 358 static enum clnt_stat nlm_granted_msg_1_cb(nlm4_testargs *, void *, CLIENT *);
 359
 360 bool_t
 361 nlm_lock_msg_1_svc(nlm_lockargs *argp, void *resp,
 362     struct svc_req *sr)
 363 {
 364         nlm4_lockargs args4;
 365         nlm4_res res4;
 366
 367         bzero(&res4, sizeof (res4));
 368
 369         args4.cookie = argp->cookie;
 370         args4.block = argp->block;
 371         args4.exclusive = argp->exclusive;
 372         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 373         args4.reclaim = argp->reclaim;
 374         args4.state = argp->state;
 375
 376         /* NLM_LOCK_MSG */
 377         nlm_do_lock(&args4, &res4, sr,
 378             NULL, nlm_lock_res_1_cb,
 379             nlm_granted_msg_1_cb);
 380
 381         /* NB: We have a result our caller will not free. */
 382         xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res4);
 383         (void) resp;
 384
 385         /* The _msg_ calls get no reply. */
 386         return (FALSE);
 387 }
 388
 389 static enum clnt_stat
 390 nlm_lock_res_1_cb(nlm4_res *resp, void *null, CLIENT *clnt)
 391 {
 392         nlm_res res1;
 393
 394         nlm_convert_to_nlm_res(&res1, resp);
 395         return (nlm_lock_res_1(&res1, null, clnt));
 396 }
 397
 398 static enum clnt_stat
 399 nlm_granted_msg_1_cb(nlm4_testargs *argp, void *null, CLIENT *clnt)
 400 {
 401         nlm_testargs args1;
 402
 403         args1.cookie = argp->cookie;
 404         args1.exclusive = argp->exclusive;
 405         nlm_convert_to_nlm_lock(&args1.alock, &argp->alock);
 406
 407         return (nlm_granted_msg_1(&args1, null, clnt));
 408
 409 }
 410
 411
 412 static enum clnt_stat nlm_cancel_res_1_cb(nlm4_res *, void *, CLIENT *);
 413
 414 bool_t
 415 nlm_cancel_msg_1_svc(struct nlm_cancargs *argp, void *resp,
 416     struct svc_req *sr)
 417 {
 418         nlm4_cancargs args4;
 419         nlm4_res res4;
 420
 421         bzero(&res4, sizeof (res4));
 422
 423         args4.cookie = argp->cookie;
 424         args4.block = argp->block;
 425         args4.exclusive = argp->exclusive;
 426         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 427
 428         nlm_do_cancel(&args4, &res4, sr,
 429             nlm_cancel_res_1_cb);
 430
 431         /* NB: We have a result our caller will not free. */
 432         xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res4);
 433         (void) resp;
 434
 435         /* The _msg_ calls get no reply. */
 436         return (FALSE);
 437 }
 438
 439 static enum clnt_stat
 440 nlm_cancel_res_1_cb(nlm4_res *res4, void *null, CLIENT *clnt)
 441 {
 442         nlm_res res1;
 443
 444         nlm_convert_to_nlm_res(&res1, res4);
 445         return (nlm_cancel_res_1(&res1, null, clnt));
 446 }
 447
 448
 449 static enum clnt_stat nlm_unlock_res_1_cb(nlm4_res *, void *, CLIENT *);
 450
 451 bool_t
 452 nlm_unlock_msg_1_svc(struct nlm_unlockargs *argp, void *resp,
 453     struct svc_req *sr)
 454 {
 455         nlm4_unlockargs args4;
 456         nlm4_res res4;
 457
 458         bzero(&res4, sizeof (res4));
 459
 460         args4.cookie = argp->cookie;
 461         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 462
 463         nlm_do_unlock(&args4, &res4, sr,
 464             nlm_unlock_res_1_cb);
 465
 466         /* NB: We have a result our caller will not free. */
 467         xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res4);
 468         (void) resp;
 469
 470         /* The _msg_ calls get no reply. */
 471         return (FALSE);
 472 }
 473
 474 static enum clnt_stat
 475 nlm_unlock_res_1_cb(nlm4_res *res4, void *null, CLIENT *clnt)
 476 {
 477         nlm_res res1;
 478
 479         nlm_convert_to_nlm_res(&res1, res4);
 480         return (nlm_unlock_res_1(&res1, null, clnt));
 481 }
 482
 483
 484 static enum clnt_stat nlm_granted_res_1_cb(nlm4_res *, void *, CLIENT *);
 485
 486 bool_t
 487 nlm_granted_msg_1_svc(struct nlm_testargs *argp, void *resp,
 488     struct svc_req *sr)
 489 {
 490         nlm4_testargs args4;
 491         nlm4_res res4;
 492
 493         bzero(&res4, sizeof (res4));
 494
 495         args4.cookie = argp->cookie;
 496         args4.exclusive = argp->exclusive;
 497         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 498
 499         nlm_do_granted(&args4, &res4, sr,
 500             nlm_granted_res_1_cb);
 501
 502         /* NB: We have a result our caller will not free. */
 503         xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res4);
 504         (void) resp;
 505
 506         /* The _msg_ calls get no reply. */
 507         return (FALSE);
 508 }
 509
 510 static enum clnt_stat
 511 nlm_granted_res_1_cb(nlm4_res *res4, void *null, CLIENT *clnt)
 512 {
 513         nlm_res res1;
 514
 515         nlm_convert_to_nlm_res(&res1, res4);
 516         return (nlm_granted_res_1(&res1, null, clnt));
 517 }
 518
 519 /*
 520  * The _res_ calls get no reply.  These RPC calls are
 521  * "call backs" in response to RPC _msg_ calls.
 522  * We don't care about these responses.
 523  */
 524
 525 /* ARGSUSED */
 526 bool_t
 527 nlm_test_res_1_svc(nlm_testres *argp, void *resp, struct svc_req *sr)
 528 {
 529         /* The _res_ calls get no reply. */
 530         return (FALSE);
 531 }
 532
 533 /* ARGSUSED */
 534 bool_t
 535 nlm_lock_res_1_svc(nlm_res *argp, void *resp, struct svc_req *sr)
 536 {
 537         /* The _res_ calls get no reply. */
 538         return (FALSE);
 539 }
 540
 541 /* ARGSUSED */
 542 bool_t
 543 nlm_cancel_res_1_svc(nlm_res *argp, void *resp, struct svc_req *sr)
 544 {
 545         /* The _res_ calls get no reply. */
 546         return (FALSE);
 547 }
 548
 549 /* ARGSUSED */
 550 bool_t
 551 nlm_unlock_res_1_svc(nlm_res *argp, void *resp, struct svc_req *sr)
 552 {
 553         /* The _res_ calls get no reply. */
 554         return (FALSE);
 555 }
 556
 557 /* ARGSUSED */
 558 bool_t
 559 nlm_granted_res_1_svc(nlm_res *argp, void *resp, struct svc_req *sr)
 560 {
 561         /* The _res_ calls get no reply. */
 562         return (FALSE);
 563 }
 564
 565 /*
 566  * Version 2 svc functions (used by local statd)
 567  */
 568
 569 bool_t
 570 nlm_sm_notify1_2_svc(struct nlm_sm_status *argp, void *resp,
 571     struct svc_req *sr)
 572 {
 573         nlm_do_notify1(argp, resp, sr);
 574         return (TRUE);
 575 }
 576
 577 bool_t
 578 nlm_sm_notify2_2_svc(struct nlm_sm_status *argp, void *resp,
 579     struct svc_req *sr)
 580 {
 581         nlm_do_notify2(argp, resp, sr);
 582         return (TRUE);
 583 }
 584
 585 /*
 586  * Version 3 svc functions
 587  */
 588
 589 bool_t
 590 nlm_share_3_svc(nlm_shareargs *argp, nlm_shareres *resp,
 591     struct svc_req *sr)
 592 {
 593         nlm4_shareargs args4;
 594         nlm4_shareres res4;
 595
 596         bzero(&res4, sizeof (res4));
 597
 598         args4.cookie = argp->cookie;
 599         nlm_convert_to_nlm4_share(&args4.share, &argp->share);
 600         args4.reclaim = argp->reclaim;
 601
 602         nlm_do_share(&args4, &res4, sr);
 603
 604         resp->cookie = res4.cookie;
 605         resp->stat = nlm_convert_to_nlm_stats(res4.stat);
 606         resp->sequence = res4.sequence;
 607
 608         return (TRUE);
 609 }
 610
 611 bool_t
 612 nlm_unshare_3_svc(nlm_shareargs *argp, nlm_shareres *resp,
 613     struct svc_req *sr)
 614 {
 615         nlm4_shareargs args4;
 616         nlm4_shareres res4;
 617
 618         bzero(&res4, sizeof (res4));
 619
 620         args4.cookie = argp->cookie;
 621         nlm_convert_to_nlm4_share(&args4.share, &argp->share);
 622         args4.reclaim = argp->reclaim;
 623
 624         nlm_do_unshare(&args4, &res4, sr);
 625
 626         resp->cookie = res4.cookie;
 627         resp->stat = nlm_convert_to_nlm_stats(res4.stat);
 628         resp->sequence = res4.sequence;
 629
 630         return (TRUE);
 631 }
 632
 633 bool_t
 634 nlm_nm_lock_3_svc(nlm_lockargs *argp, nlm_res *resp, struct svc_req *sr)
 635 {
 636         nlm4_lockargs args4;
 637         nlm4_res res4;
 638
 639         bzero(&res4, sizeof (res4));
 640
 641         args4.cookie = argp->cookie;
 642         args4.block = argp->block;
 643         args4.exclusive = argp->exclusive;
 644         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 645         args4.reclaim = argp->reclaim;
 646         args4.state = argp->state;
 647
 648         /*
 649          * Don't allow blocking for non-monitored (nm_lock) calls.
 650          * These clients don't handle any callbacks, including
 651          * the granted call we make after a blocking lock.
 652          * Same reply callback as nlm_lock_1_svc
 653          */
 654         args4.block = FALSE;
 655
 656         /* NLM_NM_LOCK */
 657         nlm_do_lock(&args4, &res4, sr,
 658             nlm_lock_1_reply, NULL,
 659             NULL); /* indicates non-monitored */
 660
 661         /* for freeresult */
 662         nlm_convert_to_nlm_res(resp, &res4);
 663
 664         /* above does its own reply */
 665         return (FALSE);
 666 }
 667
 668 bool_t
 669 nlm_free_all_3_svc(nlm_notify *argp, void *resp, struct svc_req *sr)
 670 {
 671         struct nlm4_notify args4;
 672
 673         args4.name = argp->name;
 674         args4.state = argp->state;
 675
 676         nlm_do_free_all(&args4, resp, sr);
 677
 678         return (TRUE);
 679 }
 680
 681 /*
 682  * Version 4 svc functions
 683  */
 684
 685 bool_t
 686 nlm4_test_4_svc(nlm4_testargs *argp, nlm4_testres *resp, struct svc_req *sr)
 687 {
 688         nlm_do_test(argp, resp, sr, NULL);
 689         return (TRUE);
 690 }
 691
 692 /*
 693  * Callback functions for nlm4_lock_4_svc
 694  */
 695 static bool_t nlm4_lock_4_reply(SVCXPRT *, nlm4_res *);
 696 static enum clnt_stat nlm4_granted_4_cb(nlm4_testargs *, void *, CLIENT *);
 697
 698 bool_t
 699 nlm4_lock_4_svc(nlm4_lockargs *argp, nlm4_res *resp,
 700     struct svc_req *sr)
 701 {
 702
 703         /* NLM4_LOCK */
 704         nlm_do_lock(argp, resp, sr,
 705             nlm4_lock_4_reply, NULL,
 706             nlm4_granted_4_cb);
 707
 708         /* above does its own reply */
 709         return (FALSE);
 710 }
 711
 712 static bool_t
 713 nlm4_lock_4_reply(SVCXPRT *transp, nlm4_res *resp)
 714 {
 715         return (svc_sendreply(transp, xdr_nlm4_res, (char *)resp));
 716 }
 717
 718 static enum clnt_stat
 719 nlm4_granted_4_cb(nlm4_testargs *argp, void *resp, CLIENT *clnt)
 720 {
 721         nlm4_res res4;
 722         int rv;
 723
 724         bzero(&res4, sizeof (res4));
 725         rv = nlm4_granted_4(argp, &res4, clnt);
 726
 727         /* NB: We have a result our caller will not free. */
 728         xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res4);
 729         (void) resp;
 730
 731         return (rv);
 732 }
 733
 734 bool_t
 735 nlm4_cancel_4_svc(nlm4_cancargs *argp, nlm4_res *resp, struct svc_req *sr)
 736 {
 737         nlm_do_cancel(argp, resp, sr, NULL);
 738         return (TRUE);
 739 }
 740
 741 bool_t
 742 nlm4_unlock_4_svc(nlm4_unlockargs *argp, nlm4_res *resp, struct svc_req *sr)
 743 {
 744         nlm_do_unlock(argp, resp, sr, NULL);
 745         return (TRUE);
 746 }
 747
 748 bool_t
 749 nlm4_granted_4_svc(nlm4_testargs *argp, nlm4_res *resp, struct svc_req *sr)
 750 {
 751         nlm_do_granted(argp, resp, sr, NULL);
 752         return (TRUE);
 753 }
 754
 755 bool_t
 756 nlm4_test_msg_4_svc(nlm4_testargs *argp, void *resp, struct svc_req *sr)
 757 {
 758         nlm4_testres res4;
 759
 760         bzero(&res4, sizeof (res4));
 761         nlm_do_test(argp, &res4, sr,
 762             nlm4_test_res_4);
 763
 764         /* NB: We have a result our caller will not free. */
 765         xdr_free((xdrproc_t)xdr_nlm4_testres, (void *)&res4);
 766         (void) resp;
 767
 768         /* The _msg_ calls get no reply. */
 769         return (FALSE);
 770 }
 771
 772 /*
 773  * Callback functions for nlm4_lock_msg_4_svc
 774  * (using the RPC client stubs directly)
 775  */
 776
 777 bool_t
 778 nlm4_lock_msg_4_svc(nlm4_lockargs *argp, void *resp,
 779     struct svc_req *sr)
 780 {
 781         nlm4_res res4;
 782
 783         /* NLM4_LOCK_MSG */
 784         bzero(&res4, sizeof (res4));
 785         nlm_do_lock(argp, &res4, sr,
 786             NULL, nlm4_lock_res_4,
 787             nlm4_granted_msg_4);
 788
 789         /* NB: We have a result our caller will not free. */
 790         xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res4);
 791         (void) resp;
 792
 793         /* The _msg_ calls get no reply. */
 794         return (FALSE);
 795 }
 796
 797 bool_t
 798 nlm4_cancel_msg_4_svc(nlm4_cancargs *argp, void *resp, struct svc_req *sr)
 799 {
 800         nlm4_res res4;
 801
 802         bzero(&res4, sizeof (res4));
 803         nlm_do_cancel(argp, &res4, sr,
 804             nlm4_cancel_res_4);
 805
 806         /* NB: We have a result our caller will not free. */
 807         xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res4);
 808         (void) resp;
 809
 810         /* The _msg_ calls get no reply. */
 811         return (FALSE);
 812 }
 813
 814 bool_t
 815 nlm4_unlock_msg_4_svc(nlm4_unlockargs *argp, void *resp, struct svc_req *sr)
 816 {
 817         nlm4_res res4;
 818
 819         bzero(&res4, sizeof (res4));
 820         nlm_do_unlock(argp, &res4, sr,
 821             nlm4_unlock_res_4);
 822
 823         /* NB: We have a result our caller will not free. */
 824         xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res4);
 825         (void) resp;
 826
 827         /* The _msg_ calls get no reply. */
 828         return (FALSE);
 829 }
 830
 831 bool_t
 832 nlm4_granted_msg_4_svc(nlm4_testargs *argp, void *resp, struct svc_req *sr)
 833 {
 834         nlm4_res res4;
 835
 836         bzero(&res4, sizeof (res4));
 837         nlm_do_granted(argp, &res4, sr,
 838             nlm4_granted_res_4);
 839
 840         /* NB: We have a result our caller will not free. */
 841         xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res4);
 842         (void) resp;
 843
 844         /* The _msg_ calls get no reply. */
 845         return (FALSE);
 846 }
 847
 848 /* ARGSUSED */
 849 bool_t
 850 nlm4_test_res_4_svc(nlm4_testres *argp, void *resp, struct svc_req *sr)
 851 {
 852         /* The _res_ calls get no reply. */
 853         return (FALSE);
 854 }
 855
 856 /* ARGSUSED */
 857 bool_t
 858 nlm4_lock_res_4_svc(nlm4_res *argp, void *resp, struct svc_req *sr)
 859 {
 860         /* The _res_ calls get no reply. */
 861         return (FALSE);
 862 }
 863
 864 /* ARGSUSED */
 865 bool_t
 866 nlm4_cancel_res_4_svc(nlm4_res *argp, void *resp, struct svc_req *sr)
 867 {
 868         /* The _res_ calls get no reply. */
 869         return (FALSE);
 870 }
 871
 872 /* ARGSUSED */
 873 bool_t
 874 nlm4_unlock_res_4_svc(nlm4_res *argp, void *resp, struct svc_req *sr)
 875 {
 876         /* The _res_ calls get no reply. */
 877         return (FALSE);
 878 }
 879
 880 /* ARGSUSED */
 881 bool_t
 882 nlm4_granted_res_4_svc(nlm4_res *argp, void *resp, struct svc_req *sr)
 883 {
 884         /* The _res_ calls get no reply. */
 885         return (FALSE);
 886 }
 887
 888 /* ARGSUSED */
 889 bool_t
 890 nlm4_share_4_svc(nlm4_shareargs *argp, nlm4_shareres *resp,
 891     struct svc_req *sr)
 892 {
 893         nlm_do_share(argp, resp, sr);
 894         return (TRUE);
 895 }
 896
 897 /* ARGSUSED */
 898 bool_t
 899 nlm4_unshare_4_svc(nlm4_shareargs *argp, nlm4_shareres *resp,
 900     struct svc_req *sr)
 901 {
 902         nlm_do_unshare(argp, resp, sr);
 903         return (TRUE);
 904 }
 905
 906 bool_t
 907 nlm4_nm_lock_4_svc(nlm4_lockargs *argp, nlm4_res *resp, struct svc_req *sr)
 908 {
 909
 910         /*
 911          * Don't allow blocking for non-monitored (nm_lock) calls.
 912          * These clients don't handle any callbacks, including
 913          * the granted call we make after a blocking lock.
 914          * Same reply callback as nlm4_lock_4_svc
 915          */
 916         argp->block = FALSE;
 917
 918         /* NLM4_NM_LOCK */
 919         nlm_do_lock(argp, resp, sr,
 920             nlm4_lock_4_reply, NULL,
 921             NULL); /* indicates non-monitored */
 922
 923         /* above does its own reply */
 924         return (FALSE);
 925 }
 926
 927 bool_t
 928 nlm4_free_all_4_svc(nlm4_notify *argp, void *resp, struct svc_req *sr)
 929 {
 930         nlm_do_free_all(argp, resp, sr);
 931         return (TRUE);
 932 }