[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/nlm/nlm_prot_server.c

Version: -  FREEBSD  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  cheribsd  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
SearchContext: -  none  -  3  -  10 

    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 #include <sys/cdefs.h>
   29 #ifndef lint
   30 /*static char sccsid[] = "from: @(#)nlm_prot.x 1.8 87/09/21 Copyr 1987 Sun Micro";*/
   31 /*static char sccsid[] = "from: * @(#)nlm_prot.x        2.1 88/08/01 4.0 RPCSRC";*/
   32 __RCSID("$NetBSD: nlm_prot.x,v 1.6 2000/06/07 14:30:15 bouyer Exp $");
   33 #endif /* not lint */
   34 __FBSDID("$FreeBSD: releng/7.3/sys/nlm/nlm_prot_server.c 182712 2008-09-03 07:49:49Z dfr $");
   35 
   36 #include <sys/param.h>
   37 #include <sys/malloc.h>
   38 #include <sys/systm.h>
   39 
   40 #include <nlm/nlm_prot.h>
   41 #include <nlm/nlm.h>
   42 
   43 /**********************************************************************/
   44 
   45 /*
   46  * Convert between various versions of the protocol structures.
   47  */
   48 
   49 static void
   50 nlm_convert_to_nlm4_lock(struct nlm4_lock *dst, struct nlm_lock *src)
   51 {
   52 
   53         dst->caller_name = src->caller_name;
   54         dst->fh = src->fh;
   55         dst->oh = src->oh;
   56         dst->svid = src->svid;
   57         dst->l_offset = src->l_offset;
   58         dst->l_len = src->l_len;
   59 }
   60 
   61 static void
   62 nlm_convert_to_nlm4_share(struct nlm4_share *dst, struct nlm_share *src)
   63 {
   64 
   65         dst->caller_name = src->caller_name;
   66         dst->fh = src->fh;
   67         dst->oh = src->oh;
   68         dst->mode = src->mode;
   69         dst->access = src->access;
   70 }
   71 
   72 static void
   73 nlm_convert_to_nlm_holder(struct nlm_holder *dst, struct nlm4_holder *src)
   74 {
   75 
   76         dst->exclusive = src->exclusive;
   77         dst->svid = src->svid;
   78         dst->oh = src->oh;
   79         dst->l_offset = src->l_offset;
   80         dst->l_len = src->l_len;
   81 }
   82 
   83 static void
   84 nlm_convert_to_nlm4_holder(struct nlm4_holder *dst, struct nlm_holder *src)
   85 {
   86 
   87         dst->exclusive = src->exclusive;
   88         dst->svid = src->svid;
   89         dst->oh = src->oh;
   90         dst->l_offset = src->l_offset;
   91         dst->l_len = src->l_len;
   92 }
   93 
   94 static enum nlm_stats
   95 nlm_convert_to_nlm_stats(enum nlm4_stats src)
   96 {
   97         if (src > nlm4_deadlck)
   98                 return nlm_denied;
   99         return (enum nlm_stats) src;
  100 }
  101 
  102 static void
  103 nlm_convert_to_nlm_res(struct nlm_res *dst, struct nlm4_res *src)
  104 {
  105         dst->cookie = src->cookie;
  106         dst->stat.stat = nlm_convert_to_nlm_stats(src->stat.stat);
  107 }
  108 
  109 static void
  110 nlm_convert_to_nlm4_res(struct nlm4_res *dst, struct nlm_res *src)
  111 {
  112         dst->cookie = src->cookie;
  113         dst->stat.stat = (enum nlm4_stats) src->stat.stat;
  114 }
  115 
  116 /**********************************************************************/
  117 
  118 /*
  119  * RPC server stubs.
  120  */
  121 
  122 bool_t
  123 nlm_sm_notify_0_svc(struct nlm_sm_status *argp, void *result, struct svc_req *rqstp)
  124 {
  125         nlm_sm_notify(argp);
  126 
  127         return (TRUE);
  128 }
  129 
  130 bool_t
  131 nlm_test_1_svc(struct nlm_testargs *argp, nlm_testres *result, struct svc_req *rqstp)
  132 {
  133         bool_t retval;
  134         nlm4_testargs args4;
  135         nlm4_testres res4;
  136 
  137         args4.cookie = argp->cookie;
  138         args4.exclusive = argp->exclusive;
  139         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
  140 
  141         retval = nlm4_test_4_svc(&args4, &res4, rqstp);
  142         if (retval) {
  143                 result->cookie = res4.cookie;
  144                 result->stat.stat = nlm_convert_to_nlm_stats(res4.stat.stat);
  145                 if (result->stat.stat == nlm_denied)
  146                         nlm_convert_to_nlm_holder(
  147                                 &result->stat.nlm_testrply_u.holder,
  148                                 &res4.stat.nlm4_testrply_u.holder);
  149         }
  150 
  151         return (retval);
  152 }
  153 
  154 bool_t
  155 nlm_lock_1_svc(struct nlm_lockargs *argp, nlm_res *result, struct svc_req *rqstp)
  156 {
  157         bool_t retval;
  158         nlm4_lockargs args4;
  159         nlm4_res res4;
  160 
  161         args4.cookie = argp->cookie;
  162         args4.block = argp->block;
  163         args4.exclusive = argp->exclusive;
  164         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
  165         args4.reclaim = argp->reclaim;
  166         args4.state = argp->state;
  167 
  168         retval = nlm4_lock_4_svc(&args4, &res4, rqstp);
  169         if (retval)
  170                 nlm_convert_to_nlm_res(result, &res4);
  171 
  172         return (retval);
  173 }
  174 
  175 bool_t
  176 nlm_cancel_1_svc(struct nlm_cancargs *argp, nlm_res *result, struct svc_req *rqstp)
  177 {
  178         bool_t retval;
  179         nlm4_cancargs args4;
  180         nlm4_res res4;
  181 
  182         args4.cookie = argp->cookie;
  183         args4.block = argp->block;
  184         args4.exclusive = argp->exclusive;
  185         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
  186 
  187         retval = nlm4_cancel_4_svc(&args4, &res4, rqstp);
  188         if (retval)
  189                 nlm_convert_to_nlm_res(result, &res4);
  190 
  191         return (retval);
  192 }
  193 
  194 bool_t
  195 nlm_unlock_1_svc(struct nlm_unlockargs *argp, nlm_res *result, struct svc_req *rqstp)
  196 {
  197         bool_t retval;
  198         nlm4_unlockargs args4;
  199         nlm4_res res4;
  200 
  201         args4.cookie = argp->cookie;
  202         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
  203 
  204         retval = nlm4_unlock_4_svc(&args4, &res4, rqstp);
  205         if (retval)
  206                 nlm_convert_to_nlm_res(result, &res4);
  207 
  208         return (retval);
  209 }
  210 
  211 bool_t
  212 nlm_granted_1_svc(struct nlm_testargs *argp, nlm_res *result, struct svc_req *rqstp)
  213 {
  214         bool_t retval;
  215         nlm4_testargs args4;
  216         nlm4_res res4;
  217 
  218         args4.cookie = argp->cookie;
  219         args4.exclusive = argp->exclusive;
  220         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
  221 
  222         retval = nlm4_granted_4_svc(&args4, &res4, rqstp);
  223         if (retval)
  224                 nlm_convert_to_nlm_res(result, &res4);
  225 
  226         return (retval);
  227 }
  228 
  229 bool_t
  230 nlm_test_msg_1_svc(struct nlm_testargs *argp, void *result, struct svc_req *rqstp)
  231 {
  232         nlm4_testargs args4;
  233         nlm4_testres res4;
  234         nlm_testres res;
  235         CLIENT *rpc;
  236         char dummy;
  237 
  238         args4.cookie = argp->cookie;
  239         args4.exclusive = argp->exclusive;
  240         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
  241 
  242         if (nlm_do_test(&args4, &res4, rqstp, &rpc))
  243                 return (FALSE);
  244 
  245         res.cookie = res4.cookie;
  246         res.stat.stat = nlm_convert_to_nlm_stats(res4.stat.stat);
  247         if (res.stat.stat == nlm_denied)
  248                 nlm_convert_to_nlm_holder(
  249                         &res.stat.nlm_testrply_u.holder,
  250                         &res4.stat.nlm4_testrply_u.holder);
  251 
  252         if (rpc) {
  253                 nlm_test_res_1(&res, &dummy, rpc, NULL, nlm_zero_tv);
  254                 CLNT_RELEASE(rpc);
  255         }
  256         xdr_free((xdrproc_t) xdr_nlm_testres, &res);
  257 
  258         return (FALSE);
  259 }
  260 
  261 bool_t
  262 nlm_lock_msg_1_svc(struct nlm_lockargs *argp, void *result, struct svc_req *rqstp)
  263 {
  264         nlm4_lockargs args4;
  265         nlm4_res res4;
  266         nlm_res res;
  267         CLIENT *rpc;
  268         char dummy;
  269 
  270         args4.cookie = argp->cookie;
  271         args4.block = argp->block;
  272         args4.exclusive = argp->exclusive;
  273         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
  274         args4.reclaim = argp->reclaim;
  275         args4.state = argp->state;
  276 
  277         if (nlm_do_lock(&args4, &res4, rqstp, TRUE, &rpc))
  278                 return (FALSE);
  279 
  280         nlm_convert_to_nlm_res(&res, &res4);
  281 
  282         if (rpc) {
  283                 nlm_lock_res_1(&res, &dummy, rpc, NULL, nlm_zero_tv);
  284                 CLNT_RELEASE(rpc);
  285         }
  286         xdr_free((xdrproc_t) xdr_nlm_res, &res);
  287 
  288         return (FALSE);
  289 }
  290 
  291 bool_t
  292 nlm_cancel_msg_1_svc(struct nlm_cancargs *argp, void *result, struct svc_req *rqstp)
  293 {
  294         nlm4_cancargs args4;
  295         nlm4_res res4;
  296         nlm_res res;
  297         CLIENT *rpc;
  298         char dummy;
  299 
  300         args4.cookie = argp->cookie;
  301         args4.block = argp->block;
  302         args4.exclusive = argp->exclusive;
  303         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
  304 
  305         if (nlm_do_cancel(&args4, &res4, rqstp, &rpc))
  306                 return (FALSE);
  307 
  308         nlm_convert_to_nlm_res(&res, &res4);
  309 
  310         if (rpc) {
  311                 nlm_cancel_res_1(&res, &dummy, rpc, NULL, nlm_zero_tv);
  312                 CLNT_RELEASE(rpc);
  313         }
  314         xdr_free((xdrproc_t) xdr_nlm_res, &res);
  315 
  316         return (FALSE);
  317 }
  318 
  319 bool_t
  320 nlm_unlock_msg_1_svc(struct nlm_unlockargs *argp, void *result, struct svc_req *rqstp)
  321 {
  322         nlm4_unlockargs args4;
  323         nlm4_res res4;
  324         nlm_res res;
  325         CLIENT *rpc;
  326         char dummy;
  327 
  328         args4.cookie = argp->cookie;
  329         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
  330 
  331         if (nlm_do_unlock(&args4, &res4, rqstp, &rpc))
  332                 return (FALSE);
  333 
  334         nlm_convert_to_nlm_res(&res, &res4);
  335 
  336         if (rpc) {
  337                 nlm_unlock_res_1(&res, &dummy, rpc, NULL, nlm_zero_tv);
  338                 CLNT_RELEASE(rpc);
  339         }
  340         xdr_free((xdrproc_t) xdr_nlm_res, &res);
  341 
  342         return (FALSE);
  343 }
  344 
  345 bool_t
  346 nlm_granted_msg_1_svc(struct nlm_testargs *argp, void *result, struct svc_req *rqstp)
  347 {
  348         nlm4_testargs args4;
  349         nlm4_res res4;
  350         nlm_res res;
  351         CLIENT *rpc;
  352         char dummy;
  353 
  354         args4.cookie = argp->cookie;
  355         args4.exclusive = argp->exclusive;
  356         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
  357 
  358         if (nlm_do_granted(&args4, &res4, rqstp, &rpc))
  359                 return (FALSE);
  360 
  361         nlm_convert_to_nlm_res(&res, &res4);
  362 
  363         if (rpc) {
  364                 nlm_granted_res_1(&res, &dummy, rpc, NULL, nlm_zero_tv);
  365                 CLNT_RELEASE(rpc);
  366         }
  367         xdr_free((xdrproc_t) xdr_nlm_res, &res);
  368 
  369         return (FALSE);
  370 }
  371 
  372 bool_t
  373 nlm_test_res_1_svc(nlm_testres *argp, void *result, struct svc_req *rqstp)
  374 {
  375         nlm4_testres args4;
  376 
  377         args4.cookie = argp->cookie;
  378         if (argp->stat.stat == nlm_denied)
  379                 nlm_convert_to_nlm4_holder(
  380                         &args4.stat.nlm4_testrply_u.holder,
  381                         &argp->stat.nlm_testrply_u.holder);
  382 
  383         return (nlm4_test_res_4_svc(&args4, result, rqstp));
  384 }
  385 
  386 bool_t
  387 nlm_lock_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp)
  388 {
  389         nlm4_res arg4;
  390 
  391         nlm_convert_to_nlm4_res(&arg4, argp);
  392         return (nlm4_lock_res_4_svc(&arg4, result, rqstp));
  393 }
  394 
  395 bool_t
  396 nlm_cancel_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp)
  397 {
  398         nlm4_res arg4;
  399 
  400         nlm_convert_to_nlm4_res(&arg4, argp);
  401         return (nlm4_cancel_res_4_svc(&arg4, result, rqstp));
  402 }
  403 
  404 bool_t
  405 nlm_unlock_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp)
  406 {
  407         nlm4_res arg4;
  408 
  409         nlm_convert_to_nlm4_res(&arg4, argp);
  410         return (nlm4_unlock_res_4_svc(&arg4, result, rqstp));
  411 }
  412 
  413 bool_t
  414 nlm_granted_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp)
  415 {
  416         nlm4_res arg4;
  417 
  418         nlm_convert_to_nlm4_res(&arg4, argp);
  419         return (nlm4_granted_res_4_svc(&arg4, result, rqstp));
  420 }
  421 
  422 int
  423 nlm_prog_1_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
  424 {
  425 
  426         (void) xdr_free(xdr_result, result);
  427         return (TRUE);
  428 }
  429 
  430 bool_t
  431 nlm_share_3_svc(nlm_shareargs *argp, nlm_shareres *result, struct svc_req *rqstp)
  432 {
  433         bool_t retval;
  434         nlm4_shareargs args4;
  435         nlm4_shareres res4;
  436 
  437         args4.cookie = argp->cookie;
  438         nlm_convert_to_nlm4_share(&args4.share, &argp->share);
  439         args4.reclaim = argp->reclaim;
  440 
  441         retval = nlm4_share_4_svc(&args4, &res4, rqstp);
  442         if (retval) {
  443                 result->cookie = res4.cookie;
  444                 result->stat = nlm_convert_to_nlm_stats(res4.stat);
  445                 result->sequence = res4.sequence;
  446         }
  447 
  448         return (retval);
  449 }
  450 
  451 bool_t
  452 nlm_unshare_3_svc(nlm_shareargs *argp, nlm_shareres *result, struct svc_req *rqstp)
  453 {
  454         bool_t retval;
  455         nlm4_shareargs args4;
  456         nlm4_shareres res4;
  457 
  458         args4.cookie = argp->cookie;
  459         nlm_convert_to_nlm4_share(&args4.share, &argp->share);
  460         args4.reclaim = argp->reclaim;
  461 
  462         retval = nlm4_unshare_4_svc(&args4, &res4, rqstp);
  463         if (retval) {
  464                 result->cookie = res4.cookie;
  465                 result->stat = nlm_convert_to_nlm_stats(res4.stat);
  466                 result->sequence = res4.sequence;
  467         }
  468 
  469         return (retval);
  470 }
  471 
  472 bool_t
  473 nlm_nm_lock_3_svc(nlm_lockargs *argp, nlm_res *result, struct svc_req *rqstp)
  474 {
  475         bool_t retval;
  476         nlm4_lockargs args4;
  477         nlm4_res res4;
  478 
  479         args4.cookie = argp->cookie;
  480         args4.block = argp->block;
  481         args4.exclusive = argp->exclusive;
  482         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
  483         args4.reclaim = argp->reclaim;
  484         args4.state = argp->state;
  485 
  486         retval = nlm4_nm_lock_4_svc(&args4, &res4, rqstp);
  487         if (retval)
  488                 nlm_convert_to_nlm_res(result, &res4);
  489 
  490         return (retval);
  491 }
  492 
  493 bool_t
  494 nlm_free_all_3_svc(nlm_notify *argp, void *result, struct svc_req *rqstp)
  495 {
  496         struct nlm4_notify args4;
  497 
  498         args4.name = argp->name;
  499         args4.state = argp->state;
  500 
  501         return (nlm4_free_all_4_svc(&args4, result, rqstp));
  502 }
  503 
  504 int
  505 nlm_prog_3_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
  506 {
  507 
  508         (void) xdr_free(xdr_result, result);
  509         return (TRUE);
  510 }
  511 
  512 bool_t
  513 nlm4_test_4_svc(nlm4_testargs *argp, nlm4_testres *result, struct svc_req *rqstp)
  514 {
  515 
  516         nlm_do_test(argp, result, rqstp, NULL);
  517         return (TRUE);
  518 }
  519 
  520 bool_t
  521 nlm4_lock_4_svc(nlm4_lockargs *argp, nlm4_res *result, struct svc_req *rqstp)
  522 {
  523 
  524         nlm_do_lock(argp, result, rqstp, TRUE, NULL);
  525         return (TRUE);
  526 }
  527 
  528 bool_t
  529 nlm4_cancel_4_svc(nlm4_cancargs *argp, nlm4_res *result, struct svc_req *rqstp)
  530 {
  531 
  532         nlm_do_cancel(argp, result, rqstp, NULL);
  533         return (TRUE);
  534 }
  535 
  536 bool_t
  537 nlm4_unlock_4_svc(nlm4_unlockargs *argp, nlm4_res *result, struct svc_req *rqstp)
  538 {
  539 
  540         nlm_do_unlock(argp, result, rqstp, NULL);
  541         return (TRUE);
  542 }
  543 
  544 bool_t
  545 nlm4_granted_4_svc(nlm4_testargs *argp, nlm4_res *result, struct svc_req *rqstp)
  546 {
  547 
  548         nlm_do_granted(argp, result, rqstp, NULL);
  549         return (TRUE);
  550 }
  551 
  552 bool_t
  553 nlm4_test_msg_4_svc(nlm4_testargs *argp, void *result, struct svc_req *rqstp)
  554 {
  555         nlm4_testres res4;
  556         CLIENT *rpc;
  557         char dummy;
  558 
  559         if (nlm_do_test(argp, &res4, rqstp, &rpc))
  560                 return (FALSE);
  561         if (rpc) {
  562                 nlm4_test_res_4(&res4, &dummy, rpc, NULL, nlm_zero_tv);
  563                 CLNT_RELEASE(rpc);
  564         }
  565         xdr_free((xdrproc_t) xdr_nlm4_testres, &res4);
  566 
  567         return (FALSE);
  568 }
  569 
  570 bool_t
  571 nlm4_lock_msg_4_svc(nlm4_lockargs *argp, void *result, struct svc_req *rqstp)
  572 {
  573         nlm4_res res4;
  574         CLIENT *rpc;
  575         char dummy;
  576 
  577         if (nlm_do_lock(argp, &res4, rqstp, TRUE, &rpc))
  578                 return (FALSE);
  579         if (rpc) {
  580                 nlm4_lock_res_4(&res4, &dummy, rpc, NULL, nlm_zero_tv);
  581                 CLNT_RELEASE(rpc);
  582         }
  583         xdr_free((xdrproc_t) xdr_nlm4_res, &res4);
  584 
  585         return (FALSE);
  586 }
  587 
  588 bool_t
  589 nlm4_cancel_msg_4_svc(nlm4_cancargs *argp, void *result, struct svc_req *rqstp)
  590 {
  591         nlm4_res res4;
  592         CLIENT *rpc;
  593         char dummy;
  594 
  595         if (nlm_do_cancel(argp, &res4, rqstp, &rpc))
  596                 return (FALSE);
  597         if (rpc) {
  598                 nlm4_cancel_res_4(&res4, &dummy, rpc, NULL, nlm_zero_tv);
  599                 CLNT_RELEASE(rpc);
  600         }
  601         xdr_free((xdrproc_t) xdr_nlm4_res, &res4);
  602 
  603         return (FALSE);
  604 }
  605 
  606 bool_t
  607 nlm4_unlock_msg_4_svc(nlm4_unlockargs *argp, void *result, struct svc_req *rqstp)
  608 {
  609         nlm4_res res4;
  610         CLIENT *rpc;
  611         char dummy;
  612 
  613         if (nlm_do_unlock(argp, &res4, rqstp, &rpc))
  614                 return (FALSE);
  615         if (rpc) {
  616                 nlm4_unlock_res_4(&res4, &dummy, rpc, NULL, nlm_zero_tv);
  617                 CLNT_RELEASE(rpc);
  618         }
  619         xdr_free((xdrproc_t) xdr_nlm4_res, &res4);
  620 
  621         return (FALSE);
  622 }
  623 
  624 bool_t
  625 nlm4_granted_msg_4_svc(nlm4_testargs *argp, void *result, struct svc_req *rqstp)
  626 {
  627         nlm4_res res4;
  628         CLIENT *rpc;
  629         char dummy;
  630 
  631         if (nlm_do_granted(argp, &res4, rqstp, &rpc))
  632                 return (FALSE);
  633         if (rpc) {
  634                 nlm4_granted_res_4(&res4, &dummy, rpc, NULL, nlm_zero_tv);
  635                 CLNT_RELEASE(rpc);
  636         }
  637         xdr_free((xdrproc_t) xdr_nlm4_res, &res4);
  638 
  639         return (FALSE);
  640 }
  641 
  642 bool_t
  643 nlm4_test_res_4_svc(nlm4_testres *argp, void *result, struct svc_req *rqstp)
  644 {
  645 
  646         return (FALSE);
  647 }
  648 
  649 bool_t
  650 nlm4_lock_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp)
  651 {
  652 
  653         return (FALSE);
  654 }
  655 
  656 bool_t
  657 nlm4_cancel_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp)
  658 {
  659 
  660         return (FALSE);
  661 }
  662 
  663 bool_t
  664 nlm4_unlock_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp)
  665 {
  666 
  667         return (FALSE);
  668 }
  669 
  670 bool_t
  671 nlm4_granted_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp)
  672 {
  673 
  674         return (FALSE);
  675 }
  676 
  677 bool_t
  678 nlm4_share_4_svc(nlm4_shareargs *argp, nlm4_shareres *result, struct svc_req *rqstp)
  679 {
  680 
  681         memset(result, 0, sizeof(*result));
  682         result->stat = nlm4_denied;
  683         return (TRUE);
  684 }
  685 
  686 bool_t
  687 nlm4_unshare_4_svc(nlm4_shareargs *argp, nlm4_shareres *result, struct svc_req *rqstp)
  688 {
  689 
  690         memset(result, 0, sizeof(*result));
  691         result->stat = nlm4_denied;
  692         return (TRUE);
  693 }
  694 
  695 bool_t
  696 nlm4_nm_lock_4_svc(nlm4_lockargs *argp, nlm4_res *result, struct svc_req *rqstp)
  697 {
  698 
  699         nlm_do_lock(argp, result, rqstp, FALSE, NULL);
  700         return (TRUE);
  701 }
  702 
  703 bool_t
  704 nlm4_free_all_4_svc(nlm4_notify *argp, void *result, struct svc_req *rqstp)
  705 {
  706 
  707         nlm_do_free_all(argp);
  708         return (TRUE);
  709 }
  710 
  711 int
  712 nlm_prog_4_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
  713 {
  714 
  715         (void) xdr_free(xdr_result, result);
  716         return (TRUE);
  717 }

Cache object: 5da6aeb30da3a1551ba7468a8ac0a740


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.