2 * linux/fs/lockd/clntproc.c
4 * RPC procedures for the client side NLM implementation
6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
9 #include <linux/module.h>
10 #include <linux/types.h>
11 #include <linux/errno.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>
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
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
*);
32 static const struct rpc_call_ops nlmclnt_unlock_ops
;
33 static const struct rpc_call_ops nlmclnt_cancel_ops
;
36 * Cookie counter for NLM requests
38 static atomic_t nlm_cookie
= ATOMIC_INIT(0x1234);
40 void nlmclnt_next_cookie(struct nlm_cookie
*c
)
42 u32 cookie
= atomic_inc_return(&nlm_cookie
);
44 memcpy(c
->data
, &cookie
, 4);
48 static struct nlm_lockowner
*nlm_get_lockowner(struct nlm_lockowner
*lockowner
)
50 atomic_inc(&lockowner
->count
);
54 static void nlm_put_lockowner(struct nlm_lockowner
*lockowner
)
56 if (!atomic_dec_and_lock(&lockowner
->count
, &lockowner
->host
->h_lock
))
58 list_del(&lockowner
->list
);
59 spin_unlock(&lockowner
->host
->h_lock
);
60 nlm_release_host(lockowner
->host
);
64 static inline int nlm_pidbusy(struct nlm_host
*host
, uint32_t pid
)
66 struct nlm_lockowner
*lockowner
;
67 list_for_each_entry(lockowner
, &host
->h_lockowners
, list
) {
68 if (lockowner
->pid
== pid
)
74 static inline uint32_t __nlm_alloc_pid(struct nlm_host
*host
)
78 res
= host
->h_pidcount
++;
79 } while (nlm_pidbusy(host
, res
) < 0);
83 static struct nlm_lockowner
*__nlm_find_lockowner(struct nlm_host
*host
, fl_owner_t owner
)
85 struct nlm_lockowner
*lockowner
;
86 list_for_each_entry(lockowner
, &host
->h_lockowners
, list
) {
87 if (lockowner
->owner
!= owner
)
89 return nlm_get_lockowner(lockowner
);
94 static struct nlm_lockowner
*nlm_find_lockowner(struct nlm_host
*host
, fl_owner_t owner
)
96 struct nlm_lockowner
*res
, *new = NULL
;
98 spin_lock(&host
->h_lock
);
99 res
= __nlm_find_lockowner(host
, owner
);
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
) {
107 atomic_set(&new->count
, 1);
109 new->pid
= __nlm_alloc_pid(host
);
110 new->host
= nlm_get_host(host
);
111 list_add(&new->list
, &host
->h_lockowners
);
115 spin_unlock(&host
->h_lock
);
121 * Initialize arguments for TEST/LOCK/UNLOCK/CANCEL calls
123 static void nlmclnt_setlockargs(struct nlm_rqst
*req
, struct file_lock
*fl
)
125 struct nlm_args
*argp
= &req
->a_args
;
126 struct nlm_lock
*lock
= &argp
->lock
;
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
;
141 static void nlmclnt_release_lockargs(struct nlm_rqst
*req
)
143 BUG_ON(req
->a_args
.lock
.fl
.fl_ops
!= NULL
);
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
153 int nlmclnt_proc(struct nlm_host
*host
, int cmd
, struct file_lock
*fl
)
155 struct nlm_rqst
*call
;
159 call
= nlm_alloc_call(host
);
163 nlmclnt_locks_init_private(fl
, host
);
164 /* Set up the argument struct */
165 nlmclnt_setlockargs(call
, fl
);
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
);
173 status
= nlmclnt_unlock(call
, fl
);
174 } else if (IS_GETLK(cmd
))
175 status
= nlmclnt_test(call
, fl
);
179 fl
->fl_ops
->fl_release_private(fl
);
183 dprintk("lockd: clnt proc returns %d\n", status
);
186 EXPORT_SYMBOL_GPL(nlmclnt_proc
);
189 * Allocate an NLM RPC call struct
191 * Note: the caller must hold a reference to host. In case of failure,
192 * this reference will be released.
194 struct nlm_rqst
*nlm_alloc_call(struct nlm_host
*host
)
196 struct nlm_rqst
*call
;
199 call
= kzalloc(sizeof(*call
), GFP_KERNEL
);
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
);
209 printk("nlm_alloc_call: failed, waiting for memory\n");
210 schedule_timeout_interruptible(5*HZ
);
212 nlm_release_host(host
);
216 void nlm_release_call(struct nlm_rqst
*call
)
218 if (!atomic_dec_and_test(&call
->a_count
))
220 nlm_release_host(call
->a_host
);
221 nlmclnt_release_lockargs(call
);
225 static void nlmclnt_rpc_release(void *data
)
228 nlm_release_call(data
);
232 static int nlm_wait_on_grace(wait_queue_head_t
*queue
)
237 prepare_to_wait(queue
, &wait
, TASK_INTERRUPTIBLE
);
239 schedule_timeout(NLMCLNT_GRACE_WAIT
);
244 finish_wait(queue
, &wait
);
252 nlmclnt_call(struct rpc_cred
*cred
, struct nlm_rqst
*req
, u32 proc
)
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
= {
265 dprintk("lockd: call procedure %d on %s\n",
266 (int)proc
, host
->h_name
);
269 if (host
->h_reclaiming
&& !argp
->reclaim
)
270 goto in_grace_period
;
272 /* If we have no RPC client yet, create one. */
273 if ((clnt
= nlm_bind_host(host
)) == NULL
)
275 msg
.rpc_proc
= &clnt
->cl_procinfo
[proc
];
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
);
281 case -EPROTONOSUPPORT
:
287 nlm_rebind_host(host
);
291 return signalled () ? -EINTR
: status
;
297 if (resp
->status
== nlm_lck_denied_grace_period
) {
298 dprintk("lockd: server in grace period\n");
301 "lockd: spurious grace period reject?!\n");
305 if (!argp
->reclaim
) {
306 /* We appear to be out of the grace period */
307 wake_up_all(&host
->h_gracewait
);
309 dprintk("lockd: server returns status %d\n", resp
->status
);
310 return 0; /* Okay, call complete */
315 * The server has rebooted and appears to be in the grace
316 * period during which locks are only allowed to be
318 * We can only back off and try again later.
320 status
= nlm_wait_on_grace(&host
->h_gracewait
);
321 } while (status
== 0);
327 * Generic NLM call, async version.
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
)
331 struct nlm_host
*host
= req
->a_host
;
332 struct rpc_clnt
*clnt
;
333 struct rpc_task_setup task_setup_data
= {
335 .callback_ops
= tk_ops
,
336 .callback_data
= req
,
337 .flags
= RPC_TASK_ASYNC
,
340 dprintk("lockd: call procedure %d on %s (async)\n",
341 (int)proc
, host
->h_name
);
343 /* If we have no RPC client yet, create one. */
344 clnt
= nlm_bind_host(host
);
347 msg
->rpc_proc
= &clnt
->cl_procinfo
[proc
];
348 task_setup_data
.rpc_client
= clnt
;
350 /* bootstrap and kick off the async RPC call */
351 return rpc_run_task(&task_setup_data
);
353 tk_ops
->rpc_release(req
);
354 return ERR_PTR(-ENOLCK
);
357 static int nlm_do_async_call(struct nlm_rqst
*req
, u32 proc
, struct rpc_message
*msg
, const struct rpc_call_ops
*tk_ops
)
359 struct rpc_task
*task
;
361 task
= __nlm_async_call(req
, proc
, msg
, tk_ops
);
363 return PTR_ERR(task
);
369 * NLM asynchronous call.
371 int nlm_async_call(struct nlm_rqst
*req
, u32 proc
, const struct rpc_call_ops
*tk_ops
)
373 struct rpc_message msg
= {
374 .rpc_argp
= &req
->a_args
,
375 .rpc_resp
= &req
->a_res
,
377 return nlm_do_async_call(req
, proc
, &msg
, tk_ops
);
380 int nlm_async_reply(struct nlm_rqst
*req
, u32 proc
, const struct rpc_call_ops
*tk_ops
)
382 struct rpc_message msg
= {
383 .rpc_argp
= &req
->a_res
,
385 return nlm_do_async_call(req
, proc
, &msg
, tk_ops
);
389 * NLM client asynchronous call.
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
396 static int nlmclnt_async_call(struct rpc_cred
*cred
, struct nlm_rqst
*req
, u32 proc
, const struct rpc_call_ops
*tk_ops
)
398 struct rpc_message msg
= {
399 .rpc_argp
= &req
->a_args
,
400 .rpc_resp
= &req
->a_res
,
403 struct rpc_task
*task
;
406 task
= __nlm_async_call(req
, proc
, &msg
, tk_ops
);
408 return PTR_ERR(task
);
409 err
= rpc_wait_for_completion_task(task
);
415 * TEST for the presence of a conflicting lock
418 nlmclnt_test(struct nlm_rqst
*req
, struct file_lock
*fl
)
422 status
= nlmclnt_call(nfs_file_cred(fl
->fl_file
), req
, NLMPROC_TEST
);
426 switch (req
->a_res
.status
) {
428 fl
->fl_type
= F_UNLCK
;
432 * Report the conflicting lock back to the application.
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
;
440 status
= nlm_stat_to_errno(req
->a_res
.status
);
443 nlm_release_call(req
);
447 static void nlmclnt_locks_copy_lock(struct file_lock
*new, struct file_lock
*fl
)
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
);
454 static void nlmclnt_locks_release_private(struct file_lock
*fl
)
456 list_del(&fl
->fl_u
.nfs_fl
.list
);
457 nlm_put_lockowner(fl
->fl_u
.nfs_fl
.owner
);
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
,
465 static void nlmclnt_locks_init_private(struct file_lock
*fl
, struct nlm_host
*host
)
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
;
474 static int do_vfs_lock(struct file_lock
*fl
)
477 switch (fl
->fl_flags
& (FL_POSIX
|FL_FLOCK
)) {
479 res
= posix_lock_file_wait(fl
->fl_file
, fl
);
482 res
= flock_lock_file_wait(fl
->fl_file
, fl
);
491 * LOCK: Try to create a lock
493 * Programmer Harassment Alert
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.
500 * Solution A: Implement busy-waiting
501 * Solution B: Use the async version of the call (NLM_LOCK_{MSG,RES})
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.
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.
511 nlmclnt_lock(struct nlm_rqst
*req
, struct file_lock
*fl
)
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
;
521 if (nsm_monitor(host
) < 0)
523 req
->a_args
.state
= nsm_local_state
;
525 fl
->fl_flags
|= FL_ACCESS
;
526 status
= do_vfs_lock(fl
);
527 fl
->fl_flags
= fl_flags
;
531 block
= nlmclnt_prepare_block(host
, fl
);
534 * Initialise resp->status to a valid non-zero value,
535 * since 0 == nlm_lck_granted
537 resp
->status
= nlm_lck_blocked
;
539 /* Reboot protection */
540 fl
->fl_u
.nfs_fl
.state
= host
->h_state
;
541 status
= nlmclnt_call(cred
, req
, NLMPROC_LOCK
);
544 /* Did a reclaimer thread notify us of a server reboot? */
545 if (resp
->status
== nlm_lck_denied_grace_period
)
547 if (resp
->status
!= nlm_lck_blocked
)
549 /* Wait on an NLM blocking lock */
550 status
= nlmclnt_block(block
, req
, NLMCLNT_POLL_TIMEOUT
);
553 if (resp
->status
!= nlm_lck_blocked
)
557 /* if we were interrupted while blocking, then cancel the lock request
560 if (resp
->status
== nlm_lck_blocked
) {
561 if (!req
->a_args
.block
)
563 if (nlmclnt_cancel(host
, req
->a_args
.block
, fl
) == 0)
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
);
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
;
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.
589 if (resp
->status
== nlm_lck_denied
&& (fl_flags
& FL_SLEEP
))
592 status
= nlm_stat_to_errno(resp
->status
);
594 nlmclnt_finish_block(block
);
596 nlm_release_call(req
);
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
);
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
);
615 * RECLAIM: Try to reclaim a lock
618 nlmclnt_reclaim(struct nlm_host
*host
, struct file_lock
*fl
)
620 struct nlm_rqst reqst
, *req
;
624 memset(req
, 0, sizeof(*req
));
625 locks_init_lock(&req
->a_args
.lock
.fl
);
626 locks_init_lock(&req
->a_res
.lock
.fl
);
630 /* Set up the argument struct */
631 nlmclnt_setlockargs(req
, fl
);
632 req
->a_args
.reclaim
= 1;
634 status
= nlmclnt_call(nfs_file_cred(fl
->fl_file
), req
, NLMPROC_LOCK
);
635 if (status
>= 0 && req
->a_res
.status
== nlm_granted
)
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
));
643 * FIXME: This is a serious failure. We can
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
650 * Until someone comes up with a simple implementation
651 * for b or c, I'll choose option a.
658 * UNLOCK: remove an existing lock
661 nlmclnt_unlock(struct nlm_rqst
*req
, struct file_lock
*fl
)
663 struct nlm_host
*host
= req
->a_host
;
664 struct nlm_res
*resp
= &req
->a_res
;
666 unsigned char fl_flags
= fl
->fl_flags
;
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.
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
) {
683 atomic_inc(&req
->a_count
);
684 status
= nlmclnt_async_call(nfs_file_cred(fl
->fl_file
), req
,
685 NLMPROC_UNLOCK
, &nlmclnt_unlock_ops
);
689 if (resp
->status
== nlm_granted
)
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... */
697 nlm_release_call(req
);
701 static void nlmclnt_unlock_callback(struct rpc_task
*task
, void *data
)
703 struct nlm_rqst
*req
= data
;
704 u32 status
= ntohl(req
->a_res
.status
);
706 if (RPC_ASSASSINATED(task
))
709 if (task
->tk_status
< 0) {
710 dprintk("lockd: unlock failed (err = %d)\n", -task
->tk_status
);
713 if (status
== NLM_LCK_DENIED_GRACE_PERIOD
) {
714 rpc_delay(task
, NLMCLNT_GRACE_WAIT
);
717 if (status
!= NLM_LCK_GRANTED
)
718 printk(KERN_WARNING
"lockd: unexpected unlock status: %d\n", status
);
723 nlm_rebind_host(req
->a_host
);
726 rpc_restart_call(task
);
729 static const struct rpc_call_ops nlmclnt_unlock_ops
= {
730 .rpc_call_done
= nlmclnt_unlock_callback
,
731 .rpc_release
= nlmclnt_rpc_release
,
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.
739 static int nlmclnt_cancel(struct nlm_host
*host
, int block
, struct file_lock
*fl
)
741 struct nlm_rqst
*req
;
744 dprintk("lockd: blocking lock attempt was interrupted by a signal.\n"
745 " Attempting to cancel lock.\n");
747 req
= nlm_alloc_call(nlm_get_host(host
));
750 req
->a_flags
= RPC_TASK_ASYNC
;
752 nlmclnt_setlockargs(req
, fl
);
753 req
->a_args
.block
= block
;
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
)
760 nlm_release_call(req
);
764 static void nlmclnt_cancel_callback(struct rpc_task
*task
, void *data
)
766 struct nlm_rqst
*req
= data
;
767 u32 status
= ntohl(req
->a_res
.status
);
769 if (RPC_ASSASSINATED(task
))
772 if (task
->tk_status
< 0) {
773 dprintk("lockd: CANCEL call error %d, retrying.\n",
778 dprintk("lockd: cancel status %u (task %u)\n",
779 status
, task
->tk_pid
);
782 case NLM_LCK_GRANTED
:
783 case NLM_LCK_DENIED_GRACE_PERIOD
:
785 /* Everything's good */
787 case NLM_LCK_DENIED_NOLOCKS
:
788 dprintk("lockd: CANCEL failed (server has no locks)\n");
791 printk(KERN_NOTICE
"lockd: weird return %d for CANCEL call\n",
799 /* Don't ever retry more than 3 times */
800 if (req
->a_retries
++ >= NLMCLNT_MAX_RETRIES
)
803 nlm_rebind_host(req
->a_host
);
805 rpc_restart_call(task
);
806 rpc_delay(task
, 30 * HZ
);
809 static const struct rpc_call_ops nlmclnt_cancel_ops
= {
810 .rpc_call_done
= nlmclnt_cancel_callback
,
811 .rpc_release
= nlmclnt_rpc_release
,
815 * Convert an NLM status code to a generic kernel errno
818 nlm_stat_to_errno(__be32 status
)
820 switch(ntohl(status
)) {
821 case NLM_LCK_GRANTED
:
825 case NLM_LCK_DENIED_NOLOCKS
:
826 case NLM_LCK_DENIED_GRACE_PERIOD
:
828 case NLM_LCK_BLOCKED
:
829 printk(KERN_NOTICE
"lockd: unexpected status NLM_BLOCKED\n");
831 #ifdef CONFIG_LOCKD_V4
844 printk(KERN_NOTICE
"lockd: unexpected server status %d\n", status
);