Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ 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 - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
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$"); 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 nlm_do_granted_res(argp, rqstp); 675 return (FALSE); 676 } 677 678 bool_t 679 nlm4_share_4_svc(nlm4_shareargs *argp, nlm4_shareres *result, struct svc_req *rqstp) 680 { 681 682 memset(result, 0, sizeof(*result)); 683 result->stat = nlm4_denied; 684 return (TRUE); 685 } 686 687 bool_t 688 nlm4_unshare_4_svc(nlm4_shareargs *argp, nlm4_shareres *result, struct svc_req *rqstp) 689 { 690 691 memset(result, 0, sizeof(*result)); 692 result->stat = nlm4_denied; 693 return (TRUE); 694 } 695 696 bool_t 697 nlm4_nm_lock_4_svc(nlm4_lockargs *argp, nlm4_res *result, struct svc_req *rqstp) 698 { 699 700 nlm_do_lock(argp, result, rqstp, FALSE, NULL); 701 return (TRUE); 702 } 703 704 bool_t 705 nlm4_free_all_4_svc(nlm4_notify *argp, void *result, struct svc_req *rqstp) 706 { 707 708 nlm_do_free_all(argp); 709 return (TRUE); 710 } 711 712 int 713 nlm_prog_4_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result) 714 { 715 716 (void) xdr_free(xdr_result, result); 717 return (TRUE); 718 }
Cache object: df3c82f57c3d7f972198d51ca4d96f1d
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]