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