1 /* 2 * linux/fs/lockd/clntproc.c 3 * 4 * RPC procedures for the client side NLM implementation 5 * 6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/types.h> 11 #include <linux/errno.h> 12 #include <linux/fs.h> 13 #include <linux/nfs_fs.h> 14 #include <linux/utsname.h> 15 #include <linux/freezer.h> 16 #include <linux/sunrpc/clnt.h> 17 #include <linux/sunrpc/svc.h> 18 #include <linux/lockd/lockd.h> 19 20 #define NLMDBG_FACILITY NLMDBG_CLIENT 21 #define NLMCLNT_GRACE_WAIT (5*HZ) 22 #define NLMCLNT_POLL_TIMEOUT (30*HZ) 23 #define NLMCLNT_MAX_RETRIES 3 24 25 static int nlmclnt_test(struct nlm_rqst *, struct file_lock *); 26 static int nlmclnt_lock(struct nlm_rqst *, struct file_lock *); 27 static int nlmclnt_unlock(struct nlm_rqst *, struct file_lock *); 28 static int nlm_stat_to_errno(__be32 stat); 29 static void nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *host); 30 static int nlmclnt_cancel(struct nlm_host *, int , struct file_lock *); 31 32 static const struct rpc_call_ops nlmclnt_unlock_ops; 33 static const struct rpc_call_ops nlmclnt_cancel_ops; 34 35 /* 36 * Cookie counter for NLM requests 37 */ 38 static atomic_t nlm_cookie = ATOMIC_INIT(0x1234); 39 40 void nlmclnt_next_cookie(struct nlm_cookie *c) 41 { 42 u32 cookie = atomic_inc_return(&nlm_cookie); 43 44 memcpy(c->data, &cookie, 4); 45 c->len=4; 46 } 47 48 static struct nlm_lockowner *nlm_get_lockowner(struct nlm_lockowner *lockowner) 49 { 50 atomic_inc(&lockowner->count); 51 return lockowner; 52 } 53 54 static void nlm_put_lockowner(struct nlm_lockowner *lockowner) 55 { 56 if (!atomic_dec_and_lock(&lockowner->count, &lockowner->host->h_lock)) 57 return; 58 list_del(&lockowner->list); 59 spin_unlock(&lockowner->host->h_lock); 60 nlm_release_host(lockowner->host); 61 kfree(lockowner); 62 } 63 64 static inline int nlm_pidbusy(struct nlm_host *host, uint32_t pid) 65 { 66 struct nlm_lockowner *lockowner; 67 list_for_each_entry(lockowner, &host->h_lockowners, list) { 68 if (lockowner->pid == pid) 69 return -EBUSY; 70 } 71 return 0; 72 } 73 74 static inline uint32_t __nlm_alloc_pid(struct nlm_host *host) 75 { 76 uint32_t res; 77 do { 78 res = host->h_pidcount++; 79 } while (nlm_pidbusy(host, res) < 0); 80 return res; 81 } 82 83 static struct nlm_lockowner *__nlm_find_lockowner(struct nlm_host *host, fl_owner_t owner) 84 { 85 struct nlm_lockowner *lockowner; 86 list_for_each_entry(lockowner, &host->h_lockowners, list) { 87 if (lockowner->owner != owner) 88 continue; 89 return nlm_get_lockowner(lockowner); 90 } 91 return NULL; 92 } 93 94 static struct nlm_lockowner *nlm_find_lockowner(struct nlm_host *host, fl_owner_t owner) 95 { 96 struct nlm_lockowner *res, *new = NULL; 97 98 spin_lock(&host->h_lock); 99 res = __nlm_find_lockowner(host, owner); 100 if (res == NULL) { 101 spin_unlock(&host->h_lock); 102 new = kmalloc(sizeof(*new), GFP_KERNEL); 103 spin_lock(&host->h_lock); 104 res = __nlm_find_lockowner(host, owner); 105 if (res == NULL && new != NULL) { 106 res = new; 107 atomic_set(&new->count, 1); 108 new->owner = owner; 109 new->pid = __nlm_alloc_pid(host); 110 new->host = nlm_get_host(host); 111 list_add(&new->list, &host->h_lockowners); 112 new = NULL; 113 } 114 } 115 spin_unlock(&host->h_lock); 116 kfree(new); 117 return res; 118 } 119 120 /* 121 * Initialize arguments for TEST/LOCK/UNLOCK/CANCEL calls 122 */ 123 static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl) 124 { 125 struct nlm_args *argp = &req->a_args; 126 struct nlm_lock *lock = &argp->lock; 127 128 nlmclnt_next_cookie(&argp->cookie); 129 memcpy(&lock->fh, NFS_FH(fl->fl_file->f_path.dentry->d_inode), sizeof(struct nfs_fh)); 130 lock->caller = utsname()->nodename; 131 lock->oh.data = req->a_owner; 132 lock->oh.len = snprintf(req->a_owner, sizeof(req->a_owner), "%u@%s", 133 (unsigned int)fl->fl_u.nfs_fl.owner->pid, 134 utsname()->nodename); 135 lock->svid = fl->fl_u.nfs_fl.owner->pid; 136 lock->fl.fl_start = fl->fl_start; 137 lock->fl.fl_end = fl->fl_end; 138 lock->fl.fl_type = fl->fl_type; 139 } 140 141 static void nlmclnt_release_lockargs(struct nlm_rqst *req) 142 { 143 BUG_ON(req->a_args.lock.fl.fl_ops != NULL); 144 } 145 146 /** 147 * nlmclnt_proc - Perform a single client-side lock request 148 * @host: address of a valid nlm_host context representing the NLM server 149 * @cmd: fcntl-style file lock operation to perform 150 * @fl: address of arguments for the lock operation 151 * 152 */ 153 int nlmclnt_proc(struct nlm_host *host, int cmd, struct file_lock *fl) 154 { 155 struct nlm_rqst *call; 156 int status; 157 158 nlm_get_host(host); 159 call = nlm_alloc_call(host); 160 if (call == NULL) 161 return -ENOMEM; 162 163 nlmclnt_locks_init_private(fl, host); 164 /* Set up the argument struct */ 165 nlmclnt_setlockargs(call, fl); 166 167 lock_kernel(); 168 if (IS_SETLK(cmd) || IS_SETLKW(cmd)) { 169 if (fl->fl_type != F_UNLCK) { 170 call->a_args.block = IS_SETLKW(cmd) ? 1 : 0; 171 status = nlmclnt_lock(call, fl); 172 } else 173 status = nlmclnt_unlock(call, fl); 174 } else if (IS_GETLK(cmd)) 175 status = nlmclnt_test(call, fl); 176 else 177 status = -EINVAL; 178 179 fl->fl_ops->fl_release_private(fl); 180 fl->fl_ops = NULL; 181 unlock_kernel(); 182 183 dprintk("lockd: clnt proc returns %d\n", status); 184 return status; 185 } 186 EXPORT_SYMBOL_GPL(nlmclnt_proc); 187 188 /* 189 * Allocate an NLM RPC call struct 190 * 191 * Note: the caller must hold a reference to host. In case of failure, 192 * this reference will be released. 193 */ 194 struct nlm_rqst *nlm_alloc_call(struct nlm_host *host) 195 { 196 struct nlm_rqst *call; 197 198 for(;;) { 199 call = kzalloc(sizeof(*call), GFP_KERNEL); 200 if (call != NULL) { 201 atomic_set(&call->a_count, 1); 202 locks_init_lock(&call->a_args.lock.fl); 203 locks_init_lock(&call->a_res.lock.fl); 204 call->a_host = host; 205 return call; 206 } 207 if (signalled()) 208 break; 209 printk("nlm_alloc_call: failed, waiting for memory\n"); 210 schedule_timeout_interruptible(5*HZ); 211 } 212 nlm_release_host(host); 213 return NULL; 214 } 215 216 void nlm_release_call(struct nlm_rqst *call) 217 { 218 if (!atomic_dec_and_test(&call->a_count)) 219 return; 220 nlm_release_host(call->a_host); 221 nlmclnt_release_lockargs(call); 222 kfree(call); 223 } 224 225 static void nlmclnt_rpc_release(void *data) 226 { 227 lock_kernel(); 228 nlm_release_call(data); 229 unlock_kernel(); 230 } 231 232 static int nlm_wait_on_grace(wait_queue_head_t *queue) 233 { 234 DEFINE_WAIT(wait); 235 int status = -EINTR; 236 237 prepare_to_wait(queue, &wait, TASK_INTERRUPTIBLE); 238 if (!signalled ()) { 239 schedule_timeout(NLMCLNT_GRACE_WAIT); 240 try_to_freeze(); 241 if (!signalled ()) 242 status = 0; 243 } 244 finish_wait(queue, &wait); 245 return status; 246 } 247 248 /* 249 * Generic NLM call 250 */ 251 static int 252 nlmclnt_call(struct rpc_cred *cred, struct nlm_rqst *req, u32 proc) 253 { 254 struct nlm_host *host = req->a_host; 255 struct rpc_clnt *clnt; 256 struct nlm_args *argp = &req->a_args; 257 struct nlm_res *resp = &req->a_res; 258 struct rpc_message msg = { 259 .rpc_argp = argp, 260 .rpc_resp = resp, 261 .rpc_cred = cred, 262 }; 263 int status; 264 265 dprintk("lockd: call procedure %d on %s\n", 266 (int)proc, host->h_name); 267 268 do { 269 if (host->h_reclaiming && !argp->reclaim) 270 goto in_grace_period; 271 272 /* If we have no RPC client yet, create one. */ 273 if ((clnt = nlm_bind_host(host)) == NULL) 274 return -ENOLCK; 275 msg.rpc_proc = &clnt->cl_procinfo[proc]; 276 277 /* Perform the RPC call. If an error occurs, try again */ 278 if ((status = rpc_call_sync(clnt, &msg, 0)) < 0) { 279 dprintk("lockd: rpc_call returned error %d\n", -status); 280 switch (status) { 281 case -EPROTONOSUPPORT: 282 status = -EINVAL; 283 break; 284 case -ECONNREFUSED: 285 case -ETIMEDOUT: 286 case -ENOTCONN: 287 nlm_rebind_host(host); 288 status = -EAGAIN; 289 break; 290 case -ERESTARTSYS: 291 return signalled () ? -EINTR : status; 292 default: 293 break; 294 } 295 break; 296 } else 297 if (resp->status == nlm_lck_denied_grace_period) { 298 dprintk("lockd: server in grace period\n"); 299 if (argp->reclaim) { 300 printk(KERN_WARNING 301 "lockd: spurious grace period reject?!\n"); 302 return -ENOLCK; 303 } 304 } else { 305 if (!argp->reclaim) { 306 /* We appear to be out of the grace period */ 307 wake_up_all(&host->h_gracewait); 308 } 309 dprintk("lockd: server returns status %d\n", resp->status); 310 return 0; /* Okay, call complete */ 311 } 312 313 in_grace_period: 314 /* 315 * The server has rebooted and appears to be in the grace 316 * period during which locks are only allowed to be 317 * reclaimed. 318 * We can only back off and try again later. 319 */ 320 status = nlm_wait_on_grace(&host->h_gracewait); 321 } while (status == 0); 322 323 return status; 324 } 325 326 /* 327 * Generic NLM call, async version. 328 */ 329 static struct rpc_task *__nlm_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *msg, const struct rpc_call_ops *tk_ops) 330 { 331 struct nlm_host *host = req->a_host; 332 struct rpc_clnt *clnt; 333 struct rpc_task_setup task_setup_data = { 334 .rpc_message = msg, 335 .callback_ops = tk_ops, 336 .callback_data = req, 337 .flags = RPC_TASK_ASYNC, 338 }; 339 340 dprintk("lockd: call procedure %d on %s (async)\n", 341 (int)proc, host->h_name); 342 343 /* If we have no RPC client yet, create one. */ 344 clnt = nlm_bind_host(host); 345 if (clnt == NULL) 346 goto out_err; 347 msg->rpc_proc = &clnt->cl_procinfo[proc]; 348 task_setup_data.rpc_client = clnt; 349 350 /* bootstrap and kick off the async RPC call */ 351 return rpc_run_task(&task_setup_data); 352 out_err: 353 tk_ops->rpc_release(req); 354 return ERR_PTR(-ENOLCK); 355 } 356 357 static int nlm_do_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *msg, const struct rpc_call_ops *tk_ops) 358 { 359 struct rpc_task *task; 360 361 task = __nlm_async_call(req, proc, msg, tk_ops); 362 if (IS_ERR(task)) 363 return PTR_ERR(task); 364 rpc_put_task(task); 365 return 0; 366 } 367 368 /* 369 * NLM asynchronous call. 370 */ 371 int nlm_async_call(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops) 372 { 373 struct rpc_message msg = { 374 .rpc_argp = &req->a_args, 375 .rpc_resp = &req->a_res, 376 }; 377 return nlm_do_async_call(req, proc, &msg, tk_ops); 378 } 379 380 int nlm_async_reply(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops) 381 { 382 struct rpc_message msg = { 383 .rpc_argp = &req->a_res, 384 }; 385 return nlm_do_async_call(req, proc, &msg, tk_ops); 386 } 387 388 /* 389 * NLM client asynchronous call. 390 * 391 * Note that although the calls are asynchronous, and are therefore 392 * guaranteed to complete, we still always attempt to wait for 393 * completion in order to be able to correctly track the lock 394 * state. 395 */ 396 static int nlmclnt_async_call(struct rpc_cred *cred, struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops) 397 { 398 struct rpc_message msg = { 399 .rpc_argp = &req->a_args, 400 .rpc_resp = &req->a_res, 401 .rpc_cred = cred, 402 }; 403 struct rpc_task *task; 404 int err; 405 406 task = __nlm_async_call(req, proc, &msg, tk_ops); 407 if (IS_ERR(task)) 408 return PTR_ERR(task); 409 err = rpc_wait_for_completion_task(task); 410 rpc_put_task(task); 411 return err; 412 } 413 414 /* 415 * TEST for the presence of a conflicting lock 416 */ 417 static int 418 nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl) 419 { 420 int status; 421 422 status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_TEST); 423 if (status < 0) 424 goto out; 425 426 switch (req->a_res.status) { 427 case nlm_granted: 428 fl->fl_type = F_UNLCK; 429 break; 430 case nlm_lck_denied: 431 /* 432 * Report the conflicting lock back to the application. 433 */ 434 fl->fl_start = req->a_res.lock.fl.fl_start; 435 fl->fl_end = req->a_res.lock.fl.fl_end; 436 fl->fl_type = req->a_res.lock.fl.fl_type; 437 fl->fl_pid = 0; 438 break; 439 default: 440 status = nlm_stat_to_errno(req->a_res.status); 441 } 442 out: 443 nlm_release_call(req); 444 return status; 445 } 446 447 static void nlmclnt_locks_copy_lock(struct file_lock *new, struct file_lock *fl) 448 { 449 new->fl_u.nfs_fl.state = fl->fl_u.nfs_fl.state; 450 new->fl_u.nfs_fl.owner = nlm_get_lockowner(fl->fl_u.nfs_fl.owner); 451 list_add_tail(&new->fl_u.nfs_fl.list, &fl->fl_u.nfs_fl.owner->host->h_granted); 452 } 453 454 static void nlmclnt_locks_release_private(struct file_lock *fl) 455 { 456 list_del(&fl->fl_u.nfs_fl.list); 457 nlm_put_lockowner(fl->fl_u.nfs_fl.owner); 458 } 459 460 static struct file_lock_operations nlmclnt_lock_ops = { 461 .fl_copy_lock = nlmclnt_locks_copy_lock, 462 .fl_release_private = nlmclnt_locks_release_private, 463 }; 464 465 static void nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *host) 466 { 467 BUG_ON(fl->fl_ops != NULL); 468 fl->fl_u.nfs_fl.state = 0; 469 fl->fl_u.nfs_fl.owner = nlm_find_lockowner(host, fl->fl_owner); 470 INIT_LIST_HEAD(&fl->fl_u.nfs_fl.list); 471 fl->fl_ops = &nlmclnt_lock_ops; 472 } 473 474 static int do_vfs_lock(struct file_lock *fl) 475 { 476 int res = 0; 477 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) { 478 case FL_POSIX: 479 res = posix_lock_file_wait(fl->fl_file, fl); 480 break; 481 case FL_FLOCK: 482 res = flock_lock_file_wait(fl->fl_file, fl); 483 break; 484 default: 485 BUG(); 486 } 487 return res; 488 } 489 490 /* 491 * LOCK: Try to create a lock 492 * 493 * Programmer Harassment Alert 494 * 495 * When given a blocking lock request in a sync RPC call, the HPUX lockd 496 * will faithfully return LCK_BLOCKED but never cares to notify us when 497 * the lock could be granted. This way, our local process could hang 498 * around forever waiting for the callback. 499 * 500 * Solution A: Implement busy-waiting 501 * Solution B: Use the async version of the call (NLM_LOCK_{MSG,RES}) 502 * 503 * For now I am implementing solution A, because I hate the idea of 504 * re-implementing lockd for a third time in two months. The async 505 * calls shouldn't be too hard to do, however. 506 * 507 * This is one of the lovely things about standards in the NFS area: 508 * they're so soft and squishy you can't really blame HP for doing this. 509 */ 510 static int 511 nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) 512 { 513 struct rpc_cred *cred = nfs_file_cred(fl->fl_file); 514 struct nlm_host *host = req->a_host; 515 struct nlm_res *resp = &req->a_res; 516 struct nlm_wait *block = NULL; 517 unsigned char fl_flags = fl->fl_flags; 518 unsigned char fl_type; 519 int status = -ENOLCK; 520 521 if (nsm_monitor(host) < 0) 522 goto out; 523 req->a_args.state = nsm_local_state; 524 525 fl->fl_flags |= FL_ACCESS; 526 status = do_vfs_lock(fl); 527 fl->fl_flags = fl_flags; 528 if (status < 0) 529 goto out; 530 531 block = nlmclnt_prepare_block(host, fl); 532 again: 533 /* 534 * Initialise resp->status to a valid non-zero value, 535 * since 0 == nlm_lck_granted 536 */ 537 resp->status = nlm_lck_blocked; 538 for(;;) { 539 /* Reboot protection */ 540 fl->fl_u.nfs_fl.state = host->h_state; 541 status = nlmclnt_call(cred, req, NLMPROC_LOCK); 542 if (status < 0) 543 break; 544 /* Did a reclaimer thread notify us of a server reboot? */ 545 if (resp->status == nlm_lck_denied_grace_period) 546 continue; 547 if (resp->status != nlm_lck_blocked) 548 break; 549 /* Wait on an NLM blocking lock */ 550 status = nlmclnt_block(block, req, NLMCLNT_POLL_TIMEOUT); 551 if (status < 0) 552 break; 553 if (resp->status != nlm_lck_blocked) 554 break; 555 } 556 557 /* if we were interrupted while blocking, then cancel the lock request 558 * and exit 559 */ 560 if (resp->status == nlm_lck_blocked) { 561 if (!req->a_args.block) 562 goto out_unlock; 563 if (nlmclnt_cancel(host, req->a_args.block, fl) == 0) 564 goto out_unblock; 565 } 566 567 if (resp->status == nlm_granted) { 568 down_read(&host->h_rwsem); 569 /* Check whether or not the server has rebooted */ 570 if (fl->fl_u.nfs_fl.state != host->h_state) { 571 up_read(&host->h_rwsem); 572 goto again; 573 } 574 /* Ensure the resulting lock will get added to granted list */ 575 fl->fl_flags |= FL_SLEEP; 576 if (do_vfs_lock(fl) < 0) 577 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__); 578 up_read(&host->h_rwsem); 579 fl->fl_flags = fl_flags; 580 status = 0; 581 } 582 if (status < 0) 583 goto out_unlock; 584 /* 585 * EAGAIN doesn't make sense for sleeping locks, and in some 586 * cases NLM_LCK_DENIED is returned for a permanent error. So 587 * turn it into an ENOLCK. 588 */ 589 if (resp->status == nlm_lck_denied && (fl_flags & FL_SLEEP)) 590 status = -ENOLCK; 591 else 592 status = nlm_stat_to_errno(resp->status); 593 out_unblock: 594 nlmclnt_finish_block(block); 595 out: 596 nlm_release_call(req); 597 return status; 598 out_unlock: 599 /* Fatal error: ensure that we remove the lock altogether */ 600 dprintk("lockd: lock attempt ended in fatal error.\n" 601 " Attempting to unlock.\n"); 602 nlmclnt_finish_block(block); 603 fl_type = fl->fl_type; 604 fl->fl_type = F_UNLCK; 605 down_read(&host->h_rwsem); 606 do_vfs_lock(fl); 607 up_read(&host->h_rwsem); 608 fl->fl_type = fl_type; 609 fl->fl_flags = fl_flags; 610 nlmclnt_async_call(cred, req, NLMPROC_UNLOCK, &nlmclnt_unlock_ops); 611 return status; 612 } 613 614 /* 615 * RECLAIM: Try to reclaim a lock 616 */ 617 int 618 nlmclnt_reclaim(struct nlm_host *host, struct file_lock *fl) 619 { 620 struct nlm_rqst reqst, *req; 621 int status; 622 623 req = &reqst; 624 memset(req, 0, sizeof(*req)); 625 locks_init_lock(&req->a_args.lock.fl); 626 locks_init_lock(&req->a_res.lock.fl); 627 req->a_host = host; 628 req->a_flags = 0; 629 630 /* Set up the argument struct */ 631 nlmclnt_setlockargs(req, fl); 632 req->a_args.reclaim = 1; 633 634 status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_LOCK); 635 if (status >= 0 && req->a_res.status == nlm_granted) 636 return 0; 637 638 printk(KERN_WARNING "lockd: failed to reclaim lock for pid %d " 639 "(errno %d, status %d)\n", fl->fl_pid, 640 status, ntohl(req->a_res.status)); 641 642 /* 643 * FIXME: This is a serious failure. We can 644 * 645 * a. Ignore the problem 646 * b. Send the owning process some signal (Linux doesn't have 647 * SIGLOST, though...) 648 * c. Retry the operation 649 * 650 * Until someone comes up with a simple implementation 651 * for b or c, I'll choose option a. 652 */ 653 654 return -ENOLCK; 655 } 656 657 /* 658 * UNLOCK: remove an existing lock 659 */ 660 static int 661 nlmclnt_unlock(struct nlm_rqst *req, struct file_lock *fl) 662 { 663 struct nlm_host *host = req->a_host; 664 struct nlm_res *resp = &req->a_res; 665 int status; 666 unsigned char fl_flags = fl->fl_flags; 667 668 /* 669 * Note: the server is supposed to either grant us the unlock 670 * request, or to deny it with NLM_LCK_DENIED_GRACE_PERIOD. In either 671 * case, we want to unlock. 672 */ 673 fl->fl_flags |= FL_EXISTS; 674 down_read(&host->h_rwsem); 675 status = do_vfs_lock(fl); 676 up_read(&host->h_rwsem); 677 fl->fl_flags = fl_flags; 678 if (status == -ENOENT) { 679 status = 0; 680 goto out; 681 } 682 683 atomic_inc(&req->a_count); 684 status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req, 685 NLMPROC_UNLOCK, &nlmclnt_unlock_ops); 686 if (status < 0) 687 goto out; 688 689 if (resp->status == nlm_granted) 690 goto out; 691 692 if (resp->status != nlm_lck_denied_nolocks) 693 printk("lockd: unexpected unlock status: %d\n", resp->status); 694 /* What to do now? I'm out of my depth... */ 695 status = -ENOLCK; 696 out: 697 nlm_release_call(req); 698 return status; 699 } 700 701 static void nlmclnt_unlock_callback(struct rpc_task *task, void *data) 702 { 703 struct nlm_rqst *req = data; 704 u32 status = ntohl(req->a_res.status); 705 706 if (RPC_ASSASSINATED(task)) 707 goto die; 708 709 if (task->tk_status < 0) { 710 dprintk("lockd: unlock failed (err = %d)\n", -task->tk_status); 711 goto retry_rebind; 712 } 713 if (status == NLM_LCK_DENIED_GRACE_PERIOD) { 714 rpc_delay(task, NLMCLNT_GRACE_WAIT); 715 goto retry_unlock; 716 } 717 if (status != NLM_LCK_GRANTED) 718 printk(KERN_WARNING "lockd: unexpected unlock status: %d\n", status); 719 die: 720 return; 721 retry_rebind: 722 lock_kernel(); 723 nlm_rebind_host(req->a_host); 724 unlock_kernel(); 725 retry_unlock: 726 rpc_restart_call(task); 727 } 728 729 static const struct rpc_call_ops nlmclnt_unlock_ops = { 730 .rpc_call_done = nlmclnt_unlock_callback, 731 .rpc_release = nlmclnt_rpc_release, 732 }; 733 734 /* 735 * Cancel a blocked lock request. 736 * We always use an async RPC call for this in order not to hang a 737 * process that has been Ctrl-C'ed. 738 */ 739 static int nlmclnt_cancel(struct nlm_host *host, int block, struct file_lock *fl) 740 { 741 struct nlm_rqst *req; 742 int status; 743 744 dprintk("lockd: blocking lock attempt was interrupted by a signal.\n" 745 " Attempting to cancel lock.\n"); 746 747 req = nlm_alloc_call(nlm_get_host(host)); 748 if (!req) 749 return -ENOMEM; 750 req->a_flags = RPC_TASK_ASYNC; 751 752 nlmclnt_setlockargs(req, fl); 753 req->a_args.block = block; 754 755 atomic_inc(&req->a_count); 756 status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req, 757 NLMPROC_CANCEL, &nlmclnt_cancel_ops); 758 if (status == 0 && req->a_res.status == nlm_lck_denied) 759 status = -ENOLCK; 760 nlm_release_call(req); 761 return status; 762 } 763 764 static void nlmclnt_cancel_callback(struct rpc_task *task, void *data) 765 { 766 struct nlm_rqst *req = data; 767 u32 status = ntohl(req->a_res.status); 768 769 if (RPC_ASSASSINATED(task)) 770 goto die; 771 772 if (task->tk_status < 0) { 773 dprintk("lockd: CANCEL call error %d, retrying.\n", 774 task->tk_status); 775 goto retry_cancel; 776 } 777 778 dprintk("lockd: cancel status %u (task %u)\n", 779 status, task->tk_pid); 780 781 switch (status) { 782 case NLM_LCK_GRANTED: 783 case NLM_LCK_DENIED_GRACE_PERIOD: 784 case NLM_LCK_DENIED: 785 /* Everything's good */ 786 break; 787 case NLM_LCK_DENIED_NOLOCKS: 788 dprintk("lockd: CANCEL failed (server has no locks)\n"); 789 goto retry_cancel; 790 default: 791 printk(KERN_NOTICE "lockd: weird return %d for CANCEL call\n", 792 status); 793 } 794 795 die: 796 return; 797 798 retry_cancel: 799 /* Don't ever retry more than 3 times */ 800 if (req->a_retries++ >= NLMCLNT_MAX_RETRIES) 801 goto die; 802 lock_kernel(); 803 nlm_rebind_host(req->a_host); 804 unlock_kernel(); 805 rpc_restart_call(task); 806 rpc_delay(task, 30 * HZ); 807 } 808 809 static const struct rpc_call_ops nlmclnt_cancel_ops = { 810 .rpc_call_done = nlmclnt_cancel_callback, 811 .rpc_release = nlmclnt_rpc_release, 812 }; 813 814 /* 815 * Convert an NLM status code to a generic kernel errno 816 */ 817 static int 818 nlm_stat_to_errno(__be32 status) 819 { 820 switch(ntohl(status)) { 821 case NLM_LCK_GRANTED: 822 return 0; 823 case NLM_LCK_DENIED: 824 return -EAGAIN; 825 case NLM_LCK_DENIED_NOLOCKS: 826 case NLM_LCK_DENIED_GRACE_PERIOD: 827 return -ENOLCK; 828 case NLM_LCK_BLOCKED: 829 printk(KERN_NOTICE "lockd: unexpected status NLM_BLOCKED\n"); 830 return -ENOLCK; 831 #ifdef CONFIG_LOCKD_V4 832 case NLM_DEADLCK: 833 return -EDEADLK; 834 case NLM_ROFS: 835 return -EROFS; 836 case NLM_STALE_FH: 837 return -ESTALE; 838 case NLM_FBIG: 839 return -EOVERFLOW; 840 case NLM_FAILED: 841 return -ENOLCK; 842 #endif 843 } 844 printk(KERN_NOTICE "lockd: unexpected server status %d\n", status); 845 return -ENOLCK; 846 } 847