fs/lockd/svclock.c

   1 /*
   2  * linux/fs/lockd/svclock.c
   3  *
   4  * Handling of server-side locks, mostly of the blocked variety.
   5  * This is the ugliest part of lockd because we tread on very thin ice.
   6  * GRANT and CANCEL calls may get stuck, meet in mid-flight, etc.
   7  * IMNSHO introducing the grant callback into the NLM protocol was one
   8  * of the worst ideas Sun ever had. Except maybe for the idea of doing
   9  * NFS file locking at all.
  10  *
  11  * I'm trying hard to avoid race conditions by protecting most accesses
  12  * to a file's list of blocked locks through a semaphore. The global
  13  * list of blocked locks is not protected in this fashion however.
  14  * Therefore, some functions (such as the RPC callback for the async grant
  15  * call) move blocked locks towards the head of the list *while some other
  16  * process might be traversing it*. This should not be a problem in
  17  * practice, because this will only cause functions traversing the list
  18  * to visit some blocks twice.
  19  *
  20  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
  21  */
  22
  23 #include <linux/types.h>
  24 #include <linux/slab.h>
  25 #include <linux/errno.h>
  26 #include <linux/kernel.h>
  27 #include <linux/sched.h>
  28 #include <linux/sunrpc/clnt.h>
  29 #include <linux/sunrpc/svc.h>
  30 #include <linux/lockd/nlm.h>
  31 #include <linux/lockd/lockd.h>
  32 #include <linux/kthread.h>
  33
  34 #define NLMDBG_FACILITY         NLMDBG_SVCLOCK
  35
  36 #ifdef CONFIG_LOCKD_V4
  37 #define nlm_deadlock    nlm4_deadlock
  38 #else
  39 #define nlm_deadlock    nlm_lck_denied
  40 #endif
  41
  42 static void nlmsvc_release_block(struct nlm_block *block);
  43 static void     nlmsvc_insert_block(struct nlm_block *block, unsigned long);
  44 static void     nlmsvc_remove_block(struct nlm_block *block);
  45
  46 static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock);
  47 static void nlmsvc_freegrantargs(struct nlm_rqst *call);
  48 static const struct rpc_call_ops nlmsvc_grant_ops;
  49
  50 /*
  51  * The list of blocked locks to retry
  52  */
  53 static LIST_HEAD(nlm_blocked);
  54 static DEFINE_SPINLOCK(nlm_blocked_lock);
  55
  56 /*
  57  * Insert a blocked lock into the global list
  58  */
  59 static void
  60 nlmsvc_insert_block_locked(struct nlm_block *block, unsigned long when)
  61 {
  62         struct nlm_block *b;
  63         struct list_head *pos;
  64
  65         dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block, when);
  66         if (list_empty(&block->b_list)) {
  67                 kref_get(&block->b_count);
  68         } else {
  69                 list_del_init(&block->b_list);
  70         }
  71
  72         pos = &nlm_blocked;
  73         if (when != NLM_NEVER) {
  74                 if ((when += jiffies) == NLM_NEVER)
  75                         when ++;
  76                 list_for_each(pos, &nlm_blocked) {
  77                         b = list_entry(pos, struct nlm_block, b_list);
  78                         if (time_after(b->b_when,when) || b->b_when == NLM_NEVER)
  79                                 break;
  80                 }
  81                 /* On normal exit from the loop, pos == &nlm_blocked,
  82                  * so we will be adding to the end of the list - good
  83                  */
  84         }
  85
  86         list_add_tail(&block->b_list, pos);
  87         block->b_when = when;
  88 }
  89
  90 static void nlmsvc_insert_block(struct nlm_block *block, unsigned long when)
  91 {
  92         spin_lock(&nlm_blocked_lock);
  93         nlmsvc_insert_block_locked(block, when);
  94         spin_unlock(&nlm_blocked_lock);
  95 }
  96
  97 /*
  98  * Remove a block from the global list
  99  */
 100 static inline void
 101 nlmsvc_remove_block(struct nlm_block *block)
 102 {
 103         if (!list_empty(&block->b_list)) {
 104                 spin_lock(&nlm_blocked_lock);
 105                 list_del_init(&block->b_list);
 106                 spin_unlock(&nlm_blocked_lock);
 107                 nlmsvc_release_block(block);
 108         }
 109 }
 110
 111 /*
 112  * Find a block for a given lock
 113  */
 114 static struct nlm_block *
 115 nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock)
 116 {
 117         struct nlm_block        *block;
 118         struct file_lock        *fl;
 119
 120         dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n",
 121                                 file, lock->fl.fl_pid,
 122                                 (long long)lock->fl.fl_start,
 123                                 (long long)lock->fl.fl_end, lock->fl.fl_type);
 124         list_for_each_entry(block, &nlm_blocked, b_list) {
 125                 fl = &block->b_call->a_args.lock.fl;
 126                 dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",
 127                                 block->b_file, fl->fl_pid,
 128                                 (long long)fl->fl_start,
 129                                 (long long)fl->fl_end, fl->fl_type,
 130                                 nlmdbg_cookie2a(&block->b_call->a_args.cookie));
 131                 if (block->b_file == file && nlm_compare_locks(fl, &lock->fl)) {
 132                         kref_get(&block->b_count);
 133                         return block;
 134                 }
 135         }
 136
 137         return NULL;
 138 }
 139
 140 static inline int nlm_cookie_match(struct nlm_cookie *a, struct nlm_cookie *b)
 141 {
 142         if (a->len != b->len)
 143                 return 0;
 144         if (memcmp(a->data, b->data, a->len))
 145                 return 0;
 146         return 1;
 147 }
 148
 149 /*
 150  * Find a block with a given NLM cookie.
 151  */
 152 static inline struct nlm_block *
 153 nlmsvc_find_block(struct nlm_cookie *cookie)
 154 {
 155         struct nlm_block *block;
 156
 157         list_for_each_entry(block, &nlm_blocked, b_list) {
 158                 if (nlm_cookie_match(&block->b_call->a_args.cookie,cookie))
 159                         goto found;
 160         }
 161
 162         return NULL;
 163
 164 found:
 165         dprintk("nlmsvc_find_block(%s): block=%p\n", nlmdbg_cookie2a(cookie), block);
 166         kref_get(&block->b_count);
 167         return block;
 168 }
 169
 170 /*
 171  * Create a block and initialize it.
 172  *
 173  * Note: we explicitly set the cookie of the grant reply to that of
 174  * the blocked lock request. The spec explicitly mentions that the client
 175  * should _not_ rely on the callback containing the same cookie as the
 176  * request, but (as I found out later) that's because some implementations
 177  * do just this. Never mind the standards comittees, they support our
 178  * logging industries.
 179  *
 180  * 10 years later: I hope we can safely ignore these old and broken
 181  * clients by now. Let's fix this so we can uniquely identify an incoming
 182  * GRANTED_RES message by cookie, without having to rely on the client's IP
 183  * address. --okir
 184  */
 185 static struct nlm_block *
 186 nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_host *host,
 187                     struct nlm_file *file, struct nlm_lock *lock,
 188                     struct nlm_cookie *cookie)
 189 {
 190         struct nlm_block        *block;
 191         struct nlm_rqst         *call = NULL;
 192
 193         nlm_get_host(host);
 194         call = nlm_alloc_call(host);
 195         if (call == NULL)
 196                 return NULL;
 197
 198         /* Allocate memory for block, and initialize arguments */
 199         block = kzalloc(sizeof(*block), GFP_KERNEL);
 200         if (block == NULL)
 201                 goto failed;
 202         kref_init(&block->b_count);
 203         INIT_LIST_HEAD(&block->b_list);
 204         INIT_LIST_HEAD(&block->b_flist);
 205
 206         if (!nlmsvc_setgrantargs(call, lock))
 207                 goto failed_free;
 208
 209         /* Set notifier function for VFS, and init args */
 210         call->a_args.lock.fl.fl_flags |= FL_SLEEP;
 211         call->a_args.lock.fl.fl_lmops = &nlmsvc_lock_operations;
 212         nlmclnt_next_cookie(&call->a_args.cookie);
 213
 214         dprintk("lockd: created block %p...\n", block);
 215
 216         /* Create and initialize the block */
 217         block->b_daemon = rqstp->rq_server;
 218         block->b_host   = host;
 219         block->b_file   = file;
 220         block->b_fl = NULL;
 221         file->f_count++;
 222
 223         /* Add to file's list of blocks */
 224         list_add(&block->b_flist, &file->f_blocks);
 225
 226         /* Set up RPC arguments for callback */
 227         block->b_call = call;
 228         call->a_flags   = RPC_TASK_ASYNC;
 229         call->a_block = block;
 230
 231         return block;
 232
 233 failed_free:
 234         kfree(block);
 235 failed:
 236         nlm_release_call(call);
 237         return NULL;
 238 }
 239
 240 /*
 241  * Delete a block.
 242  * It is the caller's responsibility to check whether the file
 243  * can be closed hereafter.
 244  */
 245 static int nlmsvc_unlink_block(struct nlm_block *block)
 246 {
 247         int status;
 248         dprintk("lockd: unlinking block %p...\n", block);
 249
 250         /* Remove block from list */
 251         status = posix_unblock_lock(block->b_file->f_file, &block->b_call->a_args.lock.fl);
 252         nlmsvc_remove_block(block);
 253         return status;
 254 }
 255
 256 static void nlmsvc_free_block(struct kref *kref)
 257 {
 258         struct nlm_block *block = container_of(kref, struct nlm_block, b_count);
 259         struct nlm_file         *file = block->b_file;
 260
 261         dprintk("lockd: freeing block %p...\n", block);
 262
 263         /* Remove block from file's list of blocks */
 264         mutex_lock(&file->f_mutex);
 265         list_del_init(&block->b_flist);
 266         mutex_unlock(&file->f_mutex);
 267
 268         nlmsvc_freegrantargs(block->b_call);
 269         nlm_release_call(block->b_call);
 270         nlm_release_file(block->b_file);
 271         kfree(block->b_fl);
 272         kfree(block);
 273 }
 274
 275 static void nlmsvc_release_block(struct nlm_block *block)
 276 {
 277         if (block != NULL)
 278                 kref_put(&block->b_count, nlmsvc_free_block);
 279 }
 280
 281 /*
 282  * Loop over all blocks and delete blocks held by
 283  * a matching host.
 284  */
 285 void nlmsvc_traverse_blocks(struct nlm_host *host,
 286                         struct nlm_file *file,
 287                         nlm_host_match_fn_t match)
 288 {
 289         struct nlm_block *block, *next;
 290
 291 restart:
 292         mutex_lock(&file->f_mutex);
 293         list_for_each_entry_safe(block, next, &file->f_blocks, b_flist) {
 294                 if (!match(block->b_host, host))
 295                         continue;
 296                 /* Do not destroy blocks that are not on
 297                  * the global retry list - why? */
 298                 if (list_empty(&block->b_list))
 299                         continue;
 300                 kref_get(&block->b_count);
 301                 mutex_unlock(&file->f_mutex);
 302                 nlmsvc_unlink_block(block);
 303                 nlmsvc_release_block(block);
 304                 goto restart;
 305         }
 306         mutex_unlock(&file->f_mutex);
 307 }
 308
 309 /*
 310  * Initialize arguments for GRANTED call. The nlm_rqst structure
 311  * has been cleared already.
 312  */
 313 static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock)
 314 {
 315         locks_copy_lock(&call->a_args.lock.fl, &lock->fl);
 316         memcpy(&call->a_args.lock.fh, &lock->fh, sizeof(call->a_args.lock.fh));
 317         call->a_args.lock.caller = utsname()->nodename;
 318         call->a_args.lock.oh.len = lock->oh.len;
 319
 320         /* set default data area */
 321         call->a_args.lock.oh.data = call->a_owner;
 322         call->a_args.lock.svid = lock->fl.fl_pid;
 323
 324         if (lock->oh.len > NLMCLNT_OHSIZE) {
 325                 void *data = kmalloc(lock->oh.len, GFP_KERNEL);
 326                 if (!data)
 327                         return 0;
 328                 call->a_args.lock.oh.data = (u8 *) data;
 329         }
 330
 331         memcpy(call->a_args.lock.oh.data, lock->oh.data, lock->oh.len);
 332         return 1;
 333 }
 334
 335 static void nlmsvc_freegrantargs(struct nlm_rqst *call)
 336 {
 337         if (call->a_args.lock.oh.data != call->a_owner)
 338                 kfree(call->a_args.lock.oh.data);
 339
 340         locks_release_private(&call->a_args.lock.fl);
 341 }
 342
 343 /*
 344  * Deferred lock request handling for non-blocking lock
 345  */
 346 static __be32
 347 nlmsvc_defer_lock_rqst(struct svc_rqst *rqstp, struct nlm_block *block)
 348 {
 349         __be32 status = nlm_lck_denied_nolocks;
 350
 351         block->b_flags |= B_QUEUED;
 352
 353         nlmsvc_insert_block(block, NLM_TIMEOUT);
 354
 355         block->b_cache_req = &rqstp->rq_chandle;
 356         if (rqstp->rq_chandle.defer) {
 357                 block->b_deferred_req =
 358                         rqstp->rq_chandle.defer(block->b_cache_req);
 359                 if (block->b_deferred_req != NULL)
 360                         status = nlm_drop_reply;
 361         }
 362         dprintk("lockd: nlmsvc_defer_lock_rqst block %p flags %d status %d\n",
 363                 block, block->b_flags, ntohl(status));
 364
 365         return status;
 366 }
 367
 368 /*
 369  * Attempt to establish a lock, and if it can't be granted, block it
 370  * if required.
 371  */
 372 __be32
 373 nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
 374             struct nlm_host *host, struct nlm_lock *lock, int wait,
 375             struct nlm_cookie *cookie, int reclaim)
 376 {
 377         struct nlm_block        *block = NULL;
 378         int                     error;
 379         __be32                  ret;
 380
 381         dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
 382                                 file->f_file->f_path.dentry->d_inode->i_sb->s_id,
 383                                 file->f_file->f_path.dentry->d_inode->i_ino,
 384                                 lock->fl.fl_type, lock->fl.fl_pid,
 385                                 (long long)lock->fl.fl_start,
 386                                 (long long)lock->fl.fl_end,
 387                                 wait);
 388
 389         /* Lock file against concurrent access */
 390         mutex_lock(&file->f_mutex);
 391         /* Get existing block (in case client is busy-waiting)
 392          * or create new block
 393          */
 394         block = nlmsvc_lookup_block(file, lock);
 395         if (block == NULL) {
 396                 block = nlmsvc_create_block(rqstp, host, file, lock, cookie);
 397                 ret = nlm_lck_denied_nolocks;
 398                 if (block == NULL)
 399                         goto out;
 400                 lock = &block->b_call->a_args.lock;
 401         } else
 402                 lock->fl.fl_flags &= ~FL_SLEEP;
 403
 404         if (block->b_flags & B_QUEUED) {
 405                 dprintk("lockd: nlmsvc_lock deferred block %p flags %d\n",
 406                                                         block, block->b_flags);
 407                 if (block->b_granted) {
 408                         nlmsvc_unlink_block(block);
 409                         ret = nlm_granted;
 410                         goto out;
 411                 }
 412                 if (block->b_flags & B_TIMED_OUT) {
 413                         nlmsvc_unlink_block(block);
 414                         ret = nlm_lck_denied;
 415                         goto out;
 416                 }
 417                 ret = nlm_drop_reply;
 418                 goto out;
 419         }
 420
 421         if (locks_in_grace() && !reclaim) {
 422                 ret = nlm_lck_denied_grace_period;
 423                 goto out;
 424         }
 425         if (reclaim && !locks_in_grace()) {
 426                 ret = nlm_lck_denied_grace_period;
 427                 goto out;
 428         }
 429
 430         if (!wait)
 431                 lock->fl.fl_flags &= ~FL_SLEEP;
 432         error = vfs_lock_file(file->f_file, F_SETLK, &lock->fl, NULL);
 433         lock->fl.fl_flags &= ~FL_SLEEP;
 434
 435         dprintk("lockd: vfs_lock_file returned %d\n", error);
 436         switch (error) {
 437                 case 0:
 438                         ret = nlm_granted;
 439                         goto out;
 440                 case -EAGAIN:
 441                         /*
 442                          * If this is a blocking request for an
 443                          * already pending lock request then we need
 444                          * to put it back on lockd's block list
 445                          */
 446                         if (wait)
 447                                 break;
 448                         ret = nlm_lck_denied;
 449                         goto out;
 450                 case FILE_LOCK_DEFERRED:
 451                         if (wait)
 452                                 break;
 453                         /* Filesystem lock operation is in progress
 454                            Add it to the queue waiting for callback */
 455                         ret = nlmsvc_defer_lock_rqst(rqstp, block);
 456                         goto out;
 457                 case -EDEADLK:
 458                         ret = nlm_deadlock;
 459                         goto out;
 460                 default:                        /* includes ENOLCK */
 461                         ret = nlm_lck_denied_nolocks;
 462                         goto out;
 463         }
 464
 465         ret = nlm_lck_blocked;
 466
 467         /* Append to list of blocked */
 468         nlmsvc_insert_block(block, NLM_NEVER);
 469 out:
 470         mutex_unlock(&file->f_mutex);
 471         nlmsvc_release_block(block);
 472         dprintk("lockd: nlmsvc_lock returned %u\n", ret);
 473         return ret;
 474 }
 475
 476 /*
 477  * Test for presence of a conflicting lock.
 478  */
 479 __be32
 480 nlmsvc_testlock(struct svc_rqst *rqstp, struct nlm_file *file,
 481                 struct nlm_host *host, struct nlm_lock *lock,
 482                 struct nlm_lock *conflock, struct nlm_cookie *cookie)
 483 {
 484         struct nlm_block        *block = NULL;
 485         int                     error;
 486         __be32                  ret;
 487
 488         dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
 489                                 file->f_file->f_path.dentry->d_inode->i_sb->s_id,
 490                                 file->f_file->f_path.dentry->d_inode->i_ino,
 491                                 lock->fl.fl_type,
 492                                 (long long)lock->fl.fl_start,
 493                                 (long long)lock->fl.fl_end);
 494
 495         /* Get existing block (in case client is busy-waiting) */
 496         block = nlmsvc_lookup_block(file, lock);
 497
 498         if (block == NULL) {
 499                 struct file_lock *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
 500
 501                 if (conf == NULL)
 502                         return nlm_granted;
 503                 block = nlmsvc_create_block(rqstp, host, file, lock, cookie);
 504                 if (block == NULL) {
 505                         kfree(conf);
 506                         return nlm_granted;
 507                 }
 508                 block->b_fl = conf;
 509         }
 510         if (block->b_flags & B_QUEUED) {
 511                 dprintk("lockd: nlmsvc_testlock deferred block %p flags %d fl %p\n",
 512                         block, block->b_flags, block->b_fl);
 513                 if (block->b_flags & B_TIMED_OUT) {
 514                         nlmsvc_unlink_block(block);
 515                         ret = nlm_lck_denied;
 516                         goto out;
 517                 }
 518                 if (block->b_flags & B_GOT_CALLBACK) {
 519                         nlmsvc_unlink_block(block);
 520                         if (block->b_fl != NULL
 521                                         && block->b_fl->fl_type != F_UNLCK) {
 522                                 lock->fl = *block->b_fl;
 523                                 goto conf_lock;
 524                         } else {
 525                                 ret = nlm_granted;
 526                                 goto out;
 527                         }
 528                 }
 529                 ret = nlm_drop_reply;
 530                 goto out;
 531         }
 532
 533         if (locks_in_grace()) {
 534                 ret = nlm_lck_denied_grace_period;
 535                 goto out;
 536         }
 537         error = vfs_test_lock(file->f_file, &lock->fl);
 538         if (error == FILE_LOCK_DEFERRED) {
 539                 ret = nlmsvc_defer_lock_rqst(rqstp, block);
 540                 goto out;
 541         }
 542         if (error) {
 543                 ret = nlm_lck_denied_nolocks;
 544                 goto out;
 545         }
 546         if (lock->fl.fl_type == F_UNLCK) {
 547                 ret = nlm_granted;
 548                 goto out;
 549         }
 550
 551 conf_lock:
 552         dprintk("lockd: conflicting lock(ty=%d, %Ld-%Ld)\n",
 553                 lock->fl.fl_type, (long long)lock->fl.fl_start,
 554                 (long long)lock->fl.fl_end);
 555         conflock->caller = "somehost";  /* FIXME */
 556         conflock->len = strlen(conflock->caller);
 557         conflock->oh.len = 0;           /* don't return OH info */
 558         conflock->svid = lock->fl.fl_pid;
 559         conflock->fl.fl_type = lock->fl.fl_type;
 560         conflock->fl.fl_start = lock->fl.fl_start;
 561         conflock->fl.fl_end = lock->fl.fl_end;
 562         ret = nlm_lck_denied;
 563 out:
 564         if (block)
 565                 nlmsvc_release_block(block);
 566         return ret;
 567 }
 568
 569 /*
 570  * Remove a lock.
 571  * This implies a CANCEL call: We send a GRANT_MSG, the client replies
 572  * with a GRANT_RES call which gets lost, and calls UNLOCK immediately
 573  * afterwards. In this case the block will still be there, and hence
 574  * must be removed.
 575  */
 576 __be32
 577 nlmsvc_unlock(struct nlm_file *file, struct nlm_lock *lock)
 578 {
 579         int     error;
 580
 581         dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
 582                                 file->f_file->f_path.dentry->d_inode->i_sb->s_id,
 583                                 file->f_file->f_path.dentry->d_inode->i_ino,
 584                                 lock->fl.fl_pid,
 585                                 (long long)lock->fl.fl_start,
 586                                 (long long)lock->fl.fl_end);
 587
 588         /* First, cancel any lock that might be there */
 589         nlmsvc_cancel_blocked(file, lock);
 590
 591         lock->fl.fl_type = F_UNLCK;
 592         error = vfs_lock_file(file->f_file, F_SETLK, &lock->fl, NULL);
 593
 594         return (error < 0)? nlm_lck_denied_nolocks : nlm_granted;
 595 }
 596
 597 /*
 598  * Cancel a previously blocked request.
 599  *
 600  * A cancel request always overrides any grant that may currently
 601  * be in progress.
 602  * The calling procedure must check whether the file can be closed.
 603  */
 604 __be32
 605 nlmsvc_cancel_blocked(struct nlm_file *file, struct nlm_lock *lock)
 606 {
 607         struct nlm_block        *block;
 608         int status = 0;
 609
 610         dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
 611                                 file->f_file->f_path.dentry->d_inode->i_sb->s_id,
 612                                 file->f_file->f_path.dentry->d_inode->i_ino,
 613                                 lock->fl.fl_pid,
 614                                 (long long)lock->fl.fl_start,
 615                                 (long long)lock->fl.fl_end);
 616
 617         if (locks_in_grace())
 618                 return nlm_lck_denied_grace_period;
 619
 620         mutex_lock(&file->f_mutex);
 621         block = nlmsvc_lookup_block(file, lock);
 622         mutex_unlock(&file->f_mutex);
 623         if (block != NULL) {
 624                 vfs_cancel_lock(block->b_file->f_file,
 625                                 &block->b_call->a_args.lock.fl);
 626                 status = nlmsvc_unlink_block(block);
 627                 nlmsvc_release_block(block);
 628         }
 629         return status ? nlm_lck_denied : nlm_granted;
 630 }
 631
 632 /*
 633  * This is a callback from the filesystem for VFS file lock requests.
 634  * It will be used if fl_grant is defined and the filesystem can not
 635  * respond to the request immediately.
 636  * For GETLK request it will copy the reply to the nlm_block.
 637  * For SETLK or SETLKW request it will get the local posix lock.
 638  * In all cases it will move the block to the head of nlm_blocked q where
 639  * nlmsvc_retry_blocked() can send back a reply for SETLKW or revisit the
 640  * deferred rpc for GETLK and SETLK.
 641  */
 642 static void
 643 nlmsvc_update_deferred_block(struct nlm_block *block, struct file_lock *conf,
 644                              int result)
 645 {
 646         block->b_flags |= B_GOT_CALLBACK;
 647         if (result == 0)
 648                 block->b_granted = 1;
 649         else
 650                 block->b_flags |= B_TIMED_OUT;
 651         if (conf) {
 652                 if (block->b_fl)
 653                         __locks_copy_lock(block->b_fl, conf);
 654         }
 655 }
 656
 657 static int nlmsvc_grant_deferred(struct file_lock *fl, struct file_lock *conf,
 658                                         int result)
 659 {
 660         struct nlm_block *block;
 661         int rc = -ENOENT;
 662
 663         spin_lock(&nlm_blocked_lock);
 664         list_for_each_entry(block, &nlm_blocked, b_list) {
 665                 if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) {
 666                         dprintk("lockd: nlmsvc_notify_blocked block %p flags %d\n",
 667                                                         block, block->b_flags);
 668                         if (block->b_flags & B_QUEUED) {
 669                                 if (block->b_flags & B_TIMED_OUT) {
 670                                         rc = -ENOLCK;
 671                                         break;
 672                                 }
 673                                 nlmsvc_update_deferred_block(block, conf, result);
 674                         } else if (result == 0)
 675                                 block->b_granted = 1;
 676
 677                         nlmsvc_insert_block_locked(block, 0);
 678                         svc_wake_up(block->b_daemon);
 679                         rc = 0;
 680                         break;
 681                 }
 682         }
 683         spin_unlock(&nlm_blocked_lock);
 684         if (rc == -ENOENT)
 685                 printk(KERN_WARNING "lockd: grant for unknown block\n");
 686         return rc;
 687 }
 688
 689 /*
 690  * Unblock a blocked lock request. This is a callback invoked from the
 691  * VFS layer when a lock on which we blocked is removed.
 692  *
 693  * This function doesn't grant the blocked lock instantly, but rather moves
 694  * the block to the head of nlm_blocked where it can be picked up by lockd.
 695  */
 696 static void
 697 nlmsvc_notify_blocked(struct file_lock *fl)
 698 {
 699         struct nlm_block        *block;
 700
 701         dprintk("lockd: VFS unblock notification for block %p\n", fl);
 702         spin_lock(&nlm_blocked_lock);
 703         list_for_each_entry(block, &nlm_blocked, b_list) {
 704                 if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) {
 705                         nlmsvc_insert_block_locked(block, 0);
 706                         spin_unlock(&nlm_blocked_lock);
 707                         svc_wake_up(block->b_daemon);
 708                         return;
 709                 }
 710         }
 711         spin_unlock(&nlm_blocked_lock);
 712         printk(KERN_WARNING "lockd: notification for unknown block!\n");
 713 }
 714
 715 static int nlmsvc_same_owner(struct file_lock *fl1, struct file_lock *fl2)
 716 {
 717         return fl1->fl_owner == fl2->fl_owner && fl1->fl_pid == fl2->fl_pid;
 718 }
 719
 720 const struct lock_manager_operations nlmsvc_lock_operations = {
 721         .fl_compare_owner = nlmsvc_same_owner,
 722         .fl_notify = nlmsvc_notify_blocked,
 723         .fl_grant = nlmsvc_grant_deferred,
 724 };
 725
 726 /*
 727  * Try to claim a lock that was previously blocked.
 728  *
 729  * Note that we use both the RPC_GRANTED_MSG call _and_ an async
 730  * RPC thread when notifying the client. This seems like overkill...
 731  * Here's why:
 732  *  -   we don't want to use a synchronous RPC thread, otherwise
 733  *      we might find ourselves hanging on a dead portmapper.
 734  *  -   Some lockd implementations (e.g. HP) don't react to
 735  *      RPC_GRANTED calls; they seem to insist on RPC_GRANTED_MSG calls.
 736  */
 737 static void
 738 nlmsvc_grant_blocked(struct nlm_block *block)
 739 {
 740         struct nlm_file         *file = block->b_file;
 741         struct nlm_lock         *lock = &block->b_call->a_args.lock;
 742         int                     error;
 743
 744         dprintk("lockd: grant blocked lock %p\n", block);
 745
 746         kref_get(&block->b_count);
 747
 748         /* Unlink block request from list */
 749         nlmsvc_unlink_block(block);
 750
 751         /* If b_granted is true this means we've been here before.
 752          * Just retry the grant callback, possibly refreshing the RPC
 753          * binding */
 754         if (block->b_granted) {
 755                 nlm_rebind_host(block->b_host);
 756                 goto callback;
 757         }
 758
 759         /* Try the lock operation again */
 760         lock->fl.fl_flags |= FL_SLEEP;
 761         error = vfs_lock_file(file->f_file, F_SETLK, &lock->fl, NULL);
 762         lock->fl.fl_flags &= ~FL_SLEEP;
 763
 764         switch (error) {
 765         case 0:
 766                 break;
 767         case FILE_LOCK_DEFERRED:
 768                 dprintk("lockd: lock still blocked error %d\n", error);
 769                 nlmsvc_insert_block(block, NLM_NEVER);
 770                 nlmsvc_release_block(block);
 771                 return;
 772         default:
 773                 printk(KERN_WARNING "lockd: unexpected error %d in %s!\n",
 774                                 -error, __func__);
 775                 nlmsvc_insert_block(block, 10 * HZ);
 776                 nlmsvc_release_block(block);
 777                 return;
 778         }
 779
 780 callback:
 781         /* Lock was granted by VFS. */
 782         dprintk("lockd: GRANTing blocked lock.\n");
 783         block->b_granted = 1;
 784
 785         /* keep block on the list, but don't reattempt until the RPC
 786          * completes or the submission fails
 787          */
 788         nlmsvc_insert_block(block, NLM_NEVER);
 789
 790         /* Call the client -- use a soft RPC task since nlmsvc_retry_blocked
 791          * will queue up a new one if this one times out
 792          */
 793         error = nlm_async_call(block->b_call, NLMPROC_GRANTED_MSG,
 794                                 &nlmsvc_grant_ops);
 795
 796         /* RPC submission failed, wait a bit and retry */
 797         if (error < 0)
 798                 nlmsvc_insert_block(block, 10 * HZ);
 799 }
 800
 801 /*
 802  * This is the callback from the RPC layer when the NLM_GRANTED_MSG
 803  * RPC call has succeeded or timed out.
 804  * Like all RPC callbacks, it is invoked by the rpciod process, so it
 805  * better not sleep. Therefore, we put the blocked lock on the nlm_blocked
 806  * chain once more in order to have it removed by lockd itself (which can
 807  * then sleep on the file semaphore without disrupting e.g. the nfs client).
 808  */
 809 static void nlmsvc_grant_callback(struct rpc_task *task, void *data)
 810 {
 811         struct nlm_rqst         *call = data;
 812         struct nlm_block        *block = call->a_block;
 813         unsigned long           timeout;
 814
 815         dprintk("lockd: GRANT_MSG RPC callback\n");
 816
 817         spin_lock(&nlm_blocked_lock);
 818         /* if the block is not on a list at this point then it has
 819          * been invalidated. Don't try to requeue it.
 820          *
 821          * FIXME: it's possible that the block is removed from the list
 822          * after this check but before the nlmsvc_insert_block. In that
 823          * case it will be added back. Perhaps we need better locking
 824          * for nlm_blocked?
 825          */
 826         if (list_empty(&block->b_list))
 827                 goto out;
 828
 829         /* Technically, we should down the file semaphore here. Since we
 830          * move the block towards the head of the queue only, no harm
 831          * can be done, though. */
 832         if (task->tk_status < 0) {
 833                 /* RPC error: Re-insert for retransmission */
 834                 timeout = 10 * HZ;
 835         } else {
 836                 /* Call was successful, now wait for client callback */
 837                 timeout = 60 * HZ;
 838         }
 839         nlmsvc_insert_block_locked(block, timeout);
 840         svc_wake_up(block->b_daemon);
 841 out:
 842         spin_unlock(&nlm_blocked_lock);
 843 }
 844
 845 /*
 846  * FIXME: nlmsvc_release_block() grabs a mutex.  This is not allowed for an
 847  * .rpc_release rpc_call_op
 848  */
 849 static void nlmsvc_grant_release(void *data)
 850 {
 851         struct nlm_rqst         *call = data;
 852         nlmsvc_release_block(call->a_block);
 853 }
 854
 855 static const struct rpc_call_ops nlmsvc_grant_ops = {
 856         .rpc_call_done = nlmsvc_grant_callback,
 857         .rpc_release = nlmsvc_grant_release,
 858 };
 859
 860 /*
 861  * We received a GRANT_RES callback. Try to find the corresponding
 862  * block.
 863  */
 864 void
 865 nlmsvc_grant_reply(struct nlm_cookie *cookie, __be32 status)
 866 {
 867         struct nlm_block        *block;
 868
 869         dprintk("grant_reply: looking for cookie %x, s=%d \n",
 870                 *(unsigned int *)(cookie->data), status);
 871         if (!(block = nlmsvc_find_block(cookie)))
 872                 return;
 873
 874         if (block) {
 875                 if (status == nlm_lck_denied_grace_period) {
 876                         /* Try again in a couple of seconds */
 877                         nlmsvc_insert_block(block, 10 * HZ);
 878                 } else {
 879                         /* Lock is now held by client, or has been rejected.
 880                          * In both cases, the block should be removed. */
 881                         nlmsvc_unlink_block(block);
 882                 }
 883         }
 884         nlmsvc_release_block(block);
 885 }
 886
 887 /* Helper function to handle retry of a deferred block.
 888  * If it is a blocking lock, call grant_blocked.
 889  * For a non-blocking lock or test lock, revisit the request.
 890  */
 891 static void
 892 retry_deferred_block(struct nlm_block *block)
 893 {
 894         if (!(block->b_flags & B_GOT_CALLBACK))
 895                 block->b_flags |= B_TIMED_OUT;
 896         nlmsvc_insert_block(block, NLM_TIMEOUT);
 897         dprintk("revisit block %p flags %d\n",  block, block->b_flags);
 898         if (block->b_deferred_req) {
 899                 block->b_deferred_req->revisit(block->b_deferred_req, 0);
 900                 block->b_deferred_req = NULL;
 901         }
 902 }
 903
 904 /*
 905  * Retry all blocked locks that have been notified. This is where lockd
 906  * picks up locks that can be granted, or grant notifications that must
 907  * be retransmitted.
 908  */
 909 unsigned long
 910 nlmsvc_retry_blocked(void)
 911 {
 912         unsigned long   timeout = MAX_SCHEDULE_TIMEOUT;
 913         struct nlm_block *block;
 914
 915         while (!list_empty(&nlm_blocked) && !kthread_should_stop()) {
 916                 block = list_entry(nlm_blocked.next, struct nlm_block, b_list);
 917
 918                 if (block->b_when == NLM_NEVER)
 919                         break;
 920                 if (time_after(block->b_when, jiffies)) {
 921                         timeout = block->b_when - jiffies;
 922                         break;
 923                 }
 924
 925                 dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n",
 926                         block, block->b_when);
 927                 if (block->b_flags & B_QUEUED) {
 928                         dprintk("nlmsvc_retry_blocked delete block (%p, granted=%d, flags=%d)\n",
 929                                 block, block->b_granted, block->b_flags);
 930                         retry_deferred_block(block);
 931                 } else
 932                         nlmsvc_grant_blocked(block);
 933         }
 934
 935         return timeout;
 936 }