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 } 933