1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy is of the CDDL is also available via the Internet 9 * at http://www.illumos.org/license/CDDL. 10 */ 11 12 /* 13 * Copyright 2013 Nexenta Systems, Inc. All rights reserved. 14 */ 15 16 /* 17 * NFS Lock Manager, server-side dispatch tables and 18 * dispatch programs: nlm_prog_3, nlm_prog4 19 * 20 * These are called by RPC framework after the RPC service 21 * endpoints setup done in nlm_impl.c: nlm_svc_add_ep(). 22 * 23 * Originally from rpcgen, then reduced. 24 */ 25 26 #include <sys/param.h> 27 #include <sys/systm.h> 28 #include <sys/sdt.h> 29 #include <rpcsvc/nlm_prot.h> 30 #include "nlm_impl.h" 31 32 /* 33 * Dispatch entry function pointers. 34 */ 35 typedef bool_t (*nlm_svc_func_t)(void *, void *, struct svc_req *); 36 typedef void (*nlm_freeres_func_t)(void *); 37 38 /* 39 * Entries in the dispatch tables below. 40 */ 41 struct dispatch_entry { 42 nlm_svc_func_t de_svc; /* service routine function */ 43 xdrproc_t de_xargs; /* XDR args decode function */ 44 xdrproc_t de_xres; /* XDR res encode function */ 45 nlm_freeres_func_t de_resfree; /* free res function */ 46 int de_ressz; /* size of result */ 47 uint_t de_flags; /* flags */ 48 }; 49 50 /* Flag bits in de_flags */ 51 #define NLM_DISP_NOREMOTE 1 /* Local calls only */ 52 53 /* 54 * Cast macros for dispatch table function pointers. 55 */ 56 #define NLM_SVC_FUNC(func) (nlm_svc_func_t)func 57 #define NLM_FREERES_FUNC(func) (nlm_freeres_func_t)func 58 59 /* ARGSUSED */ 60 static bool_t 61 nlm_null_svc(void *args, void *resp, struct svc_req *sr) 62 { 63 return (TRUE); 64 } 65 66 /* 67 * The common NLM service dispatch function, used by 68 * both: nlm_prog_3, nlm_prog_4 69 */ 70 void 71 nlm_dispatch( 72 struct svc_req *rqstp, 73 SVCXPRT *transp, 74 const struct dispatch_entry *de) 75 { 76 union { 77 /* All the arg types */ 78 nlm_cancargs au_cancargs; 79 nlm_lockargs au_lockargs; 80 nlm_notify au_notify; 81 nlm_res au_res; 82 nlm_shareargs au_shareargs; 83 nlm_sm_status au_sm_status; 84 nlm_testargs au_testargs; 85 nlm_testres au_testres; 86 nlm_unlockargs au_unlockargs; 87 nlm4_cancargs au_cancargs4; 88 nlm4_lockargs au_lockargs4; 89 nlm4_notify au_notify4; 90 nlm4_res au_res4; 91 nlm4_shareargs au_shareargs4; 92 nlm4_testargs au_testargs4; 93 nlm4_testres au_testres4; 94 nlm4_unlockargs au_unlockargs4; 95 } argu; 96 void *args = &argu; 97 union { 98 /* All the ret types */ 99 int ru_int; 100 nlm_res ru_res; 101 nlm_shareres ru_shareres; 102 nlm_testres ru_testres; 103 nlm4_res ru_res4; 104 nlm4_shareres ru_shareres4; 105 nlm4_testres ru_testres4; 106 107 } resu; 108 void *res = &resu; 109 nlm_svc_func_t func; 110 bool_t do_reply = FALSE; 111 bool_t dupcached = FALSE; 112 struct dupreq *dr; 113 int dupstat; 114 115 if ((func = de->de_svc) == NULL) { 116 svcerr_noproc(transp); 117 return; 118 } 119 120 if ((de->de_flags & NLM_DISP_NOREMOTE) && 121 !nlm_caller_is_local(transp)) { 122 svcerr_noproc(transp); 123 return; 124 } 125 126 /* 127 * This section from rpcgen, and then modified slightly. 128 * 129 * Dispatch entries that should _never_ send a response 130 * (i.e. all the _MSG and _RES entries) put NULL in the 131 * de_xres field to indicate that. For such entries, we 132 * will NOT call svc_sendreply nor xdr_free(). Normal 133 * dispatch entries skip svc_sendreply if the dispatch 134 * function returns zero, but always call xdr_free(). 135 * 136 * There are more complex cases where some dispatch 137 * functions need to send their own reply. We chose 138 * to indicate those by returning false from the 139 * service routine. 140 */ 141 bzero(&argu, sizeof (argu)); 142 if (!SVC_GETARGS(transp, de->de_xargs, args)) { 143 svcerr_decode(transp); 144 return; 145 } 146 147 /* 148 * Duplicate request cache. 149 * 150 * Since none of the NLM replies are very large we have simplified the 151 * DRC by not distinguishing between idempotent and non-idempotent 152 * requests. 153 */ 154 dupstat = SVC_DUP_EXT(transp, rqstp, res, de->de_ressz, &dr, 155 &dupcached); 156 157 switch (dupstat) { 158 case DUP_ERROR: 159 svcerr_systemerr(transp); 160 break; 161 case DUP_INPROGRESS: 162 break; 163 case DUP_NEW: 164 case DUP_DROP: 165 /* 166 * When UFS is quiescing it uses lockfs to block vnode 167 * operations until it has finished quiescing. Set the 168 * thread's T_DONTPEND flag to prevent the service routine 169 * from blocking due to a lockfs lock. (See ufs_check_lockfs) 170 */ 171 curthread->t_flag |= T_DONTPEND; 172 173 bzero(&resu, sizeof (resu)); 174 do_reply = (*func)(args, res, rqstp); 175 176 curthread->t_flag &= ~T_DONTPEND; 177 if (curthread->t_flag & T_WOULDBLOCK) { 178 curthread->t_flag &= ~T_WOULDBLOCK; 179 SVC_DUPDONE_EXT(transp, dr, res, NULL, 180 de->de_ressz, DUP_DROP); 181 do_reply = FALSE; 182 break; 183 } 184 SVC_DUPDONE_EXT(transp, dr, res, de->de_resfree, 185 de->de_ressz, DUP_DONE); 186 dupcached = TRUE; 187 break; 188 case DUP_DONE: 189 /* 190 * The service routine may have been responsible for sending 191 * the reply for the original request but for a re-xmitted 192 * request we don't invoke the service routine so we must 193 * re-xmit the reply from the dispatch function. 194 * 195 * If de_xres is NULL this is a one-way message so no reply is 196 * needed. 197 */ 198 if (de->de_xres != NULL_xdrproc_t) { 199 do_reply = TRUE; 200 } 201 break; 202 } 203 204 if (do_reply) { 205 ASSERT(de->de_xres != NULL_xdrproc_t); 206 DTRACE_PROBE3(sendreply, struct svc_req *, rqstp, 207 SVCXPRT *, transp, struct dispatch_entry *, de); 208 209 if (!svc_sendreply(transp, de->de_xres, res)) { 210 svcerr_systemerr(transp); 211 NLM_ERR("nlm_dispatch(): svc_sendreply() failed!\n"); 212 } 213 214 if (!dupcached) { 215 xdr_free(de->de_xres, res); 216 } 217 } 218 219 if (!SVC_FREEARGS(transp, de->de_xargs, args)) 220 NLM_WARN("nlm_dispatch(): unable to free arguments"); 221 } 222 223 /* 224 * Result free functions. The functions are called by the RPC duplicate 225 * request cache code when an entry is being evicted from the cache. 226 */ 227 static void 228 nlm_res_free(nlm_res *resp) 229 { 230 xdr_free(xdr_nlm_res, (char *)resp); 231 } 232 233 static void 234 nlm_shareres_free(nlm_shareres *resp) 235 { 236 xdr_free(xdr_nlm_shareres, (char *)resp); 237 } 238 239 static void 240 nlm_testres_free(nlm_testres *resp) 241 { 242 xdr_free(xdr_nlm_testres, (char *)resp); 243 } 244 245 static void 246 nlm4_res_free(nlm4_res *resp) 247 { 248 xdr_free(xdr_nlm4_res, (char *)resp); 249 } 250 251 static void 252 nlm4_shareres_free(nlm4_shareres *resp) 253 { 254 xdr_free(xdr_nlm4_shareres, (char *)resp); 255 } 256 257 static void 258 nlm4_testres_free(nlm4_testres *resp) 259 { 260 xdr_free(xdr_nlm4_testres, (char *)resp); 261 } 262 263 /* 264 * Dispatch tables for each program version. 265 * 266 * The tables here were all originally from rpcgen, 267 * but then arg/resp sizes removed, flags added. 268 */ 269 270 /* 271 * Dispatch table for versions 1, 2, 3 272 * (NLM_VERS, NLM_SM, NLM_VERSX) 273 */ 274 static const struct dispatch_entry 275 nlm_prog_3_dtable[] = { 276 277 /* 278 * Version 1 (NLM_VERS) entries. 279 */ 280 281 { /* 0: NULLPROC */ 282 NLM_SVC_FUNC(nlm_null_svc), 283 (xdrproc_t)xdr_void, 284 (xdrproc_t)xdr_void, 285 NULL, 286 0, 287 0 }, 288 289 { /* 1: NLM_TEST */ 290 NLM_SVC_FUNC(nlm_test_1_svc), 291 (xdrproc_t)xdr_nlm_testargs, 292 (xdrproc_t)xdr_nlm_testres, 293 NLM_FREERES_FUNC(nlm_testres_free), 294 sizeof (nlm_testres), 295 0 }, 296 297 { /* 2: NLM_LOCK */ 298 NLM_SVC_FUNC(nlm_lock_1_svc), 299 (xdrproc_t)xdr_nlm_lockargs, 300 (xdrproc_t)xdr_nlm_res, 301 NLM_FREERES_FUNC(nlm_res_free), 302 sizeof (nlm_res), 303 0 }, 304 305 { /* 3: NLM_CANCEL */ 306 NLM_SVC_FUNC(nlm_cancel_1_svc), 307 (xdrproc_t)xdr_nlm_cancargs, 308 (xdrproc_t)xdr_nlm_res, 309 NLM_FREERES_FUNC(nlm_res_free), 310 sizeof (nlm_res), 311 0 }, 312 313 { /* 4: NLM_UNLOCK */ 314 NLM_SVC_FUNC(nlm_unlock_1_svc), 315 (xdrproc_t)xdr_nlm_unlockargs, 316 (xdrproc_t)xdr_nlm_res, 317 NLM_FREERES_FUNC(nlm_res_free), 318 sizeof (nlm_res), 319 0 }, 320 321 { /* 5: NLM_GRANTED */ 322 NLM_SVC_FUNC(nlm_granted_1_svc), 323 (xdrproc_t)xdr_nlm_testargs, 324 (xdrproc_t)xdr_nlm_res, 325 NLM_FREERES_FUNC(nlm_res_free), 326 sizeof (nlm_res), 327 0 }, 328 329 /* 330 * All the _MSG and _RES entries are "one way" calls that 331 * skip the usual RPC reply. We give them a null xdr_res 332 * function so the dispatcher will not send a reply. 333 */ 334 335 { /* 6: NLM_TEST_MSG */ 336 NLM_SVC_FUNC(nlm_test_msg_1_svc), 337 (xdrproc_t)xdr_nlm_testargs, 338 (xdrproc_t)0, 339 NULL, 340 0, 341 0 }, 342 343 { /* 7: NLM_LOCK_MSG */ 344 NLM_SVC_FUNC(nlm_lock_msg_1_svc), 345 (xdrproc_t)xdr_nlm_lockargs, 346 (xdrproc_t)0, 347 NULL, 348 0, 349 0 }, 350 351 { /* 8: NLM_CANCEL_MSG */ 352 NLM_SVC_FUNC(nlm_cancel_msg_1_svc), 353 (xdrproc_t)xdr_nlm_cancargs, 354 (xdrproc_t)0, 355 NULL, 356 0, 357 0 }, 358 359 { /* 9: NLM_UNLOCK_MSG */ 360 NLM_SVC_FUNC(nlm_unlock_msg_1_svc), 361 (xdrproc_t)xdr_nlm_unlockargs, 362 (xdrproc_t)0, 363 NULL, 364 0, 365 0 }, 366 367 { /* 10: NLM_GRANTED_MSG */ 368 NLM_SVC_FUNC(nlm_granted_msg_1_svc), 369 (xdrproc_t)xdr_nlm_testargs, 370 (xdrproc_t)0, 371 NULL, 372 0, 373 0 }, 374 375 { /* 11: NLM_TEST_RES */ 376 NLM_SVC_FUNC(nlm_test_res_1_svc), 377 (xdrproc_t)xdr_nlm_testres, 378 (xdrproc_t)0, 379 NULL, 380 0, 381 0 }, 382 383 { /* 12: NLM_LOCK_RES */ 384 NLM_SVC_FUNC(nlm_lock_res_1_svc), 385 (xdrproc_t)xdr_nlm_res, 386 (xdrproc_t)0, 387 NULL, 388 0, 389 0 }, 390 391 { /* 13: NLM_CANCEL_RES */ 392 NLM_SVC_FUNC(nlm_cancel_res_1_svc), 393 (xdrproc_t)xdr_nlm_res, 394 (xdrproc_t)0, 395 NULL, 396 0, 397 0 }, 398 399 { /* 14: NLM_UNLOCK_RES */ 400 NLM_SVC_FUNC(nlm_unlock_res_1_svc), 401 (xdrproc_t)xdr_nlm_res, 402 (xdrproc_t)0, 403 NULL, 404 0, 405 0 }, 406 407 { /* 15: NLM_GRANTED_RES */ 408 NLM_SVC_FUNC(nlm_granted_res_1_svc), 409 (xdrproc_t)xdr_nlm_res, 410 (xdrproc_t)0, 411 NULL, 412 0, 413 0 }, 414 415 { /* 16: not used */ 416 NLM_SVC_FUNC(0), 417 (xdrproc_t)0, 418 (xdrproc_t)0, 419 NULL, 420 0, 421 0 }, 422 423 { /* 17: NLM_SM_NOTIFY1 */ 424 NLM_SVC_FUNC(nlm_sm_notify1_2_svc), 425 (xdrproc_t)xdr_nlm_sm_status, 426 (xdrproc_t)xdr_void, 427 NULL, 428 0, 429 NLM_DISP_NOREMOTE }, 430 431 { /* 18: NLM_SM_NOTIFY2 */ 432 NLM_SVC_FUNC(nlm_sm_notify2_2_svc), 433 (xdrproc_t)xdr_nlm_sm_status, 434 (xdrproc_t)xdr_void, 435 NULL, 436 0, 437 NLM_DISP_NOREMOTE }, 438 439 /* 440 * Version 3 (NLM_VERSX) entries. 441 */ 442 443 { /* 19: not used */ 444 NLM_SVC_FUNC(0), 445 (xdrproc_t)0, 446 (xdrproc_t)0, 447 NULL, 448 0, 449 0 }, 450 451 { /* 20: NLM_SHARE */ 452 NLM_SVC_FUNC(nlm_share_3_svc), 453 (xdrproc_t)xdr_nlm_shareargs, 454 (xdrproc_t)xdr_nlm_shareres, 455 NLM_FREERES_FUNC(nlm_shareres_free), 456 sizeof (nlm_shareres), 457 0 }, 458 459 { /* 21: NLM_UNSHARE */ 460 NLM_SVC_FUNC(nlm_unshare_3_svc), 461 (xdrproc_t)xdr_nlm_shareargs, 462 (xdrproc_t)xdr_nlm_shareres, 463 NLM_FREERES_FUNC(nlm_shareres_free), 464 sizeof (nlm_shareres), 465 0 }, 466 467 { /* 22: NLM_NM_LOCK */ 468 NLM_SVC_FUNC(nlm_nm_lock_3_svc), 469 (xdrproc_t)xdr_nlm_lockargs, 470 (xdrproc_t)xdr_nlm_res, 471 NLM_FREERES_FUNC(nlm_res_free), 472 sizeof (nlm_res), 473 0 }, 474 475 { /* 23: NLM_FREE_ALL */ 476 NLM_SVC_FUNC(nlm_free_all_3_svc), 477 (xdrproc_t)xdr_nlm_notify, 478 (xdrproc_t)xdr_void, 479 NULL, 480 0, 481 0 }, 482 }; 483 static int nlm_prog_3_dtsize = 484 sizeof (nlm_prog_3_dtable) / 485 sizeof (nlm_prog_3_dtable[0]); 486 487 /* 488 * RPC dispatch function for nlm_prot versions: 1,2,3 489 */ 490 void 491 nlm_prog_3(struct svc_req *rqstp, register SVCXPRT *transp) 492 { 493 const struct dispatch_entry *de; 494 rpcproc_t max_proc; 495 496 switch (rqstp->rq_vers) { 497 case NLM_VERS: 498 max_proc = NLM_GRANTED_RES; 499 break; 500 case NLM_SM: 501 max_proc = NLM_SM_NOTIFY2; 502 break; 503 case NLM_VERSX: 504 max_proc = NLM_FREE_ALL; 505 break; 506 default: 507 /* Our svc registration should prevent this. */ 508 ASSERT(0); /* paranoid */ 509 svcerr_noprog(transp); 510 return; 511 } 512 ASSERT(max_proc < nlm_prog_3_dtsize); 513 514 if (rqstp->rq_proc > max_proc) { 515 svcerr_noproc(transp); 516 return; 517 } 518 519 de = &nlm_prog_3_dtable[rqstp->rq_proc]; 520 521 nlm_dispatch(rqstp, transp, de); 522 } 523 524 /* 525 * Dispatch table for version 4 (NLM4_VERS) 526 */ 527 static const struct dispatch_entry 528 nlm_prog_4_dtable[] = { 529 530 { /* 0: NULLPROC */ 531 NLM_SVC_FUNC(nlm_null_svc), 532 (xdrproc_t)xdr_void, 533 (xdrproc_t)xdr_void, 534 NULL, 535 0, 536 0 }, 537 538 { /* 1: NLM4_TEST */ 539 NLM_SVC_FUNC(nlm4_test_4_svc), 540 (xdrproc_t)xdr_nlm4_testargs, 541 (xdrproc_t)xdr_nlm4_testres, 542 NLM_FREERES_FUNC(nlm4_testres_free), 543 sizeof (nlm4_testres), 544 0 }, 545 546 { /* 2: NLM4_LOCK */ 547 NLM_SVC_FUNC(nlm4_lock_4_svc), 548 (xdrproc_t)xdr_nlm4_lockargs, 549 (xdrproc_t)xdr_nlm4_res, 550 NLM_FREERES_FUNC(nlm4_res_free), 551 sizeof (nlm4_res), 552 0 }, 553 554 { /* 3: NLM4_CANCEL */ 555 NLM_SVC_FUNC(nlm4_cancel_4_svc), 556 (xdrproc_t)xdr_nlm4_cancargs, 557 (xdrproc_t)xdr_nlm4_res, 558 NLM_FREERES_FUNC(nlm4_res_free), 559 sizeof (nlm4_res), 560 0 }, 561 562 { /* 4: NLM4_UNLOCK */ 563 NLM_SVC_FUNC(nlm4_unlock_4_svc), 564 (xdrproc_t)xdr_nlm4_unlockargs, 565 (xdrproc_t)xdr_nlm4_res, 566 NLM_FREERES_FUNC(nlm4_res_free), 567 sizeof (nlm4_res), 568 0 }, 569 570 { /* 5: NLM4_GRANTED */ 571 NLM_SVC_FUNC(nlm4_granted_4_svc), 572 (xdrproc_t)xdr_nlm4_testargs, 573 (xdrproc_t)xdr_nlm4_res, 574 NLM_FREERES_FUNC(nlm4_res_free), 575 sizeof (nlm4_res), 576 0 }, 577 578 /* 579 * All the _MSG and _RES entries are "one way" calls that 580 * skip the usual RPC reply. We give them a null xdr_res 581 * function so the dispatcher will not send a reply. 582 */ 583 584 { /* 6: NLM4_TEST_MSG */ 585 NLM_SVC_FUNC(nlm4_test_msg_4_svc), 586 (xdrproc_t)xdr_nlm4_testargs, 587 (xdrproc_t)0, 588 NULL, 589 0, 590 0 }, 591 592 { /* 7: NLM4_LOCK_MSG */ 593 NLM_SVC_FUNC(nlm4_lock_msg_4_svc), 594 (xdrproc_t)xdr_nlm4_lockargs, 595 (xdrproc_t)0, 596 NULL, 597 0, 598 0 }, 599 600 { /* 8: NLM4_CANCEL_MSG */ 601 NLM_SVC_FUNC(nlm4_cancel_msg_4_svc), 602 (xdrproc_t)xdr_nlm4_cancargs, 603 (xdrproc_t)0, 604 NULL, 605 0, 606 0 }, 607 608 { /* 9: NLM4_UNLOCK_MSG */ 609 NLM_SVC_FUNC(nlm4_unlock_msg_4_svc), 610 (xdrproc_t)xdr_nlm4_unlockargs, 611 (xdrproc_t)0, 612 NULL, 613 0, 614 0 }, 615 616 { /* 10: NLM4_GRANTED_MSG */ 617 NLM_SVC_FUNC(nlm4_granted_msg_4_svc), 618 (xdrproc_t)xdr_nlm4_testargs, 619 (xdrproc_t)0, 620 NULL, 621 0, 622 0 }, 623 624 { /* 11: NLM4_TEST_RES */ 625 NLM_SVC_FUNC(nlm4_test_res_4_svc), 626 (xdrproc_t)xdr_nlm4_testres, 627 (xdrproc_t)0, 628 NULL, 629 0, 630 0 }, 631 632 { /* 12: NLM4_LOCK_RES */ 633 NLM_SVC_FUNC(nlm4_lock_res_4_svc), 634 (xdrproc_t)xdr_nlm4_res, 635 (xdrproc_t)0, 636 NULL, 637 0, 638 0 }, 639 640 { /* 13: NLM4_CANCEL_RES */ 641 NLM_SVC_FUNC(nlm4_cancel_res_4_svc), 642 (xdrproc_t)xdr_nlm4_res, 643 (xdrproc_t)0, 644 NULL, 645 0, 646 0 }, 647 648 { /* 14: NLM4_UNLOCK_RES */ 649 NLM_SVC_FUNC(nlm4_unlock_res_4_svc), 650 (xdrproc_t)xdr_nlm4_res, 651 (xdrproc_t)0, 652 NULL, 653 0, 654 0 }, 655 656 { /* 15: NLM4_GRANTED_RES */ 657 NLM_SVC_FUNC(nlm4_granted_res_4_svc), 658 (xdrproc_t)xdr_nlm4_res, 659 (xdrproc_t)0, 660 NULL, 661 0, 662 0 }, 663 664 { /* 16: not used */ 665 NLM_SVC_FUNC(0), 666 (xdrproc_t)0, 667 (xdrproc_t)0, 668 NULL, 669 0, 670 0 }, 671 672 { /* 17: NLM_SM_NOTIFY1 (not in v4) */ 673 NLM_SVC_FUNC(0), 674 (xdrproc_t)0, 675 (xdrproc_t)0, 676 NULL, 677 0, 678 0 }, 679 680 { /* 18: NLM_SM_NOTIFY2 (not in v4) */ 681 NLM_SVC_FUNC(0), 682 (xdrproc_t)0, 683 (xdrproc_t)0, 684 NULL, 685 0, 686 0 }, 687 688 { /* 19: not used */ 689 NLM_SVC_FUNC(0), 690 (xdrproc_t)0, 691 (xdrproc_t)0, 692 NULL, 693 0, 694 0 }, 695 696 { /* 20: NLM4_SHARE */ 697 NLM_SVC_FUNC(nlm4_share_4_svc), 698 (xdrproc_t)xdr_nlm4_shareargs, 699 (xdrproc_t)xdr_nlm4_shareres, 700 NLM_FREERES_FUNC(nlm4_shareres_free), 701 sizeof (nlm4_shareres), 702 0 }, 703 704 { /* 21: NLM4_UNSHARE */ 705 NLM_SVC_FUNC(nlm4_unshare_4_svc), 706 (xdrproc_t)xdr_nlm4_shareargs, 707 (xdrproc_t)xdr_nlm4_shareres, 708 NLM_FREERES_FUNC(nlm4_shareres_free), 709 sizeof (nlm4_shareres), 710 0 }, 711 712 { /* 22: NLM4_NM_LOCK */ 713 NLM_SVC_FUNC(nlm4_nm_lock_4_svc), 714 (xdrproc_t)xdr_nlm4_lockargs, 715 (xdrproc_t)xdr_nlm4_res, 716 NLM_FREERES_FUNC(nlm4_res_free), 717 sizeof (nlm4_res), 718 0 }, 719 720 { /* 23: NLM4_FREE_ALL */ 721 NLM_SVC_FUNC(nlm4_free_all_4_svc), 722 (xdrproc_t)xdr_nlm4_notify, 723 (xdrproc_t)xdr_void, 724 NULL, 725 0, 726 0 }, 727 }; 728 static int nlm_prog_4_dtsize = 729 sizeof (nlm_prog_4_dtable) / 730 sizeof (nlm_prog_4_dtable[0]); 731 732 /* 733 * RPC dispatch function for nlm_prot version 4. 734 */ 735 void 736 nlm_prog_4(struct svc_req *rqstp, register SVCXPRT *transp) 737 { 738 const struct dispatch_entry *de; 739 740 if (rqstp->rq_vers != NLM4_VERS) { 741 /* Our svc registration should prevent this. */ 742 ASSERT(0); /* paranoid */ 743 svcerr_noprog(transp); 744 return; 745 } 746 747 if (rqstp->rq_proc >= nlm_prog_4_dtsize) { 748 svcerr_noproc(transp); 749 return; 750 } 751 752 de = &nlm_prog_4_dtable[rqstp->rq_proc]; 753 754 nlm_dispatch(rqstp, transp, de); 755 } 756