1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/fs/lockd/svcproc.c 4 * 5 * Lockd server procedures. We don't implement the NLM_*_RES 6 * procedures because we don't use the async procedures. 7 * 8 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> 9 */ 10 11 #include <linux/types.h> 12 #include <linux/time.h> 13 #include <linux/lockd/lockd.h> 14 #include <linux/lockd/share.h> 15 #include <linux/sunrpc/svc_xprt.h> 16 17 #define NLMDBG_FACILITY NLMDBG_CLIENT 18 19 #ifdef CONFIG_LOCKD_V4 20 static __be32 21 cast_to_nlm(__be32 status, u32 vers) 22 { 23 /* Note: status is assumed to be in network byte order !!! */ 24 if (vers != 4){ 25 switch (status) { 26 case nlm_granted: 27 case nlm_lck_denied: 28 case nlm_lck_denied_nolocks: 29 case nlm_lck_blocked: 30 case nlm_lck_denied_grace_period: 31 case nlm_drop_reply: 32 break; 33 case nlm4_deadlock: 34 status = nlm_lck_denied; 35 break; 36 default: 37 status = nlm_lck_denied_nolocks; 38 } 39 } 40 41 return (status); 42 } 43 #define cast_status(status) (cast_to_nlm(status, rqstp->rq_vers)) 44 #else 45 #define cast_status(status) (status) 46 #endif 47 48 /* 49 * Obtain client and file from arguments 50 */ 51 static __be32 52 nlmsvc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp, 53 struct nlm_host **hostp, struct nlm_file **filp) 54 { 55 struct nlm_host *host = NULL; 56 struct nlm_file *file = NULL; 57 struct nlm_lock *lock = &argp->lock; 58 int mode; 59 __be32 error = 0; 60 61 /* nfsd callbacks must have been installed for this procedure */ 62 if (!nlmsvc_ops) 63 return nlm_lck_denied_nolocks; 64 65 /* Obtain host handle */ 66 if (!(host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len)) 67 || (argp->monitor && nsm_monitor(host) < 0)) 68 goto no_locks; 69 *hostp = host; 70 71 /* Obtain file pointer. Not used by FREE_ALL call. */ 72 if (filp != NULL) { 73 error = cast_status(nlm_lookup_file(rqstp, &file, lock)); 74 if (error != 0) 75 goto no_locks; 76 *filp = file; 77 78 /* Set up the missing parts of the file_lock structure */ 79 mode = lock_to_openmode(&lock->fl); 80 lock->fl.fl_file = file->f_file[mode]; 81 lock->fl.fl_pid = current->tgid; 82 lock->fl.fl_lmops = &nlmsvc_lock_operations; 83 nlmsvc_locks_init_private(&lock->fl, host, (pid_t)lock->svid); 84 if (!lock->fl.fl_owner) { 85 /* lockowner allocation has failed */ 86 nlmsvc_release_host(host); 87 return nlm_lck_denied_nolocks; 88 } 89 } 90 91 return 0; 92 93 no_locks: 94 nlmsvc_release_host(host); 95 if (error) 96 return error; 97 return nlm_lck_denied_nolocks; 98 } 99 100 /* 101 * NULL: Test for presence of service 102 */ 103 static __be32 104 nlmsvc_proc_null(struct svc_rqst *rqstp) 105 { 106 dprintk("lockd: NULL called\n"); 107 return rpc_success; 108 } 109 110 /* 111 * TEST: Check for conflicting lock 112 */ 113 static __be32 114 __nlmsvc_proc_test(struct svc_rqst *rqstp, struct nlm_res *resp) 115 { 116 struct nlm_args *argp = rqstp->rq_argp; 117 struct nlm_host *host; 118 struct nlm_file *file; 119 __be32 rc = rpc_success; 120 121 dprintk("lockd: TEST called\n"); 122 resp->cookie = argp->cookie; 123 124 /* Obtain client and file */ 125 if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) 126 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; 127 128 /* Now check for conflicting locks */ 129 resp->status = cast_status(nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie)); 130 if (resp->status == nlm_drop_reply) 131 rc = rpc_drop_reply; 132 else 133 dprintk("lockd: TEST status %d vers %d\n", 134 ntohl(resp->status), rqstp->rq_vers); 135 136 nlmsvc_release_lockowner(&argp->lock); 137 nlmsvc_release_host(host); 138 nlm_release_file(file); 139 return rc; 140 } 141 142 static __be32 143 nlmsvc_proc_test(struct svc_rqst *rqstp) 144 { 145 return __nlmsvc_proc_test(rqstp, rqstp->rq_resp); 146 } 147 148 static __be32 149 __nlmsvc_proc_lock(struct svc_rqst *rqstp, struct nlm_res *resp) 150 { 151 struct nlm_args *argp = rqstp->rq_argp; 152 struct nlm_host *host; 153 struct nlm_file *file; 154 __be32 rc = rpc_success; 155 156 dprintk("lockd: LOCK called\n"); 157 158 resp->cookie = argp->cookie; 159 160 /* Obtain client and file */ 161 if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) 162 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; 163 164 #if 0 165 /* If supplied state doesn't match current state, we assume it's 166 * an old request that time-warped somehow. Any error return would 167 * do in this case because it's irrelevant anyway. 168 * 169 * NB: We don't retrieve the remote host's state yet. 170 */ 171 if (host->h_nsmstate && host->h_nsmstate != argp->state) { 172 resp->status = nlm_lck_denied_nolocks; 173 } else 174 #endif 175 176 /* Now try to lock the file */ 177 resp->status = cast_status(nlmsvc_lock(rqstp, file, host, &argp->lock, 178 argp->block, &argp->cookie, 179 argp->reclaim)); 180 if (resp->status == nlm_drop_reply) 181 rc = rpc_drop_reply; 182 else 183 dprintk("lockd: LOCK status %d\n", ntohl(resp->status)); 184 185 nlmsvc_release_lockowner(&argp->lock); 186 nlmsvc_release_host(host); 187 nlm_release_file(file); 188 return rc; 189 } 190 191 static __be32 192 nlmsvc_proc_lock(struct svc_rqst *rqstp) 193 { 194 return __nlmsvc_proc_lock(rqstp, rqstp->rq_resp); 195 } 196 197 static __be32 198 __nlmsvc_proc_cancel(struct svc_rqst *rqstp, struct nlm_res *resp) 199 { 200 struct nlm_args *argp = rqstp->rq_argp; 201 struct nlm_host *host; 202 struct nlm_file *file; 203 struct net *net = SVC_NET(rqstp); 204 205 dprintk("lockd: CANCEL called\n"); 206 207 resp->cookie = argp->cookie; 208 209 /* Don't accept requests during grace period */ 210 if (locks_in_grace(net)) { 211 resp->status = nlm_lck_denied_grace_period; 212 return rpc_success; 213 } 214 215 /* Obtain client and file */ 216 if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) 217 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; 218 219 /* Try to cancel request. */ 220 resp->status = cast_status(nlmsvc_cancel_blocked(net, file, &argp->lock)); 221 222 dprintk("lockd: CANCEL status %d\n", ntohl(resp->status)); 223 nlmsvc_release_lockowner(&argp->lock); 224 nlmsvc_release_host(host); 225 nlm_release_file(file); 226 return rpc_success; 227 } 228 229 static __be32 230 nlmsvc_proc_cancel(struct svc_rqst *rqstp) 231 { 232 return __nlmsvc_proc_cancel(rqstp, rqstp->rq_resp); 233 } 234 235 /* 236 * UNLOCK: release a lock 237 */ 238 static __be32 239 __nlmsvc_proc_unlock(struct svc_rqst *rqstp, struct nlm_res *resp) 240 { 241 struct nlm_args *argp = rqstp->rq_argp; 242 struct nlm_host *host; 243 struct nlm_file *file; 244 struct net *net = SVC_NET(rqstp); 245 246 dprintk("lockd: UNLOCK called\n"); 247 248 resp->cookie = argp->cookie; 249 250 /* Don't accept new lock requests during grace period */ 251 if (locks_in_grace(net)) { 252 resp->status = nlm_lck_denied_grace_period; 253 return rpc_success; 254 } 255 256 /* Obtain client and file */ 257 if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) 258 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; 259 260 /* Now try to remove the lock */ 261 resp->status = cast_status(nlmsvc_unlock(net, file, &argp->lock)); 262 263 dprintk("lockd: UNLOCK status %d\n", ntohl(resp->status)); 264 nlmsvc_release_lockowner(&argp->lock); 265 nlmsvc_release_host(host); 266 nlm_release_file(file); 267 return rpc_success; 268 } 269 270 static __be32 271 nlmsvc_proc_unlock(struct svc_rqst *rqstp) 272 { 273 return __nlmsvc_proc_unlock(rqstp, rqstp->rq_resp); 274 } 275 276 /* 277 * GRANTED: A server calls us to tell that a process' lock request 278 * was granted 279 */ 280 static __be32 281 __nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_res *resp) 282 { 283 struct nlm_args *argp = rqstp->rq_argp; 284 285 resp->cookie = argp->cookie; 286 287 dprintk("lockd: GRANTED called\n"); 288 resp->status = nlmclnt_grant(svc_addr(rqstp), &argp->lock); 289 dprintk("lockd: GRANTED status %d\n", ntohl(resp->status)); 290 return rpc_success; 291 } 292 293 static __be32 294 nlmsvc_proc_granted(struct svc_rqst *rqstp) 295 { 296 return __nlmsvc_proc_granted(rqstp, rqstp->rq_resp); 297 } 298 299 /* 300 * This is the generic lockd callback for async RPC calls 301 */ 302 static void nlmsvc_callback_exit(struct rpc_task *task, void *data) 303 { 304 dprintk("lockd: %5u callback returned %d\n", task->tk_pid, 305 -task->tk_status); 306 } 307 308 void nlmsvc_release_call(struct nlm_rqst *call) 309 { 310 if (!refcount_dec_and_test(&call->a_count)) 311 return; 312 nlmsvc_release_host(call->a_host); 313 kfree(call); 314 } 315 316 static void nlmsvc_callback_release(void *data) 317 { 318 nlmsvc_release_call(data); 319 } 320 321 static const struct rpc_call_ops nlmsvc_callback_ops = { 322 .rpc_call_done = nlmsvc_callback_exit, 323 .rpc_release = nlmsvc_callback_release, 324 }; 325 326 /* 327 * `Async' versions of the above service routines. They aren't really, 328 * because we send the callback before the reply proper. I hope this 329 * doesn't break any clients. 330 */ 331 static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc, 332 __be32 (*func)(struct svc_rqst *, struct nlm_res *)) 333 { 334 struct nlm_args *argp = rqstp->rq_argp; 335 struct nlm_host *host; 336 struct nlm_rqst *call; 337 __be32 stat; 338 339 host = nlmsvc_lookup_host(rqstp, 340 argp->lock.caller, 341 argp->lock.len); 342 if (host == NULL) 343 return rpc_system_err; 344 345 call = nlm_alloc_call(host); 346 nlmsvc_release_host(host); 347 if (call == NULL) 348 return rpc_system_err; 349 350 stat = func(rqstp, &call->a_res); 351 if (stat != 0) { 352 nlmsvc_release_call(call); 353 return stat; 354 } 355 356 call->a_flags = RPC_TASK_ASYNC; 357 if (nlm_async_reply(call, proc, &nlmsvc_callback_ops) < 0) 358 return rpc_system_err; 359 return rpc_success; 360 } 361 362 static __be32 nlmsvc_proc_test_msg(struct svc_rqst *rqstp) 363 { 364 dprintk("lockd: TEST_MSG called\n"); 365 return nlmsvc_callback(rqstp, NLMPROC_TEST_RES, __nlmsvc_proc_test); 366 } 367 368 static __be32 nlmsvc_proc_lock_msg(struct svc_rqst *rqstp) 369 { 370 dprintk("lockd: LOCK_MSG called\n"); 371 return nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, __nlmsvc_proc_lock); 372 } 373 374 static __be32 nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp) 375 { 376 dprintk("lockd: CANCEL_MSG called\n"); 377 return nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, __nlmsvc_proc_cancel); 378 } 379 380 static __be32 381 nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp) 382 { 383 dprintk("lockd: UNLOCK_MSG called\n"); 384 return nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, __nlmsvc_proc_unlock); 385 } 386 387 static __be32 388 nlmsvc_proc_granted_msg(struct svc_rqst *rqstp) 389 { 390 dprintk("lockd: GRANTED_MSG called\n"); 391 return nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, __nlmsvc_proc_granted); 392 } 393 394 /* 395 * SHARE: create a DOS share or alter existing share. 396 */ 397 static __be32 398 nlmsvc_proc_share(struct svc_rqst *rqstp) 399 { 400 struct nlm_args *argp = rqstp->rq_argp; 401 struct nlm_res *resp = rqstp->rq_resp; 402 struct nlm_host *host; 403 struct nlm_file *file; 404 405 dprintk("lockd: SHARE called\n"); 406 407 resp->cookie = argp->cookie; 408 409 /* Don't accept new lock requests during grace period */ 410 if (locks_in_grace(SVC_NET(rqstp)) && !argp->reclaim) { 411 resp->status = nlm_lck_denied_grace_period; 412 return rpc_success; 413 } 414 415 /* Obtain client and file */ 416 if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) 417 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; 418 419 /* Now try to create the share */ 420 resp->status = cast_status(nlmsvc_share_file(host, file, argp)); 421 422 dprintk("lockd: SHARE status %d\n", ntohl(resp->status)); 423 nlmsvc_release_lockowner(&argp->lock); 424 nlmsvc_release_host(host); 425 nlm_release_file(file); 426 return rpc_success; 427 } 428 429 /* 430 * UNSHARE: Release a DOS share. 431 */ 432 static __be32 433 nlmsvc_proc_unshare(struct svc_rqst *rqstp) 434 { 435 struct nlm_args *argp = rqstp->rq_argp; 436 struct nlm_res *resp = rqstp->rq_resp; 437 struct nlm_host *host; 438 struct nlm_file *file; 439 440 dprintk("lockd: UNSHARE called\n"); 441 442 resp->cookie = argp->cookie; 443 444 /* Don't accept requests during grace period */ 445 if (locks_in_grace(SVC_NET(rqstp))) { 446 resp->status = nlm_lck_denied_grace_period; 447 return rpc_success; 448 } 449 450 /* Obtain client and file */ 451 if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) 452 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; 453 454 /* Now try to unshare the file */ 455 resp->status = cast_status(nlmsvc_unshare_file(host, file, argp)); 456 457 dprintk("lockd: UNSHARE status %d\n", ntohl(resp->status)); 458 nlmsvc_release_lockowner(&argp->lock); 459 nlmsvc_release_host(host); 460 nlm_release_file(file); 461 return rpc_success; 462 } 463 464 /* 465 * NM_LOCK: Create an unmonitored lock 466 */ 467 static __be32 468 nlmsvc_proc_nm_lock(struct svc_rqst *rqstp) 469 { 470 struct nlm_args *argp = rqstp->rq_argp; 471 472 dprintk("lockd: NM_LOCK called\n"); 473 474 argp->monitor = 0; /* just clean the monitor flag */ 475 return nlmsvc_proc_lock(rqstp); 476 } 477 478 /* 479 * FREE_ALL: Release all locks and shares held by client 480 */ 481 static __be32 482 nlmsvc_proc_free_all(struct svc_rqst *rqstp) 483 { 484 struct nlm_args *argp = rqstp->rq_argp; 485 struct nlm_host *host; 486 487 /* Obtain client */ 488 if (nlmsvc_retrieve_args(rqstp, argp, &host, NULL)) 489 return rpc_success; 490 491 nlmsvc_free_host_resources(host); 492 nlmsvc_release_host(host); 493 return rpc_success; 494 } 495 496 /* 497 * SM_NOTIFY: private callback from statd (not part of official NLM proto) 498 */ 499 static __be32 500 nlmsvc_proc_sm_notify(struct svc_rqst *rqstp) 501 { 502 struct nlm_reboot *argp = rqstp->rq_argp; 503 504 dprintk("lockd: SM_NOTIFY called\n"); 505 506 if (!nlm_privileged_requester(rqstp)) { 507 char buf[RPC_MAX_ADDRBUFLEN]; 508 printk(KERN_WARNING "lockd: rejected NSM callback from %s\n", 509 svc_print_addr(rqstp, buf, sizeof(buf))); 510 return rpc_system_err; 511 } 512 513 nlm_host_rebooted(SVC_NET(rqstp), argp); 514 return rpc_success; 515 } 516 517 /* 518 * client sent a GRANTED_RES, let's remove the associated block 519 */ 520 static __be32 521 nlmsvc_proc_granted_res(struct svc_rqst *rqstp) 522 { 523 struct nlm_res *argp = rqstp->rq_argp; 524 525 if (!nlmsvc_ops) 526 return rpc_success; 527 528 dprintk("lockd: GRANTED_RES called\n"); 529 530 nlmsvc_grant_reply(&argp->cookie, argp->status); 531 return rpc_success; 532 } 533 534 static __be32 535 nlmsvc_proc_unused(struct svc_rqst *rqstp) 536 { 537 return rpc_proc_unavail; 538 } 539 540 /* 541 * NLM Server procedures. 542 */ 543 544 struct nlm_void { int dummy; }; 545 546 #define Ck (1+XDR_QUADLEN(NLM_MAXCOOKIELEN)) /* cookie */ 547 #define St 1 /* status */ 548 #define No (1+1024/4) /* Net Obj */ 549 #define Rg 2 /* range - offset + size */ 550 551 const struct svc_procedure nlmsvc_procedures[24] = { 552 [NLMPROC_NULL] = { 553 .pc_func = nlmsvc_proc_null, 554 .pc_decode = nlmsvc_decode_void, 555 .pc_encode = nlmsvc_encode_void, 556 .pc_argsize = sizeof(struct nlm_void), 557 .pc_ressize = sizeof(struct nlm_void), 558 .pc_xdrressize = St, 559 .pc_name = "NULL", 560 }, 561 [NLMPROC_TEST] = { 562 .pc_func = nlmsvc_proc_test, 563 .pc_decode = nlmsvc_decode_testargs, 564 .pc_encode = nlmsvc_encode_testres, 565 .pc_argsize = sizeof(struct nlm_args), 566 .pc_ressize = sizeof(struct nlm_res), 567 .pc_xdrressize = Ck+St+2+No+Rg, 568 .pc_name = "TEST", 569 }, 570 [NLMPROC_LOCK] = { 571 .pc_func = nlmsvc_proc_lock, 572 .pc_decode = nlmsvc_decode_lockargs, 573 .pc_encode = nlmsvc_encode_res, 574 .pc_argsize = sizeof(struct nlm_args), 575 .pc_ressize = sizeof(struct nlm_res), 576 .pc_xdrressize = Ck+St, 577 .pc_name = "LOCK", 578 }, 579 [NLMPROC_CANCEL] = { 580 .pc_func = nlmsvc_proc_cancel, 581 .pc_decode = nlmsvc_decode_cancargs, 582 .pc_encode = nlmsvc_encode_res, 583 .pc_argsize = sizeof(struct nlm_args), 584 .pc_ressize = sizeof(struct nlm_res), 585 .pc_xdrressize = Ck+St, 586 .pc_name = "CANCEL", 587 }, 588 [NLMPROC_UNLOCK] = { 589 .pc_func = nlmsvc_proc_unlock, 590 .pc_decode = nlmsvc_decode_unlockargs, 591 .pc_encode = nlmsvc_encode_res, 592 .pc_argsize = sizeof(struct nlm_args), 593 .pc_ressize = sizeof(struct nlm_res), 594 .pc_xdrressize = Ck+St, 595 .pc_name = "UNLOCK", 596 }, 597 [NLMPROC_GRANTED] = { 598 .pc_func = nlmsvc_proc_granted, 599 .pc_decode = nlmsvc_decode_testargs, 600 .pc_encode = nlmsvc_encode_res, 601 .pc_argsize = sizeof(struct nlm_args), 602 .pc_ressize = sizeof(struct nlm_res), 603 .pc_xdrressize = Ck+St, 604 .pc_name = "GRANTED", 605 }, 606 [NLMPROC_TEST_MSG] = { 607 .pc_func = nlmsvc_proc_test_msg, 608 .pc_decode = nlmsvc_decode_testargs, 609 .pc_encode = nlmsvc_encode_void, 610 .pc_argsize = sizeof(struct nlm_args), 611 .pc_ressize = sizeof(struct nlm_void), 612 .pc_xdrressize = St, 613 .pc_name = "TEST_MSG", 614 }, 615 [NLMPROC_LOCK_MSG] = { 616 .pc_func = nlmsvc_proc_lock_msg, 617 .pc_decode = nlmsvc_decode_lockargs, 618 .pc_encode = nlmsvc_encode_void, 619 .pc_argsize = sizeof(struct nlm_args), 620 .pc_ressize = sizeof(struct nlm_void), 621 .pc_xdrressize = St, 622 .pc_name = "LOCK_MSG", 623 }, 624 [NLMPROC_CANCEL_MSG] = { 625 .pc_func = nlmsvc_proc_cancel_msg, 626 .pc_decode = nlmsvc_decode_cancargs, 627 .pc_encode = nlmsvc_encode_void, 628 .pc_argsize = sizeof(struct nlm_args), 629 .pc_ressize = sizeof(struct nlm_void), 630 .pc_xdrressize = St, 631 .pc_name = "CANCEL_MSG", 632 }, 633 [NLMPROC_UNLOCK_MSG] = { 634 .pc_func = nlmsvc_proc_unlock_msg, 635 .pc_decode = nlmsvc_decode_unlockargs, 636 .pc_encode = nlmsvc_encode_void, 637 .pc_argsize = sizeof(struct nlm_args), 638 .pc_ressize = sizeof(struct nlm_void), 639 .pc_xdrressize = St, 640 .pc_name = "UNLOCK_MSG", 641 }, 642 [NLMPROC_GRANTED_MSG] = { 643 .pc_func = nlmsvc_proc_granted_msg, 644 .pc_decode = nlmsvc_decode_testargs, 645 .pc_encode = nlmsvc_encode_void, 646 .pc_argsize = sizeof(struct nlm_args), 647 .pc_ressize = sizeof(struct nlm_void), 648 .pc_xdrressize = St, 649 .pc_name = "GRANTED_MSG", 650 }, 651 [NLMPROC_TEST_RES] = { 652 .pc_func = nlmsvc_proc_null, 653 .pc_decode = nlmsvc_decode_void, 654 .pc_encode = nlmsvc_encode_void, 655 .pc_argsize = sizeof(struct nlm_res), 656 .pc_ressize = sizeof(struct nlm_void), 657 .pc_xdrressize = St, 658 .pc_name = "TEST_RES", 659 }, 660 [NLMPROC_LOCK_RES] = { 661 .pc_func = nlmsvc_proc_null, 662 .pc_decode = nlmsvc_decode_void, 663 .pc_encode = nlmsvc_encode_void, 664 .pc_argsize = sizeof(struct nlm_res), 665 .pc_ressize = sizeof(struct nlm_void), 666 .pc_xdrressize = St, 667 .pc_name = "LOCK_RES", 668 }, 669 [NLMPROC_CANCEL_RES] = { 670 .pc_func = nlmsvc_proc_null, 671 .pc_decode = nlmsvc_decode_void, 672 .pc_encode = nlmsvc_encode_void, 673 .pc_argsize = sizeof(struct nlm_res), 674 .pc_ressize = sizeof(struct nlm_void), 675 .pc_xdrressize = St, 676 .pc_name = "CANCEL_RES", 677 }, 678 [NLMPROC_UNLOCK_RES] = { 679 .pc_func = nlmsvc_proc_null, 680 .pc_decode = nlmsvc_decode_void, 681 .pc_encode = nlmsvc_encode_void, 682 .pc_argsize = sizeof(struct nlm_res), 683 .pc_ressize = sizeof(struct nlm_void), 684 .pc_xdrressize = St, 685 .pc_name = "UNLOCK_RES", 686 }, 687 [NLMPROC_GRANTED_RES] = { 688 .pc_func = nlmsvc_proc_granted_res, 689 .pc_decode = nlmsvc_decode_res, 690 .pc_encode = nlmsvc_encode_void, 691 .pc_argsize = sizeof(struct nlm_res), 692 .pc_ressize = sizeof(struct nlm_void), 693 .pc_xdrressize = St, 694 .pc_name = "GRANTED_RES", 695 }, 696 [NLMPROC_NSM_NOTIFY] = { 697 .pc_func = nlmsvc_proc_sm_notify, 698 .pc_decode = nlmsvc_decode_reboot, 699 .pc_encode = nlmsvc_encode_void, 700 .pc_argsize = sizeof(struct nlm_reboot), 701 .pc_ressize = sizeof(struct nlm_void), 702 .pc_xdrressize = St, 703 .pc_name = "SM_NOTIFY", 704 }, 705 [17] = { 706 .pc_func = nlmsvc_proc_unused, 707 .pc_decode = nlmsvc_decode_void, 708 .pc_encode = nlmsvc_encode_void, 709 .pc_argsize = sizeof(struct nlm_void), 710 .pc_ressize = sizeof(struct nlm_void), 711 .pc_xdrressize = St, 712 .pc_name = "UNUSED", 713 }, 714 [18] = { 715 .pc_func = nlmsvc_proc_unused, 716 .pc_decode = nlmsvc_decode_void, 717 .pc_encode = nlmsvc_encode_void, 718 .pc_argsize = sizeof(struct nlm_void), 719 .pc_ressize = sizeof(struct nlm_void), 720 .pc_xdrressize = St, 721 .pc_name = "UNUSED", 722 }, 723 [19] = { 724 .pc_func = nlmsvc_proc_unused, 725 .pc_decode = nlmsvc_decode_void, 726 .pc_encode = nlmsvc_encode_void, 727 .pc_argsize = sizeof(struct nlm_void), 728 .pc_ressize = sizeof(struct nlm_void), 729 .pc_xdrressize = St, 730 .pc_name = "UNUSED", 731 }, 732 [NLMPROC_SHARE] = { 733 .pc_func = nlmsvc_proc_share, 734 .pc_decode = nlmsvc_decode_shareargs, 735 .pc_encode = nlmsvc_encode_shareres, 736 .pc_argsize = sizeof(struct nlm_args), 737 .pc_ressize = sizeof(struct nlm_res), 738 .pc_xdrressize = Ck+St+1, 739 .pc_name = "SHARE", 740 }, 741 [NLMPROC_UNSHARE] = { 742 .pc_func = nlmsvc_proc_unshare, 743 .pc_decode = nlmsvc_decode_shareargs, 744 .pc_encode = nlmsvc_encode_shareres, 745 .pc_argsize = sizeof(struct nlm_args), 746 .pc_ressize = sizeof(struct nlm_res), 747 .pc_xdrressize = Ck+St+1, 748 .pc_name = "UNSHARE", 749 }, 750 [NLMPROC_NM_LOCK] = { 751 .pc_func = nlmsvc_proc_nm_lock, 752 .pc_decode = nlmsvc_decode_lockargs, 753 .pc_encode = nlmsvc_encode_res, 754 .pc_argsize = sizeof(struct nlm_args), 755 .pc_ressize = sizeof(struct nlm_res), 756 .pc_xdrressize = Ck+St, 757 .pc_name = "NM_LOCK", 758 }, 759 [NLMPROC_FREE_ALL] = { 760 .pc_func = nlmsvc_proc_free_all, 761 .pc_decode = nlmsvc_decode_notify, 762 .pc_encode = nlmsvc_encode_void, 763 .pc_argsize = sizeof(struct nlm_args), 764 .pc_ressize = sizeof(struct nlm_void), 765 .pc_xdrressize = 0, 766 .pc_name = "FREE_ALL", 767 }, 768 }; 769