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 26 static int nlmclnt_test(struct nlm_rqst *, struct file_lock *); 27 static int nlmclnt_lock(struct nlm_rqst *, struct file_lock *); 28 static int nlmclnt_unlock(struct nlm_rqst *, struct file_lock *); 29 static int nlm_stat_to_errno(__be32 stat); 30 static void nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *host); 31 static int nlmclnt_cancel(struct nlm_host *, int , struct file_lock *); 32 33 static const struct rpc_call_ops nlmclnt_unlock_ops; 34 static const struct rpc_call_ops nlmclnt_cancel_ops; 35 36 /* 37 * Cookie counter for NLM requests 38 */ 39 static atomic_t nlm_cookie = ATOMIC_INIT(0x1234); 40 41 void 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 49 static struct nlm_lockowner *nlm_get_lockowner(struct nlm_lockowner *lockowner) 50 { 51 atomic_inc(&lockowner->count); 52 return lockowner; 53 } 54 55 static 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 65 static 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 75 static 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 84 static 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 95 static 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 */ 124 static 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 129 nlmclnt_next_cookie(&argp->cookie); 130 memcpy(&lock->fh, NFS_FH(file_inode(fl->fl_file)), sizeof(struct nfs_fh)); 131 lock->caller = utsname()->nodename; 132 lock->oh.data = req->a_owner; 133 lock->oh.len = snprintf(req->a_owner, sizeof(req->a_owner), "%u@%s", 134 (unsigned int)fl->fl_u.nfs_fl.owner->pid, 135 utsname()->nodename); 136 lock->svid = fl->fl_u.nfs_fl.owner->pid; 137 lock->fl.fl_start = fl->fl_start; 138 lock->fl.fl_end = fl->fl_end; 139 lock->fl.fl_type = fl->fl_type; 140 } 141 142 static void nlmclnt_release_lockargs(struct nlm_rqst *req) 143 { 144 WARN_ON_ONCE(req->a_args.lock.fl.fl_ops != NULL); 145 } 146 147 /** 148 * nlmclnt_proc - Perform a single client-side lock request 149 * @host: address of a valid nlm_host context representing the NLM server 150 * @cmd: fcntl-style file lock operation to perform 151 * @fl: address of arguments for the lock operation 152 * 153 */ 154 int nlmclnt_proc(struct nlm_host *host, int cmd, struct file_lock *fl) 155 { 156 struct nlm_rqst *call; 157 int status; 158 159 call = nlm_alloc_call(host); 160 if (call == NULL) 161 return -ENOMEM; 162 163 nlmclnt_locks_init_private(fl, host); 164 if (!fl->fl_u.nfs_fl.owner) { 165 /* lockowner allocation has failed */ 166 nlmclnt_release_call(call); 167 return -ENOMEM; 168 } 169 /* Set up the argument struct */ 170 nlmclnt_setlockargs(call, fl); 171 172 if (IS_SETLK(cmd) || IS_SETLKW(cmd)) { 173 if (fl->fl_type != F_UNLCK) { 174 call->a_args.block = IS_SETLKW(cmd) ? 1 : 0; 175 status = nlmclnt_lock(call, fl); 176 } else 177 status = nlmclnt_unlock(call, fl); 178 } else if (IS_GETLK(cmd)) 179 status = nlmclnt_test(call, fl); 180 else 181 status = -EINVAL; 182 fl->fl_ops->fl_release_private(fl); 183 fl->fl_ops = NULL; 184 185 dprintk("lockd: clnt proc returns %d\n", status); 186 return status; 187 } 188 EXPORT_SYMBOL_GPL(nlmclnt_proc); 189 190 /* 191 * Allocate an NLM RPC call struct 192 */ 193 struct nlm_rqst *nlm_alloc_call(struct nlm_host *host) 194 { 195 struct nlm_rqst *call; 196 197 for(;;) { 198 call = kzalloc(sizeof(*call), GFP_KERNEL); 199 if (call != NULL) { 200 atomic_set(&call->a_count, 1); 201 locks_init_lock(&call->a_args.lock.fl); 202 locks_init_lock(&call->a_res.lock.fl); 203 call->a_host = nlm_get_host(host); 204 return call; 205 } 206 if (signalled()) 207 break; 208 printk("nlm_alloc_call: failed, waiting for memory\n"); 209 schedule_timeout_interruptible(5*HZ); 210 } 211 return NULL; 212 } 213 214 void nlmclnt_release_call(struct nlm_rqst *call) 215 { 216 if (!atomic_dec_and_test(&call->a_count)) 217 return; 218 nlmclnt_release_host(call->a_host); 219 nlmclnt_release_lockargs(call); 220 kfree(call); 221 } 222 223 static void nlmclnt_rpc_release(void *data) 224 { 225 nlmclnt_release_call(data); 226 } 227 228 static int nlm_wait_on_grace(wait_queue_head_t *queue) 229 { 230 DEFINE_WAIT(wait); 231 int status = -EINTR; 232 233 prepare_to_wait(queue, &wait, TASK_INTERRUPTIBLE); 234 if (!signalled ()) { 235 schedule_timeout(NLMCLNT_GRACE_WAIT); 236 try_to_freeze(); 237 if (!signalled ()) 238 status = 0; 239 } 240 finish_wait(queue, &wait); 241 return status; 242 } 243 244 /* 245 * Generic NLM call 246 */ 247 static int 248 nlmclnt_call(struct rpc_cred *cred, struct nlm_rqst *req, u32 proc) 249 { 250 struct nlm_host *host = req->a_host; 251 struct rpc_clnt *clnt; 252 struct nlm_args *argp = &req->a_args; 253 struct nlm_res *resp = &req->a_res; 254 struct rpc_message msg = { 255 .rpc_argp = argp, 256 .rpc_resp = resp, 257 .rpc_cred = cred, 258 }; 259 int status; 260 261 dprintk("lockd: call procedure %d on %s\n", 262 (int)proc, host->h_name); 263 264 do { 265 if (host->h_reclaiming && !argp->reclaim) 266 goto in_grace_period; 267 268 /* If we have no RPC client yet, create one. */ 269 if ((clnt = nlm_bind_host(host)) == NULL) 270 return -ENOLCK; 271 msg.rpc_proc = &clnt->cl_procinfo[proc]; 272 273 /* Perform the RPC call. If an error occurs, try again */ 274 if ((status = rpc_call_sync(clnt, &msg, 0)) < 0) { 275 dprintk("lockd: rpc_call returned error %d\n", -status); 276 switch (status) { 277 case -EPROTONOSUPPORT: 278 status = -EINVAL; 279 break; 280 case -ECONNREFUSED: 281 case -ETIMEDOUT: 282 case -ENOTCONN: 283 nlm_rebind_host(host); 284 status = -EAGAIN; 285 break; 286 case -ERESTARTSYS: 287 return signalled () ? -EINTR : status; 288 default: 289 break; 290 } 291 break; 292 } else 293 if (resp->status == nlm_lck_denied_grace_period) { 294 dprintk("lockd: server in grace period\n"); 295 if (argp->reclaim) { 296 printk(KERN_WARNING 297 "lockd: spurious grace period reject?!\n"); 298 return -ENOLCK; 299 } 300 } else { 301 if (!argp->reclaim) { 302 /* We appear to be out of the grace period */ 303 wake_up_all(&host->h_gracewait); 304 } 305 dprintk("lockd: server returns status %d\n", 306 ntohl(resp->status)); 307 return 0; /* Okay, call complete */ 308 } 309 310 in_grace_period: 311 /* 312 * The server has rebooted and appears to be in the grace 313 * period during which locks are only allowed to be 314 * reclaimed. 315 * We can only back off and try again later. 316 */ 317 status = nlm_wait_on_grace(&host->h_gracewait); 318 } while (status == 0); 319 320 return status; 321 } 322 323 /* 324 * Generic NLM call, async version. 325 */ 326 static struct rpc_task *__nlm_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *msg, const struct rpc_call_ops *tk_ops) 327 { 328 struct nlm_host *host = req->a_host; 329 struct rpc_clnt *clnt; 330 struct rpc_task_setup task_setup_data = { 331 .rpc_message = msg, 332 .callback_ops = tk_ops, 333 .callback_data = req, 334 .flags = RPC_TASK_ASYNC, 335 }; 336 337 dprintk("lockd: call procedure %d on %s (async)\n", 338 (int)proc, host->h_name); 339 340 /* If we have no RPC client yet, create one. */ 341 clnt = nlm_bind_host(host); 342 if (clnt == NULL) 343 goto out_err; 344 msg->rpc_proc = &clnt->cl_procinfo[proc]; 345 task_setup_data.rpc_client = clnt; 346 347 /* bootstrap and kick off the async RPC call */ 348 return rpc_run_task(&task_setup_data); 349 out_err: 350 tk_ops->rpc_release(req); 351 return ERR_PTR(-ENOLCK); 352 } 353 354 static int nlm_do_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *msg, const struct rpc_call_ops *tk_ops) 355 { 356 struct rpc_task *task; 357 358 task = __nlm_async_call(req, proc, msg, tk_ops); 359 if (IS_ERR(task)) 360 return PTR_ERR(task); 361 rpc_put_task(task); 362 return 0; 363 } 364 365 /* 366 * NLM asynchronous call. 367 */ 368 int nlm_async_call(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops) 369 { 370 struct rpc_message msg = { 371 .rpc_argp = &req->a_args, 372 .rpc_resp = &req->a_res, 373 }; 374 return nlm_do_async_call(req, proc, &msg, tk_ops); 375 } 376 377 int nlm_async_reply(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops) 378 { 379 struct rpc_message msg = { 380 .rpc_argp = &req->a_res, 381 }; 382 return nlm_do_async_call(req, proc, &msg, tk_ops); 383 } 384 385 /* 386 * NLM client asynchronous call. 387 * 388 * Note that although the calls are asynchronous, and are therefore 389 * guaranteed to complete, we still always attempt to wait for 390 * completion in order to be able to correctly track the lock 391 * state. 392 */ 393 static int nlmclnt_async_call(struct rpc_cred *cred, struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops) 394 { 395 struct rpc_message msg = { 396 .rpc_argp = &req->a_args, 397 .rpc_resp = &req->a_res, 398 .rpc_cred = cred, 399 }; 400 struct rpc_task *task; 401 int err; 402 403 task = __nlm_async_call(req, proc, &msg, tk_ops); 404 if (IS_ERR(task)) 405 return PTR_ERR(task); 406 err = rpc_wait_for_completion_task(task); 407 rpc_put_task(task); 408 return err; 409 } 410 411 /* 412 * TEST for the presence of a conflicting lock 413 */ 414 static int 415 nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl) 416 { 417 int status; 418 419 status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_TEST); 420 if (status < 0) 421 goto out; 422 423 switch (req->a_res.status) { 424 case nlm_granted: 425 fl->fl_type = F_UNLCK; 426 break; 427 case nlm_lck_denied: 428 /* 429 * Report the conflicting lock back to the application. 430 */ 431 fl->fl_start = req->a_res.lock.fl.fl_start; 432 fl->fl_end = req->a_res.lock.fl.fl_end; 433 fl->fl_type = req->a_res.lock.fl.fl_type; 434 fl->fl_pid = 0; 435 break; 436 default: 437 status = nlm_stat_to_errno(req->a_res.status); 438 } 439 out: 440 nlmclnt_release_call(req); 441 return status; 442 } 443 444 static void nlmclnt_locks_copy_lock(struct file_lock *new, struct file_lock *fl) 445 { 446 spin_lock(&fl->fl_u.nfs_fl.owner->host->h_lock); 447 new->fl_u.nfs_fl.state = fl->fl_u.nfs_fl.state; 448 new->fl_u.nfs_fl.owner = nlm_get_lockowner(fl->fl_u.nfs_fl.owner); 449 list_add_tail(&new->fl_u.nfs_fl.list, &fl->fl_u.nfs_fl.owner->host->h_granted); 450 spin_unlock(&fl->fl_u.nfs_fl.owner->host->h_lock); 451 } 452 453 static void nlmclnt_locks_release_private(struct file_lock *fl) 454 { 455 spin_lock(&fl->fl_u.nfs_fl.owner->host->h_lock); 456 list_del(&fl->fl_u.nfs_fl.list); 457 spin_unlock(&fl->fl_u.nfs_fl.owner->host->h_lock); 458 nlm_put_lockowner(fl->fl_u.nfs_fl.owner); 459 } 460 461 static const struct file_lock_operations nlmclnt_lock_ops = { 462 .fl_copy_lock = nlmclnt_locks_copy_lock, 463 .fl_release_private = nlmclnt_locks_release_private, 464 }; 465 466 static void nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *host) 467 { 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 nlmclnt_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 struct nlm_rqst *req) 620 { 621 int status; 622 623 memset(req, 0, sizeof(*req)); 624 locks_init_lock(&req->a_args.lock.fl); 625 locks_init_lock(&req->a_res.lock.fl); 626 req->a_host = host; 627 628 /* Set up the argument struct */ 629 nlmclnt_setlockargs(req, fl); 630 req->a_args.reclaim = 1; 631 632 status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_LOCK); 633 if (status >= 0 && req->a_res.status == nlm_granted) 634 return 0; 635 636 printk(KERN_WARNING "lockd: failed to reclaim lock for pid %d " 637 "(errno %d, status %d)\n", fl->fl_pid, 638 status, ntohl(req->a_res.status)); 639 640 /* 641 * FIXME: This is a serious failure. We can 642 * 643 * a. Ignore the problem 644 * b. Send the owning process some signal (Linux doesn't have 645 * SIGLOST, though...) 646 * c. Retry the operation 647 * 648 * Until someone comes up with a simple implementation 649 * for b or c, I'll choose option a. 650 */ 651 652 return -ENOLCK; 653 } 654 655 /* 656 * UNLOCK: remove an existing lock 657 */ 658 static int 659 nlmclnt_unlock(struct nlm_rqst *req, struct file_lock *fl) 660 { 661 struct nlm_host *host = req->a_host; 662 struct nlm_res *resp = &req->a_res; 663 int status; 664 unsigned char fl_flags = fl->fl_flags; 665 666 /* 667 * Note: the server is supposed to either grant us the unlock 668 * request, or to deny it with NLM_LCK_DENIED_GRACE_PERIOD. In either 669 * case, we want to unlock. 670 */ 671 fl->fl_flags |= FL_EXISTS; 672 down_read(&host->h_rwsem); 673 status = do_vfs_lock(fl); 674 up_read(&host->h_rwsem); 675 fl->fl_flags = fl_flags; 676 if (status == -ENOENT) { 677 status = 0; 678 goto out; 679 } 680 681 atomic_inc(&req->a_count); 682 status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req, 683 NLMPROC_UNLOCK, &nlmclnt_unlock_ops); 684 if (status < 0) 685 goto out; 686 687 if (resp->status == nlm_granted) 688 goto out; 689 690 if (resp->status != nlm_lck_denied_nolocks) 691 printk("lockd: unexpected unlock status: %d\n", 692 ntohl(resp->status)); 693 /* What to do now? I'm out of my depth... */ 694 status = -ENOLCK; 695 out: 696 nlmclnt_release_call(req); 697 return status; 698 } 699 700 static void nlmclnt_unlock_callback(struct rpc_task *task, void *data) 701 { 702 struct nlm_rqst *req = data; 703 u32 status = ntohl(req->a_res.status); 704 705 if (RPC_ASSASSINATED(task)) 706 goto die; 707 708 if (task->tk_status < 0) { 709 dprintk("lockd: unlock failed (err = %d)\n", -task->tk_status); 710 switch (task->tk_status) { 711 case -EACCES: 712 case -EIO: 713 goto die; 714 default: 715 goto retry_rebind; 716 } 717 } 718 if (status == NLM_LCK_DENIED_GRACE_PERIOD) { 719 rpc_delay(task, NLMCLNT_GRACE_WAIT); 720 goto retry_unlock; 721 } 722 if (status != NLM_LCK_GRANTED) 723 printk(KERN_WARNING "lockd: unexpected unlock status: %d\n", status); 724 die: 725 return; 726 retry_rebind: 727 nlm_rebind_host(req->a_host); 728 retry_unlock: 729 rpc_restart_call(task); 730 } 731 732 static const struct rpc_call_ops nlmclnt_unlock_ops = { 733 .rpc_call_done = nlmclnt_unlock_callback, 734 .rpc_release = nlmclnt_rpc_release, 735 }; 736 737 /* 738 * Cancel a blocked lock request. 739 * We always use an async RPC call for this in order not to hang a 740 * process that has been Ctrl-C'ed. 741 */ 742 static int nlmclnt_cancel(struct nlm_host *host, int block, struct file_lock *fl) 743 { 744 struct nlm_rqst *req; 745 int status; 746 747 dprintk("lockd: blocking lock attempt was interrupted by a signal.\n" 748 " Attempting to cancel lock.\n"); 749 750 req = nlm_alloc_call(host); 751 if (!req) 752 return -ENOMEM; 753 req->a_flags = RPC_TASK_ASYNC; 754 755 nlmclnt_setlockargs(req, fl); 756 req->a_args.block = block; 757 758 atomic_inc(&req->a_count); 759 status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req, 760 NLMPROC_CANCEL, &nlmclnt_cancel_ops); 761 if (status == 0 && req->a_res.status == nlm_lck_denied) 762 status = -ENOLCK; 763 nlmclnt_release_call(req); 764 return status; 765 } 766 767 static void nlmclnt_cancel_callback(struct rpc_task *task, void *data) 768 { 769 struct nlm_rqst *req = data; 770 u32 status = ntohl(req->a_res.status); 771 772 if (RPC_ASSASSINATED(task)) 773 goto die; 774 775 if (task->tk_status < 0) { 776 dprintk("lockd: CANCEL call error %d, retrying.\n", 777 task->tk_status); 778 goto retry_cancel; 779 } 780 781 dprintk("lockd: cancel status %u (task %u)\n", 782 status, task->tk_pid); 783 784 switch (status) { 785 case NLM_LCK_GRANTED: 786 case NLM_LCK_DENIED_GRACE_PERIOD: 787 case NLM_LCK_DENIED: 788 /* Everything's good */ 789 break; 790 case NLM_LCK_DENIED_NOLOCKS: 791 dprintk("lockd: CANCEL failed (server has no locks)\n"); 792 goto retry_cancel; 793 default: 794 printk(KERN_NOTICE "lockd: weird return %d for CANCEL call\n", 795 status); 796 } 797 798 die: 799 return; 800 801 retry_cancel: 802 /* Don't ever retry more than 3 times */ 803 if (req->a_retries++ >= NLMCLNT_MAX_RETRIES) 804 goto die; 805 nlm_rebind_host(req->a_host); 806 rpc_restart_call(task); 807 rpc_delay(task, 30 * HZ); 808 } 809 810 static const struct rpc_call_ops nlmclnt_cancel_ops = { 811 .rpc_call_done = nlmclnt_cancel_callback, 812 .rpc_release = nlmclnt_rpc_release, 813 }; 814 815 /* 816 * Convert an NLM status code to a generic kernel errno 817 */ 818 static int 819 nlm_stat_to_errno(__be32 status) 820 { 821 switch(ntohl(status)) { 822 case NLM_LCK_GRANTED: 823 return 0; 824 case NLM_LCK_DENIED: 825 return -EAGAIN; 826 case NLM_LCK_DENIED_NOLOCKS: 827 case NLM_LCK_DENIED_GRACE_PERIOD: 828 return -ENOLCK; 829 case NLM_LCK_BLOCKED: 830 printk(KERN_NOTICE "lockd: unexpected status NLM_BLOCKED\n"); 831 return -ENOLCK; 832 #ifdef CONFIG_LOCKD_V4 833 case NLM_DEADLCK: 834 return -EDEADLK; 835 case NLM_ROFS: 836 return -EROFS; 837 case NLM_STALE_FH: 838 return -ESTALE; 839 case NLM_FBIG: 840 return -EOVERFLOW; 841 case NLM_FAILED: 842 return -ENOLCK; 843 #endif 844 } 845 printk(KERN_NOTICE "lockd: unexpected server status %d\n", 846 ntohl(status)); 847 return -ENOLCK; 848 } 849