xref: /openbmc/linux/fs/lockd/clntproc.c (revision 9ac8d3fb)
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 #include <linux/lockd/sm_inter.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 	nlm_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 	argp->state   = nsm_local_state;
131 	memcpy(&lock->fh, NFS_FH(fl->fl_file->f_path.dentry->d_inode), sizeof(struct nfs_fh));
132 	lock->caller  = utsname()->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 				utsname()->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 
143 static void nlmclnt_release_lockargs(struct nlm_rqst *req)
144 {
145 	BUG_ON(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  */
155 int nlmclnt_proc(struct nlm_host *host, int cmd, struct file_lock *fl)
156 {
157 	struct nlm_rqst		*call;
158 	int			status;
159 
160 	nlm_get_host(host);
161 	call = nlm_alloc_call(host);
162 	if (call == NULL)
163 		return -ENOMEM;
164 
165 	nlmclnt_locks_init_private(fl, host);
166 	/* Set up the argument struct */
167 	nlmclnt_setlockargs(call, fl);
168 
169 	if (IS_SETLK(cmd) || IS_SETLKW(cmd)) {
170 		if (fl->fl_type != F_UNLCK) {
171 			call->a_args.block = IS_SETLKW(cmd) ? 1 : 0;
172 			status = nlmclnt_lock(call, fl);
173 		} else
174 			status = nlmclnt_unlock(call, fl);
175 	} else if (IS_GETLK(cmd))
176 		status = nlmclnt_test(call, fl);
177 	else
178 		status = -EINVAL;
179 
180 	fl->fl_ops->fl_release_private(fl);
181 	fl->fl_ops = NULL;
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 		printk(KERN_NOTICE "lockd: failed to monitor %s\n",
523 					host->h_name);
524 		goto out;
525 	}
526 	fl->fl_flags |= FL_ACCESS;
527 	status = do_vfs_lock(fl);
528 	fl->fl_flags = fl_flags;
529 	if (status < 0)
530 		goto out;
531 
532 	block = nlmclnt_prepare_block(host, fl);
533 again:
534 	/*
535 	 * Initialise resp->status to a valid non-zero value,
536 	 * since 0 == nlm_lck_granted
537 	 */
538 	resp->status = nlm_lck_blocked;
539 	for(;;) {
540 		/* Reboot protection */
541 		fl->fl_u.nfs_fl.state = host->h_state;
542 		status = nlmclnt_call(cred, req, NLMPROC_LOCK);
543 		if (status < 0)
544 			break;
545 		/* Did a reclaimer thread notify us of a server reboot? */
546 		if (resp->status ==  nlm_lck_denied_grace_period)
547 			continue;
548 		if (resp->status != nlm_lck_blocked)
549 			break;
550 		/* Wait on an NLM blocking lock */
551 		status = nlmclnt_block(block, req, NLMCLNT_POLL_TIMEOUT);
552 		if (status < 0)
553 			break;
554 		if (resp->status != nlm_lck_blocked)
555 			break;
556 	}
557 
558 	/* if we were interrupted while blocking, then cancel the lock request
559 	 * and exit
560 	 */
561 	if (resp->status == nlm_lck_blocked) {
562 		if (!req->a_args.block)
563 			goto out_unlock;
564 		if (nlmclnt_cancel(host, req->a_args.block, fl) == 0)
565 			goto out_unblock;
566 	}
567 
568 	if (resp->status == nlm_granted) {
569 		down_read(&host->h_rwsem);
570 		/* Check whether or not the server has rebooted */
571 		if (fl->fl_u.nfs_fl.state != host->h_state) {
572 			up_read(&host->h_rwsem);
573 			goto again;
574 		}
575 		/* Ensure the resulting lock will get added to granted list */
576 		fl->fl_flags |= FL_SLEEP;
577 		if (do_vfs_lock(fl) < 0)
578 			printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__);
579 		up_read(&host->h_rwsem);
580 		fl->fl_flags = fl_flags;
581 		status = 0;
582 	}
583 	if (status < 0)
584 		goto out_unlock;
585 	/*
586 	 * EAGAIN doesn't make sense for sleeping locks, and in some
587 	 * cases NLM_LCK_DENIED is returned for a permanent error.  So
588 	 * turn it into an ENOLCK.
589 	 */
590 	if (resp->status == nlm_lck_denied && (fl_flags & FL_SLEEP))
591 		status = -ENOLCK;
592 	else
593 		status = nlm_stat_to_errno(resp->status);
594 out_unblock:
595 	nlmclnt_finish_block(block);
596 out:
597 	nlm_release_call(req);
598 	return status;
599 out_unlock:
600 	/* Fatal error: ensure that we remove the lock altogether */
601 	dprintk("lockd: lock attempt ended in fatal error.\n"
602 		"       Attempting to unlock.\n");
603 	nlmclnt_finish_block(block);
604 	fl_type = fl->fl_type;
605 	fl->fl_type = F_UNLCK;
606 	down_read(&host->h_rwsem);
607 	do_vfs_lock(fl);
608 	up_read(&host->h_rwsem);
609 	fl->fl_type = fl_type;
610 	fl->fl_flags = fl_flags;
611 	nlmclnt_async_call(cred, req, NLMPROC_UNLOCK, &nlmclnt_unlock_ops);
612 	return status;
613 }
614 
615 /*
616  * RECLAIM: Try to reclaim a lock
617  */
618 int
619 nlmclnt_reclaim(struct nlm_host *host, struct file_lock *fl)
620 {
621 	struct nlm_rqst reqst, *req;
622 	int		status;
623 
624 	req = &reqst;
625 	memset(req, 0, sizeof(*req));
626 	locks_init_lock(&req->a_args.lock.fl);
627 	locks_init_lock(&req->a_res.lock.fl);
628 	req->a_host  = host;
629 	req->a_flags = 0;
630 
631 	/* Set up the argument struct */
632 	nlmclnt_setlockargs(req, fl);
633 	req->a_args.reclaim = 1;
634 
635 	status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_LOCK);
636 	if (status >= 0 && req->a_res.status == nlm_granted)
637 		return 0;
638 
639 	printk(KERN_WARNING "lockd: failed to reclaim lock for pid %d "
640 				"(errno %d, status %d)\n", fl->fl_pid,
641 				status, ntohl(req->a_res.status));
642 
643 	/*
644 	 * FIXME: This is a serious failure. We can
645 	 *
646 	 *  a.	Ignore the problem
647 	 *  b.	Send the owning process some signal (Linux doesn't have
648 	 *	SIGLOST, though...)
649 	 *  c.	Retry the operation
650 	 *
651 	 * Until someone comes up with a simple implementation
652 	 * for b or c, I'll choose option a.
653 	 */
654 
655 	return -ENOLCK;
656 }
657 
658 /*
659  * UNLOCK: remove an existing lock
660  */
661 static int
662 nlmclnt_unlock(struct nlm_rqst *req, struct file_lock *fl)
663 {
664 	struct nlm_host	*host = req->a_host;
665 	struct nlm_res	*resp = &req->a_res;
666 	int status;
667 	unsigned char fl_flags = fl->fl_flags;
668 
669 	/*
670 	 * Note: the server is supposed to either grant us the unlock
671 	 * request, or to deny it with NLM_LCK_DENIED_GRACE_PERIOD. In either
672 	 * case, we want to unlock.
673 	 */
674 	fl->fl_flags |= FL_EXISTS;
675 	down_read(&host->h_rwsem);
676 	status = do_vfs_lock(fl);
677 	up_read(&host->h_rwsem);
678 	fl->fl_flags = fl_flags;
679 	if (status == -ENOENT) {
680 		status = 0;
681 		goto out;
682 	}
683 
684 	atomic_inc(&req->a_count);
685 	status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req,
686 			NLMPROC_UNLOCK, &nlmclnt_unlock_ops);
687 	if (status < 0)
688 		goto out;
689 
690 	if (resp->status == nlm_granted)
691 		goto out;
692 
693 	if (resp->status != nlm_lck_denied_nolocks)
694 		printk("lockd: unexpected unlock status: %d\n", resp->status);
695 	/* What to do now? I'm out of my depth... */
696 	status = -ENOLCK;
697 out:
698 	nlm_release_call(req);
699 	return status;
700 }
701 
702 static void nlmclnt_unlock_callback(struct rpc_task *task, void *data)
703 {
704 	struct nlm_rqst	*req = data;
705 	u32 status = ntohl(req->a_res.status);
706 
707 	if (RPC_ASSASSINATED(task))
708 		goto die;
709 
710 	if (task->tk_status < 0) {
711 		dprintk("lockd: unlock failed (err = %d)\n", -task->tk_status);
712 		goto retry_rebind;
713 	}
714 	if (status == NLM_LCK_DENIED_GRACE_PERIOD) {
715 		rpc_delay(task, NLMCLNT_GRACE_WAIT);
716 		goto retry_unlock;
717 	}
718 	if (status != NLM_LCK_GRANTED)
719 		printk(KERN_WARNING "lockd: unexpected unlock status: %d\n", status);
720 die:
721 	return;
722  retry_rebind:
723 	lock_kernel();
724 	nlm_rebind_host(req->a_host);
725 	unlock_kernel();
726  retry_unlock:
727 	rpc_restart_call(task);
728 }
729 
730 static const struct rpc_call_ops nlmclnt_unlock_ops = {
731 	.rpc_call_done = nlmclnt_unlock_callback,
732 	.rpc_release = nlmclnt_rpc_release,
733 };
734 
735 /*
736  * Cancel a blocked lock request.
737  * We always use an async RPC call for this in order not to hang a
738  * process that has been Ctrl-C'ed.
739  */
740 static int nlmclnt_cancel(struct nlm_host *host, int block, struct file_lock *fl)
741 {
742 	struct nlm_rqst	*req;
743 	int status;
744 
745 	dprintk("lockd: blocking lock attempt was interrupted by a signal.\n"
746 		"       Attempting to cancel lock.\n");
747 
748 	req = nlm_alloc_call(nlm_get_host(host));
749 	if (!req)
750 		return -ENOMEM;
751 	req->a_flags = RPC_TASK_ASYNC;
752 
753 	nlmclnt_setlockargs(req, fl);
754 	req->a_args.block = block;
755 
756 	atomic_inc(&req->a_count);
757 	status = nlmclnt_async_call(nfs_file_cred(fl->fl_file), req,
758 			NLMPROC_CANCEL, &nlmclnt_cancel_ops);
759 	if (status == 0 && req->a_res.status == nlm_lck_denied)
760 		status = -ENOLCK;
761 	nlm_release_call(req);
762 	return status;
763 }
764 
765 static void nlmclnt_cancel_callback(struct rpc_task *task, void *data)
766 {
767 	struct nlm_rqst	*req = data;
768 	u32 status = ntohl(req->a_res.status);
769 
770 	if (RPC_ASSASSINATED(task))
771 		goto die;
772 
773 	if (task->tk_status < 0) {
774 		dprintk("lockd: CANCEL call error %d, retrying.\n",
775 					task->tk_status);
776 		goto retry_cancel;
777 	}
778 
779 	dprintk("lockd: cancel status %u (task %u)\n",
780 			status, task->tk_pid);
781 
782 	switch (status) {
783 	case NLM_LCK_GRANTED:
784 	case NLM_LCK_DENIED_GRACE_PERIOD:
785 	case NLM_LCK_DENIED:
786 		/* Everything's good */
787 		break;
788 	case NLM_LCK_DENIED_NOLOCKS:
789 		dprintk("lockd: CANCEL failed (server has no locks)\n");
790 		goto retry_cancel;
791 	default:
792 		printk(KERN_NOTICE "lockd: weird return %d for CANCEL call\n",
793 			status);
794 	}
795 
796 die:
797 	return;
798 
799 retry_cancel:
800 	/* Don't ever retry more than 3 times */
801 	if (req->a_retries++ >= NLMCLNT_MAX_RETRIES)
802 		goto die;
803 	lock_kernel();
804 	nlm_rebind_host(req->a_host);
805 	unlock_kernel();
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", status);
846 	return -ENOLCK;
847 }
848