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 } 937