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