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

   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 }