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