fs/lockd/svcproc.c

   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_owner = (fl_owner_t) host;
  80                 lock->fl.fl_lmops = &nlmsvc_lock_operations;
  81         }
  82
  83         return 0;
  84
  85 no_locks:
  86         nlmsvc_release_host(host);
  87         if (error)
  88                 return error;
  89         return nlm_lck_denied_nolocks;
  90 }
  91
  92 /*
  93  * NULL: Test for presence of service
  94  */
  95 static __be32
  96 nlmsvc_proc_null(struct svc_rqst *rqstp)
  97 {
  98         dprintk("lockd: NULL          called\n");
  99         return rpc_success;
 100 }
 101
 102 /*
 103  * TEST: Check for conflicting lock
 104  */
 105 static __be32
 106 __nlmsvc_proc_test(struct svc_rqst *rqstp, struct nlm_res *resp)
 107 {
 108         struct nlm_args *argp = rqstp->rq_argp;
 109         struct nlm_host *host;
 110         struct nlm_file *file;
 111         __be32 rc = rpc_success;
 112
 113         dprintk("lockd: TEST          called\n");
 114         resp->cookie = argp->cookie;
 115
 116         /* Obtain client and file */
 117         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
 118                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 119
 120         /* Now check for conflicting locks */
 121         resp->status = cast_status(nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie));
 122         if (resp->status == nlm_drop_reply)
 123                 rc = rpc_drop_reply;
 124         else
 125                 dprintk("lockd: TEST          status %d vers %d\n",
 126                         ntohl(resp->status), rqstp->rq_vers);
 127
 128         nlmsvc_release_host(host);
 129         nlm_release_file(file);
 130         return rc;
 131 }
 132
 133 static __be32
 134 nlmsvc_proc_test(struct svc_rqst *rqstp)
 135 {
 136         return __nlmsvc_proc_test(rqstp, rqstp->rq_resp);
 137 }
 138
 139 static __be32
 140 __nlmsvc_proc_lock(struct svc_rqst *rqstp, struct nlm_res *resp)
 141 {
 142         struct nlm_args *argp = rqstp->rq_argp;
 143         struct nlm_host *host;
 144         struct nlm_file *file;
 145         __be32 rc = rpc_success;
 146
 147         dprintk("lockd: LOCK          called\n");
 148
 149         resp->cookie = argp->cookie;
 150
 151         /* Obtain client and file */
 152         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
 153                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 154
 155 #if 0
 156         /* If supplied state doesn't match current state, we assume it's
 157          * an old request that time-warped somehow. Any error return would
 158          * do in this case because it's irrelevant anyway.
 159          *
 160          * NB: We don't retrieve the remote host's state yet.
 161          */
 162         if (host->h_nsmstate && host->h_nsmstate != argp->state) {
 163                 resp->status = nlm_lck_denied_nolocks;
 164         } else
 165 #endif
 166
 167         /* Now try to lock the file */
 168         resp->status = cast_status(nlmsvc_lock(rqstp, file, host, &argp->lock,
 169                                                argp->block, &argp->cookie,
 170                                                argp->reclaim));
 171         if (resp->status == nlm_drop_reply)
 172                 rc = rpc_drop_reply;
 173         else
 174                 dprintk("lockd: LOCK         status %d\n", ntohl(resp->status));
 175
 176         nlmsvc_release_host(host);
 177         nlm_release_file(file);
 178         return rc;
 179 }
 180
 181 static __be32
 182 nlmsvc_proc_lock(struct svc_rqst *rqstp)
 183 {
 184         return __nlmsvc_proc_lock(rqstp, rqstp->rq_resp);
 185 }
 186
 187 static __be32
 188 __nlmsvc_proc_cancel(struct svc_rqst *rqstp, struct nlm_res *resp)
 189 {
 190         struct nlm_args *argp = rqstp->rq_argp;
 191         struct nlm_host *host;
 192         struct nlm_file *file;
 193         struct net *net = SVC_NET(rqstp);
 194
 195         dprintk("lockd: CANCEL        called\n");
 196
 197         resp->cookie = argp->cookie;
 198
 199         /* Don't accept requests during grace period */
 200         if (locks_in_grace(net)) {
 201                 resp->status = nlm_lck_denied_grace_period;
 202                 return rpc_success;
 203         }
 204
 205         /* Obtain client and file */
 206         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
 207                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 208
 209         /* Try to cancel request. */
 210         resp->status = cast_status(nlmsvc_cancel_blocked(net, file, &argp->lock));
 211
 212         dprintk("lockd: CANCEL        status %d\n", ntohl(resp->status));
 213         nlmsvc_release_host(host);
 214         nlm_release_file(file);
 215         return rpc_success;
 216 }
 217
 218 static __be32
 219 nlmsvc_proc_cancel(struct svc_rqst *rqstp)
 220 {
 221         return __nlmsvc_proc_cancel(rqstp, rqstp->rq_resp);
 222 }
 223
 224 /*
 225  * UNLOCK: release a lock
 226  */
 227 static __be32
 228 __nlmsvc_proc_unlock(struct svc_rqst *rqstp, struct nlm_res *resp)
 229 {
 230         struct nlm_args *argp = rqstp->rq_argp;
 231         struct nlm_host *host;
 232         struct nlm_file *file;
 233         struct net *net = SVC_NET(rqstp);
 234
 235         dprintk("lockd: UNLOCK        called\n");
 236
 237         resp->cookie = argp->cookie;
 238
 239         /* Don't accept new lock requests during grace period */
 240         if (locks_in_grace(net)) {
 241                 resp->status = nlm_lck_denied_grace_period;
 242                 return rpc_success;
 243         }
 244
 245         /* Obtain client and file */
 246         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
 247                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 248
 249         /* Now try to remove the lock */
 250         resp->status = cast_status(nlmsvc_unlock(net, file, &argp->lock));
 251
 252         dprintk("lockd: UNLOCK        status %d\n", ntohl(resp->status));
 253         nlmsvc_release_host(host);
 254         nlm_release_file(file);
 255         return rpc_success;
 256 }
 257
 258 static __be32
 259 nlmsvc_proc_unlock(struct svc_rqst *rqstp)
 260 {
 261         return __nlmsvc_proc_unlock(rqstp, rqstp->rq_resp);
 262 }
 263
 264 /*
 265  * GRANTED: A server calls us to tell that a process' lock request
 266  * was granted
 267  */
 268 static __be32
 269 __nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_res *resp)
 270 {
 271         struct nlm_args *argp = rqstp->rq_argp;
 272
 273         resp->cookie = argp->cookie;
 274
 275         dprintk("lockd: GRANTED       called\n");
 276         resp->status = nlmclnt_grant(svc_addr(rqstp), &argp->lock);
 277         dprintk("lockd: GRANTED       status %d\n", ntohl(resp->status));
 278         return rpc_success;
 279 }
 280
 281 static __be32
 282 nlmsvc_proc_granted(struct svc_rqst *rqstp)
 283 {
 284         return __nlmsvc_proc_granted(rqstp, rqstp->rq_resp);
 285 }
 286
 287 /*
 288  * This is the generic lockd callback for async RPC calls
 289  */
 290 static void nlmsvc_callback_exit(struct rpc_task *task, void *data)
 291 {
 292         dprintk("lockd: %5u callback returned %d\n", task->tk_pid,
 293                         -task->tk_status);
 294 }
 295
 296 void nlmsvc_release_call(struct nlm_rqst *call)
 297 {
 298         if (!atomic_dec_and_test(&call->a_count))
 299                 return;
 300         nlmsvc_release_host(call->a_host);
 301         kfree(call);
 302 }
 303
 304 static void nlmsvc_callback_release(void *data)
 305 {
 306         nlmsvc_release_call(data);
 307 }
 308
 309 static const struct rpc_call_ops nlmsvc_callback_ops = {
 310         .rpc_call_done = nlmsvc_callback_exit,
 311         .rpc_release = nlmsvc_callback_release,
 312 };
 313
 314 /*
 315  * `Async' versions of the above service routines. They aren't really,
 316  * because we send the callback before the reply proper. I hope this
 317  * doesn't break any clients.
 318  */
 319 static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc,
 320                 __be32 (*func)(struct svc_rqst *, struct nlm_res *))
 321 {
 322         struct nlm_args *argp = rqstp->rq_argp;
 323         struct nlm_host *host;
 324         struct nlm_rqst *call;
 325         __be32 stat;
 326
 327         host = nlmsvc_lookup_host(rqstp,
 328                                   argp->lock.caller,
 329                                   argp->lock.len);
 330         if (host == NULL)
 331                 return rpc_system_err;
 332
 333         call = nlm_alloc_call(host);
 334         nlmsvc_release_host(host);
 335         if (call == NULL)
 336                 return rpc_system_err;
 337
 338         stat = func(rqstp, &call->a_res);
 339         if (stat != 0) {
 340                 nlmsvc_release_call(call);
 341                 return stat;
 342         }
 343
 344         call->a_flags = RPC_TASK_ASYNC;
 345         if (nlm_async_reply(call, proc, &nlmsvc_callback_ops) < 0)
 346                 return rpc_system_err;
 347         return rpc_success;
 348 }
 349
 350 static __be32 nlmsvc_proc_test_msg(struct svc_rqst *rqstp)
 351 {
 352         dprintk("lockd: TEST_MSG      called\n");
 353         return nlmsvc_callback(rqstp, NLMPROC_TEST_RES, __nlmsvc_proc_test);
 354 }
 355
 356 static __be32 nlmsvc_proc_lock_msg(struct svc_rqst *rqstp)
 357 {
 358         dprintk("lockd: LOCK_MSG      called\n");
 359         return nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, __nlmsvc_proc_lock);
 360 }
 361
 362 static __be32 nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp)
 363 {
 364         dprintk("lockd: CANCEL_MSG    called\n");
 365         return nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, __nlmsvc_proc_cancel);
 366 }
 367
 368 static __be32
 369 nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp)
 370 {
 371         dprintk("lockd: UNLOCK_MSG    called\n");
 372         return nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, __nlmsvc_proc_unlock);
 373 }
 374
 375 static __be32
 376 nlmsvc_proc_granted_msg(struct svc_rqst *rqstp)
 377 {
 378         dprintk("lockd: GRANTED_MSG   called\n");
 379         return nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, __nlmsvc_proc_granted);
 380 }
 381
 382 /*
 383  * SHARE: create a DOS share or alter existing share.
 384  */
 385 static __be32
 386 nlmsvc_proc_share(struct svc_rqst *rqstp)
 387 {
 388         struct nlm_args *argp = rqstp->rq_argp;
 389         struct nlm_res *resp = rqstp->rq_resp;
 390         struct nlm_host *host;
 391         struct nlm_file *file;
 392
 393         dprintk("lockd: SHARE         called\n");
 394
 395         resp->cookie = argp->cookie;
 396
 397         /* Don't accept new lock requests during grace period */
 398         if (locks_in_grace(SVC_NET(rqstp)) && !argp->reclaim) {
 399                 resp->status = nlm_lck_denied_grace_period;
 400                 return rpc_success;
 401         }
 402
 403         /* Obtain client and file */
 404         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
 405                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 406
 407         /* Now try to create the share */
 408         resp->status = cast_status(nlmsvc_share_file(host, file, argp));
 409
 410         dprintk("lockd: SHARE         status %d\n", ntohl(resp->status));
 411         nlmsvc_release_host(host);
 412         nlm_release_file(file);
 413         return rpc_success;
 414 }
 415
 416 /*
 417  * UNSHARE: Release a DOS share.
 418  */
 419 static __be32
 420 nlmsvc_proc_unshare(struct svc_rqst *rqstp)
 421 {
 422         struct nlm_args *argp = rqstp->rq_argp;
 423         struct nlm_res *resp = rqstp->rq_resp;
 424         struct nlm_host *host;
 425         struct nlm_file *file;
 426
 427         dprintk("lockd: UNSHARE       called\n");
 428
 429         resp->cookie = argp->cookie;
 430
 431         /* Don't accept requests during grace period */
 432         if (locks_in_grace(SVC_NET(rqstp))) {
 433                 resp->status = nlm_lck_denied_grace_period;
 434                 return rpc_success;
 435         }
 436
 437         /* Obtain client and file */
 438         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
 439                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 440
 441         /* Now try to unshare the file */
 442         resp->status = cast_status(nlmsvc_unshare_file(host, file, argp));
 443
 444         dprintk("lockd: UNSHARE       status %d\n", ntohl(resp->status));
 445         nlmsvc_release_host(host);
 446         nlm_release_file(file);
 447         return rpc_success;
 448 }
 449
 450 /*
 451  * NM_LOCK: Create an unmonitored lock
 452  */
 453 static __be32
 454 nlmsvc_proc_nm_lock(struct svc_rqst *rqstp)
 455 {
 456         struct nlm_args *argp = rqstp->rq_argp;
 457
 458         dprintk("lockd: NM_LOCK       called\n");
 459
 460         argp->monitor = 0;              /* just clean the monitor flag */
 461         return nlmsvc_proc_lock(rqstp);
 462 }
 463
 464 /*
 465  * FREE_ALL: Release all locks and shares held by client
 466  */
 467 static __be32
 468 nlmsvc_proc_free_all(struct svc_rqst *rqstp)
 469 {
 470         struct nlm_args *argp = rqstp->rq_argp;
 471         struct nlm_host *host;
 472
 473         /* Obtain client */
 474         if (nlmsvc_retrieve_args(rqstp, argp, &host, NULL))
 475                 return rpc_success;
 476
 477         nlmsvc_free_host_resources(host);
 478         nlmsvc_release_host(host);
 479         return rpc_success;
 480 }
 481
 482 /*
 483  * SM_NOTIFY: private callback from statd (not part of official NLM proto)
 484  */
 485 static __be32
 486 nlmsvc_proc_sm_notify(struct svc_rqst *rqstp)
 487 {
 488         struct nlm_reboot *argp = rqstp->rq_argp;
 489
 490         dprintk("lockd: SM_NOTIFY     called\n");
 491
 492         if (!nlm_privileged_requester(rqstp)) {
 493                 char buf[RPC_MAX_ADDRBUFLEN];
 494                 printk(KERN_WARNING "lockd: rejected NSM callback from %s\n",
 495                                 svc_print_addr(rqstp, buf, sizeof(buf)));
 496                 return rpc_system_err;
 497         }
 498
 499         nlm_host_rebooted(SVC_NET(rqstp), argp);
 500         return rpc_success;
 501 }
 502
 503 /*
 504  * client sent a GRANTED_RES, let's remove the associated block
 505  */
 506 static __be32
 507 nlmsvc_proc_granted_res(struct svc_rqst *rqstp)
 508 {
 509         struct nlm_res *argp = rqstp->rq_argp;
 510
 511         if (!nlmsvc_ops)
 512                 return rpc_success;
 513
 514         dprintk("lockd: GRANTED_RES   called\n");
 515
 516         nlmsvc_grant_reply(&argp->cookie, argp->status);
 517         return rpc_success;
 518 }
 519
 520 /*
 521  * NLM Server procedures.
 522  */
 523
 524 #define nlmsvc_encode_norep     nlmsvc_encode_void
 525 #define nlmsvc_decode_norep     nlmsvc_decode_void
 526 #define nlmsvc_decode_testres   nlmsvc_decode_void
 527 #define nlmsvc_decode_lockres   nlmsvc_decode_void
 528 #define nlmsvc_decode_unlockres nlmsvc_decode_void
 529 #define nlmsvc_decode_cancelres nlmsvc_decode_void
 530 #define nlmsvc_decode_grantedres        nlmsvc_decode_void
 531
 532 #define nlmsvc_proc_none        nlmsvc_proc_null
 533 #define nlmsvc_proc_test_res    nlmsvc_proc_null
 534 #define nlmsvc_proc_lock_res    nlmsvc_proc_null
 535 #define nlmsvc_proc_cancel_res  nlmsvc_proc_null
 536 #define nlmsvc_proc_unlock_res  nlmsvc_proc_null
 537
 538 struct nlm_void                 { int dummy; };
 539
 540 #define PROC(name, xargt, xrest, argt, rest, respsize)  \
 541  { .pc_func     = nlmsvc_proc_##name,                   \
 542    .pc_decode   = nlmsvc_decode_##xargt,                \
 543    .pc_encode   = nlmsvc_encode_##xrest,                \
 544    .pc_release  = NULL,                                 \
 545    .pc_argsize  = sizeof(struct nlm_##argt),            \
 546    .pc_ressize  = sizeof(struct nlm_##rest),            \
 547    .pc_xdrressize = respsize,                           \
 548  }
 549
 550 #define Ck      (1+XDR_QUADLEN(NLM_MAXCOOKIELEN))       /* cookie */
 551 #define St      1                               /* status */
 552 #define No      (1+1024/4)                      /* Net Obj */
 553 #define Rg      2                               /* range - offset + size */
 554
 555 const struct svc_procedure nlmsvc_procedures[] = {
 556   PROC(null,            void,           void,           void,   void, 1),
 557   PROC(test,            testargs,       testres,        args,   res, Ck+St+2+No+Rg),
 558   PROC(lock,            lockargs,       res,            args,   res, Ck+St),
 559   PROC(cancel,          cancargs,       res,            args,   res, Ck+St),
 560   PROC(unlock,          unlockargs,     res,            args,   res, Ck+St),
 561   PROC(granted,         testargs,       res,            args,   res, Ck+St),
 562   PROC(test_msg,        testargs,       norep,          args,   void, 1),
 563   PROC(lock_msg,        lockargs,       norep,          args,   void, 1),
 564   PROC(cancel_msg,      cancargs,       norep,          args,   void, 1),
 565   PROC(unlock_msg,      unlockargs,     norep,          args,   void, 1),
 566   PROC(granted_msg,     testargs,       norep,          args,   void, 1),
 567   PROC(test_res,        testres,        norep,          res,    void, 1),
 568   PROC(lock_res,        lockres,        norep,          res,    void, 1),
 569   PROC(cancel_res,      cancelres,      norep,          res,    void, 1),
 570   PROC(unlock_res,      unlockres,      norep,          res,    void, 1),
 571   PROC(granted_res,     res,            norep,          res,    void, 1),
 572   /* statd callback */
 573   PROC(sm_notify,       reboot,         void,           reboot, void, 1),
 574   PROC(none,            void,           void,           void,   void, 1),
 575   PROC(none,            void,           void,           void,   void, 1),
 576   PROC(none,            void,           void,           void,   void, 1),
 577   PROC(share,           shareargs,      shareres,       args,   res, Ck+St+1),
 578   PROC(unshare,         shareargs,      shareres,       args,   res, Ck+St+1),
 579   PROC(nm_lock,         lockargs,       res,            args,   res, Ck+St),
 580   PROC(free_all,        notify,         void,           args,   void, 0),
 581
 582 };