fs/lockd/svc4proc.c

   1 /*
   2  * linux/fs/lockd/svc4proc.c
   3  *
   4  * Lockd server procedures. We don't implement the NLM_*_RES
   5  * procedures because we don't use the async procedures.
   6  *
   7  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
   8  */
   9
  10 #include <linux/types.h>
  11 #include <linux/time.h>
  12 #include <linux/lockd/lockd.h>
  13 #include <linux/lockd/share.h>
  14 #include <linux/sunrpc/svc_xprt.h>
  15
  16 #define NLMDBG_FACILITY         NLMDBG_CLIENT
  17
  18 /*
  19  * Obtain client and file from arguments
  20  */
  21 static __be32
  22 nlm4svc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp,
  23                         struct nlm_host **hostp, struct nlm_file **filp)
  24 {
  25         struct nlm_host         *host = NULL;
  26         struct nlm_file         *file = NULL;
  27         struct nlm_lock         *lock = &argp->lock;
  28         __be32                  error = 0;
  29
  30         /* nfsd callbacks must have been installed for this procedure */
  31         if (!nlmsvc_ops)
  32                 return nlm_lck_denied_nolocks;
  33
  34         /* Obtain host handle */
  35         if (!(host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len))
  36          || (argp->monitor && nsm_monitor(host) < 0))
  37                 goto no_locks;
  38         *hostp = host;
  39
  40         /* Obtain file pointer. Not used by FREE_ALL call. */
  41         if (filp != NULL) {
  42                 if ((error = nlm_lookup_file(rqstp, &file, &lock->fh)) != 0)
  43                         goto no_locks;
  44                 *filp = file;
  45
  46                 /* Set up the missing parts of the file_lock structure */
  47                 lock->fl.fl_file  = file->f_file;
  48                 lock->fl.fl_owner = (fl_owner_t) host;
  49                 lock->fl.fl_lmops = &nlmsvc_lock_operations;
  50         }
  51
  52         return 0;
  53
  54 no_locks:
  55         nlmsvc_release_host(host);
  56         if (error)
  57                 return error;
  58         return nlm_lck_denied_nolocks;
  59 }
  60
  61 /*
  62  * NULL: Test for presence of service
  63  */
  64 static __be32
  65 nlm4svc_proc_null(struct svc_rqst *rqstp)
  66 {
  67         dprintk("lockd: NULL          called\n");
  68         return rpc_success;
  69 }
  70
  71 /*
  72  * TEST: Check for conflicting lock
  73  */
  74 static __be32
  75 __nlm4svc_proc_test(struct svc_rqst *rqstp, struct nlm_res *resp)
  76 {
  77         struct nlm_args *argp = rqstp->rq_argp;
  78         struct nlm_host *host;
  79         struct nlm_file *file;
  80         __be32 rc = rpc_success;
  81
  82         dprintk("lockd: TEST4        called\n");
  83         resp->cookie = argp->cookie;
  84
  85         /* Obtain client and file */
  86         if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
  87                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
  88
  89         /* Now check for conflicting locks */
  90         resp->status = nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie);
  91         if (resp->status == nlm_drop_reply)
  92                 rc = rpc_drop_reply;
  93         else
  94                 dprintk("lockd: TEST4        status %d\n", ntohl(resp->status));
  95
  96         nlmsvc_release_host(host);
  97         nlm_release_file(file);
  98         return rc;
  99 }
 100
 101 static __be32
 102 nlm4svc_proc_test(struct svc_rqst *rqstp)
 103 {
 104         return __nlm4svc_proc_test(rqstp, rqstp->rq_resp);
 105 }
 106
 107 static __be32
 108 __nlm4svc_proc_lock(struct svc_rqst *rqstp, struct nlm_res *resp)
 109 {
 110         struct nlm_args *argp = rqstp->rq_argp;
 111         struct nlm_host *host;
 112         struct nlm_file *file;
 113         __be32 rc = rpc_success;
 114
 115         dprintk("lockd: LOCK          called\n");
 116
 117         resp->cookie = argp->cookie;
 118
 119         /* Obtain client and file */
 120         if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
 121                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 122
 123 #if 0
 124         /* If supplied state doesn't match current state, we assume it's
 125          * an old request that time-warped somehow. Any error return would
 126          * do in this case because it's irrelevant anyway.
 127          *
 128          * NB: We don't retrieve the remote host's state yet.
 129          */
 130         if (host->h_nsmstate && host->h_nsmstate != argp->state) {
 131                 resp->status = nlm_lck_denied_nolocks;
 132         } else
 133 #endif
 134
 135         /* Now try to lock the file */
 136         resp->status = nlmsvc_lock(rqstp, file, host, &argp->lock,
 137                                         argp->block, &argp->cookie,
 138                                         argp->reclaim);
 139         if (resp->status == nlm_drop_reply)
 140                 rc = rpc_drop_reply;
 141         else
 142                 dprintk("lockd: LOCK         status %d\n", ntohl(resp->status));
 143
 144         nlmsvc_release_host(host);
 145         nlm_release_file(file);
 146         return rc;
 147 }
 148
 149 static __be32
 150 nlm4svc_proc_lock(struct svc_rqst *rqstp)
 151 {
 152         return __nlm4svc_proc_lock(rqstp, rqstp->rq_resp);
 153 }
 154
 155 static __be32
 156 __nlm4svc_proc_cancel(struct svc_rqst *rqstp, struct nlm_res *resp)
 157 {
 158         struct nlm_args *argp = rqstp->rq_argp;
 159         struct nlm_host *host;
 160         struct nlm_file *file;
 161
 162         dprintk("lockd: CANCEL        called\n");
 163
 164         resp->cookie = argp->cookie;
 165
 166         /* Don't accept requests during grace period */
 167         if (locks_in_grace(SVC_NET(rqstp))) {
 168                 resp->status = nlm_lck_denied_grace_period;
 169                 return rpc_success;
 170         }
 171
 172         /* Obtain client and file */
 173         if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
 174                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 175
 176         /* Try to cancel request. */
 177         resp->status = nlmsvc_cancel_blocked(SVC_NET(rqstp), file, &argp->lock);
 178
 179         dprintk("lockd: CANCEL        status %d\n", ntohl(resp->status));
 180         nlmsvc_release_host(host);
 181         nlm_release_file(file);
 182         return rpc_success;
 183 }
 184
 185 static __be32
 186 nlm4svc_proc_cancel(struct svc_rqst *rqstp)
 187 {
 188         return __nlm4svc_proc_cancel(rqstp, rqstp->rq_resp);
 189 }
 190
 191 /*
 192  * UNLOCK: release a lock
 193  */
 194 static __be32
 195 __nlm4svc_proc_unlock(struct svc_rqst *rqstp, struct nlm_res *resp)
 196 {
 197         struct nlm_args *argp = rqstp->rq_argp;
 198         struct nlm_host *host;
 199         struct nlm_file *file;
 200
 201         dprintk("lockd: UNLOCK        called\n");
 202
 203         resp->cookie = argp->cookie;
 204
 205         /* Don't accept new lock requests during grace period */
 206         if (locks_in_grace(SVC_NET(rqstp))) {
 207                 resp->status = nlm_lck_denied_grace_period;
 208                 return rpc_success;
 209         }
 210
 211         /* Obtain client and file */
 212         if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
 213                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 214
 215         /* Now try to remove the lock */
 216         resp->status = nlmsvc_unlock(SVC_NET(rqstp), file, &argp->lock);
 217
 218         dprintk("lockd: UNLOCK        status %d\n", ntohl(resp->status));
 219         nlmsvc_release_host(host);
 220         nlm_release_file(file);
 221         return rpc_success;
 222 }
 223
 224 static __be32
 225 nlm4svc_proc_unlock(struct svc_rqst *rqstp)
 226 {
 227         return __nlm4svc_proc_unlock(rqstp, rqstp->rq_resp);
 228 }
 229
 230 /*
 231  * GRANTED: A server calls us to tell that a process' lock request
 232  * was granted
 233  */
 234 static __be32
 235 __nlm4svc_proc_granted(struct svc_rqst *rqstp, struct nlm_res *resp)
 236 {
 237         struct nlm_args *argp = rqstp->rq_argp;
 238
 239         resp->cookie = argp->cookie;
 240
 241         dprintk("lockd: GRANTED       called\n");
 242         resp->status = nlmclnt_grant(svc_addr(rqstp), &argp->lock);
 243         dprintk("lockd: GRANTED       status %d\n", ntohl(resp->status));
 244         return rpc_success;
 245 }
 246
 247 static __be32
 248 nlm4svc_proc_granted(struct svc_rqst *rqstp)
 249 {
 250         return __nlm4svc_proc_granted(rqstp, rqstp->rq_resp);
 251 }
 252
 253 /*
 254  * This is the generic lockd callback for async RPC calls
 255  */
 256 static void nlm4svc_callback_exit(struct rpc_task *task, void *data)
 257 {
 258         dprintk("lockd: %5u callback returned %d\n", task->tk_pid,
 259                         -task->tk_status);
 260 }
 261
 262 static void nlm4svc_callback_release(void *data)
 263 {
 264         nlmsvc_release_call(data);
 265 }
 266
 267 static const struct rpc_call_ops nlm4svc_callback_ops = {
 268         .rpc_call_done = nlm4svc_callback_exit,
 269         .rpc_release = nlm4svc_callback_release,
 270 };
 271
 272 /*
 273  * `Async' versions of the above service routines. They aren't really,
 274  * because we send the callback before the reply proper. I hope this
 275  * doesn't break any clients.
 276  */
 277 static __be32 nlm4svc_callback(struct svc_rqst *rqstp, u32 proc,
 278                 __be32 (*func)(struct svc_rqst *,  struct nlm_res *))
 279 {
 280         struct nlm_args *argp = rqstp->rq_argp;
 281         struct nlm_host *host;
 282         struct nlm_rqst *call;
 283         __be32 stat;
 284
 285         host = nlmsvc_lookup_host(rqstp,
 286                                   argp->lock.caller,
 287                                   argp->lock.len);
 288         if (host == NULL)
 289                 return rpc_system_err;
 290
 291         call = nlm_alloc_call(host);
 292         nlmsvc_release_host(host);
 293         if (call == NULL)
 294                 return rpc_system_err;
 295
 296         stat = func(rqstp, &call->a_res);
 297         if (stat != 0) {
 298                 nlmsvc_release_call(call);
 299                 return stat;
 300         }
 301
 302         call->a_flags = RPC_TASK_ASYNC;
 303         if (nlm_async_reply(call, proc, &nlm4svc_callback_ops) < 0)
 304                 return rpc_system_err;
 305         return rpc_success;
 306 }
 307
 308 static __be32 nlm4svc_proc_test_msg(struct svc_rqst *rqstp)
 309 {
 310         dprintk("lockd: TEST_MSG      called\n");
 311         return nlm4svc_callback(rqstp, NLMPROC_TEST_RES, __nlm4svc_proc_test);
 312 }
 313
 314 static __be32 nlm4svc_proc_lock_msg(struct svc_rqst *rqstp)
 315 {
 316         dprintk("lockd: LOCK_MSG      called\n");
 317         return nlm4svc_callback(rqstp, NLMPROC_LOCK_RES, __nlm4svc_proc_lock);
 318 }
 319
 320 static __be32 nlm4svc_proc_cancel_msg(struct svc_rqst *rqstp)
 321 {
 322         dprintk("lockd: CANCEL_MSG    called\n");
 323         return nlm4svc_callback(rqstp, NLMPROC_CANCEL_RES, __nlm4svc_proc_cancel);
 324 }
 325
 326 static __be32 nlm4svc_proc_unlock_msg(struct svc_rqst *rqstp)
 327 {
 328         dprintk("lockd: UNLOCK_MSG    called\n");
 329         return nlm4svc_callback(rqstp, NLMPROC_UNLOCK_RES, __nlm4svc_proc_unlock);
 330 }
 331
 332 static __be32 nlm4svc_proc_granted_msg(struct svc_rqst *rqstp)
 333 {
 334         dprintk("lockd: GRANTED_MSG   called\n");
 335         return nlm4svc_callback(rqstp, NLMPROC_GRANTED_RES, __nlm4svc_proc_granted);
 336 }
 337
 338 /*
 339  * SHARE: create a DOS share or alter existing share.
 340  */
 341 static __be32
 342 nlm4svc_proc_share(struct svc_rqst *rqstp)
 343 {
 344         struct nlm_args *argp = rqstp->rq_argp;
 345         struct nlm_res *resp = rqstp->rq_resp;
 346         struct nlm_host *host;
 347         struct nlm_file *file;
 348
 349         dprintk("lockd: SHARE         called\n");
 350
 351         resp->cookie = argp->cookie;
 352
 353         /* Don't accept new lock requests during grace period */
 354         if (locks_in_grace(SVC_NET(rqstp)) && !argp->reclaim) {
 355                 resp->status = nlm_lck_denied_grace_period;
 356                 return rpc_success;
 357         }
 358
 359         /* Obtain client and file */
 360         if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
 361                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 362
 363         /* Now try to create the share */
 364         resp->status = nlmsvc_share_file(host, file, argp);
 365
 366         dprintk("lockd: SHARE         status %d\n", ntohl(resp->status));
 367         nlmsvc_release_host(host);
 368         nlm_release_file(file);
 369         return rpc_success;
 370 }
 371
 372 /*
 373  * UNSHARE: Release a DOS share.
 374  */
 375 static __be32
 376 nlm4svc_proc_unshare(struct svc_rqst *rqstp)
 377 {
 378         struct nlm_args *argp = rqstp->rq_argp;
 379         struct nlm_res *resp = rqstp->rq_resp;
 380         struct nlm_host *host;
 381         struct nlm_file *file;
 382
 383         dprintk("lockd: UNSHARE       called\n");
 384
 385         resp->cookie = argp->cookie;
 386
 387         /* Don't accept requests during grace period */
 388         if (locks_in_grace(SVC_NET(rqstp))) {
 389                 resp->status = nlm_lck_denied_grace_period;
 390                 return rpc_success;
 391         }
 392
 393         /* Obtain client and file */
 394         if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
 395                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 396
 397         /* Now try to lock the file */
 398         resp->status = nlmsvc_unshare_file(host, file, argp);
 399
 400         dprintk("lockd: UNSHARE       status %d\n", ntohl(resp->status));
 401         nlmsvc_release_host(host);
 402         nlm_release_file(file);
 403         return rpc_success;
 404 }
 405
 406 /*
 407  * NM_LOCK: Create an unmonitored lock
 408  */
 409 static __be32
 410 nlm4svc_proc_nm_lock(struct svc_rqst *rqstp)
 411 {
 412         struct nlm_args *argp = rqstp->rq_argp;
 413
 414         dprintk("lockd: NM_LOCK       called\n");
 415
 416         argp->monitor = 0;              /* just clean the monitor flag */
 417         return nlm4svc_proc_lock(rqstp);
 418 }
 419
 420 /*
 421  * FREE_ALL: Release all locks and shares held by client
 422  */
 423 static __be32
 424 nlm4svc_proc_free_all(struct svc_rqst *rqstp)
 425 {
 426         struct nlm_args *argp = rqstp->rq_argp;
 427         struct nlm_host *host;
 428
 429         /* Obtain client */
 430         if (nlm4svc_retrieve_args(rqstp, argp, &host, NULL))
 431                 return rpc_success;
 432
 433         nlmsvc_free_host_resources(host);
 434         nlmsvc_release_host(host);
 435         return rpc_success;
 436 }
 437
 438 /*
 439  * SM_NOTIFY: private callback from statd (not part of official NLM proto)
 440  */
 441 static __be32
 442 nlm4svc_proc_sm_notify(struct svc_rqst *rqstp)
 443 {
 444         struct nlm_reboot *argp = rqstp->rq_argp;
 445
 446         dprintk("lockd: SM_NOTIFY     called\n");
 447
 448         if (!nlm_privileged_requester(rqstp)) {
 449                 char buf[RPC_MAX_ADDRBUFLEN];
 450                 printk(KERN_WARNING "lockd: rejected NSM callback from %s\n",
 451                                 svc_print_addr(rqstp, buf, sizeof(buf)));
 452                 return rpc_system_err;
 453         }
 454
 455         nlm_host_rebooted(SVC_NET(rqstp), argp);
 456         return rpc_success;
 457 }
 458
 459 /*
 460  * client sent a GRANTED_RES, let's remove the associated block
 461  */
 462 static __be32
 463 nlm4svc_proc_granted_res(struct svc_rqst *rqstp)
 464 {
 465         struct nlm_res *argp = rqstp->rq_argp;
 466
 467         if (!nlmsvc_ops)
 468                 return rpc_success;
 469
 470         dprintk("lockd: GRANTED_RES   called\n");
 471
 472         nlmsvc_grant_reply(&argp->cookie, argp->status);
 473         return rpc_success;
 474 }
 475
 476
 477 /*
 478  * NLM Server procedures.
 479  */
 480
 481 #define nlm4svc_encode_norep    nlm4svc_encode_void
 482 #define nlm4svc_decode_norep    nlm4svc_decode_void
 483 #define nlm4svc_decode_testres  nlm4svc_decode_void
 484 #define nlm4svc_decode_lockres  nlm4svc_decode_void
 485 #define nlm4svc_decode_unlockres        nlm4svc_decode_void
 486 #define nlm4svc_decode_cancelres        nlm4svc_decode_void
 487 #define nlm4svc_decode_grantedres       nlm4svc_decode_void
 488
 489 #define nlm4svc_proc_none       nlm4svc_proc_null
 490 #define nlm4svc_proc_test_res   nlm4svc_proc_null
 491 #define nlm4svc_proc_lock_res   nlm4svc_proc_null
 492 #define nlm4svc_proc_cancel_res nlm4svc_proc_null
 493 #define nlm4svc_proc_unlock_res nlm4svc_proc_null
 494
 495 struct nlm_void                 { int dummy; };
 496
 497 #define PROC(name, xargt, xrest, argt, rest, respsize)  \
 498  { .pc_func     = nlm4svc_proc_##name,  \
 499    .pc_decode   = nlm4svc_decode_##xargt,       \
 500    .pc_encode   = nlm4svc_encode_##xrest,       \
 501    .pc_release  = NULL,                                 \
 502    .pc_argsize  = sizeof(struct nlm_##argt),            \
 503    .pc_ressize  = sizeof(struct nlm_##rest),            \
 504    .pc_xdrressize = respsize,                           \
 505  }
 506 #define Ck      (1+XDR_QUADLEN(NLM_MAXCOOKIELEN))       /* cookie */
 507 #define No      (1+1024/4)                              /* netobj */
 508 #define St      1                                       /* status */
 509 #define Rg      4                                       /* range (offset + length) */
 510 const struct svc_procedure nlmsvc_procedures4[] = {
 511   PROC(null,            void,           void,           void,   void, 1),
 512   PROC(test,            testargs,       testres,        args,   res, Ck+St+2+No+Rg),
 513   PROC(lock,            lockargs,       res,            args,   res, Ck+St),
 514   PROC(cancel,          cancargs,       res,            args,   res, Ck+St),
 515   PROC(unlock,          unlockargs,     res,            args,   res, Ck+St),
 516   PROC(granted,         testargs,       res,            args,   res, Ck+St),
 517   PROC(test_msg,        testargs,       norep,          args,   void, 1),
 518   PROC(lock_msg,        lockargs,       norep,          args,   void, 1),
 519   PROC(cancel_msg,      cancargs,       norep,          args,   void, 1),
 520   PROC(unlock_msg,      unlockargs,     norep,          args,   void, 1),
 521   PROC(granted_msg,     testargs,       norep,          args,   void, 1),
 522   PROC(test_res,        testres,        norep,          res,    void, 1),
 523   PROC(lock_res,        lockres,        norep,          res,    void, 1),
 524   PROC(cancel_res,      cancelres,      norep,          res,    void, 1),
 525   PROC(unlock_res,      unlockres,      norep,          res,    void, 1),
 526   PROC(granted_res,     res,            norep,          res,    void, 1),
 527   /* statd callback */
 528   PROC(sm_notify,       reboot,         void,           reboot, void, 1),
 529   PROC(none,            void,           void,           void,   void, 0),
 530   PROC(none,            void,           void,           void,   void, 0),
 531   PROC(none,            void,           void,           void,   void, 0),
 532   PROC(share,           shareargs,      shareres,       args,   res, Ck+St+1),
 533   PROC(unshare,         shareargs,      shareres,       args,   res, Ck+St+1),
 534   PROC(nm_lock,         lockargs,       res,            args,   res, Ck+St),
 535   PROC(free_all,        notify,         void,           args,   void, 1),
 536
 537 };